nx/nxpath/parser.hpp

Go to the documentation of this file.

//
// (c) Copyright 2014 DESY, Eugen Wintersberger <eugen.wintersberger@desy.de>
//
// This file is part of libpniio.
//
// libpniio is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 2 of the License, or
// (at your option) any later version.
//
// libpniio is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with libpniio.  If not, see <http://www.gnu.org/licenses/>.
// ===========================================================================
//
// Created on: Jun 10, 2014
//     Author: Eugen Wintersberger <eugen.wintersberger@desy.de>
//
#pragma once
#include "nxpath.hpp"
#include "insert.hpp"

#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix.hpp>
#include <boost/fusion/include/std_pair.hpp>
#include <utility>


namespace pni{
namespace io{
namespace nx{

//add here an additional namespace to avoid namespace polution from the boost
//spirit framework.
namespace parsers{


    //------------------------------------------------------------------------
    template<typename ITERT>
    struct id_parser : boost::spirit::qi::grammar<ITERT,pni::core::string()>
    {
        boost::spirit::qi::rule<ITERT,pni::core::string()> id_rule;

        id_parser() : id_parser::base_type(id_rule)
        {
            using namespace boost::spirit;
            using namespace boost::phoenix;
            id_rule = +qi::char_("-_a-zA-Z0-9");
        }
    };
    
    //-------------------------------------------------------------------------
    template<typename ITERT>
    struct dot_parser : boost::spirit::qi::grammar<ITERT,pni::core::string()>
    {
        boost::spirit::qi::rule<ITERT,pni::core::string()> dot_rule;
        
        dot_parser() : dot_parser::base_type(dot_rule)
        {
            using namespace boost::spirit;
            using namespace boost::phoenix;
            using qi::_1;
            dot_rule = lit(".")[_val = "."]||lit(".")[_val += "."];
        }
    };
    
    //--------------------------------------------------------------------------

    template<typename ITERT> 
    struct element_parser : boost::spirit::qi::grammar<
                                        ITERT,
                                        boost::spirit::locals<
                                               pni::core::string,
                                               pni::core::string
                                              >,
                                        nxpath::element_type()
                                       >
    {
        typedef nxpath::element_type element_type;
        typedef boost::spirit::qi::rule<ITERT,pni::core::string()> 
            string_rule_type;
        typedef boost::spirit::locals<pni::core::string,pni::core::string> 
            locals_type;
        
        string_rule_type name_rule;   
        string_rule_type class_rule;  
            
        id_parser<ITERT>  id_;    
        dot_parser<ITERT> dots_;  
        
        boost::spirit::qi::rule< ITERT,locals_type,nxpath::element_type()> 
            element_rule;

        element_parser() : element_parser::base_type(element_rule)
        {
            using namespace boost::spirit;
            using namespace boost::phoenix;
            using qi::_1;
    
            //a name is basically nothing else than a simple Nexus identifier
            name_rule =   id_[_val = _1] | dots_[_val=_1];
            //a classname must alwasy start with a :
            class_rule =   lit(":") > id_[_val = _1];           

            element_rule =  eps[_a = "", _b=""]>>(
                              name_rule[_a = _1] || class_rule[_b = _1]
                            )[_val = construct<element_type>(_a,_b)];
        }

    };
    
    //-------------------------------------------------------------------------

    template<typename ITERT>
    struct elements_parser : boost::spirit::qi::grammar<ITERT,nxpath::elements_type()>
    {
        boost::spirit::qi::rule<ITERT,nxpath::elements_type()> elements_rule;
        element_parser<ITERT> element_; 

        elements_parser() : elements_parser::base_type(elements_rule)
        {
            using namespace boost::spirit;
            using namespace boost::phoenix;
            //[push_back(_val,construct<nxpath::element_type>("/","NXroot"))] 
            elements_rule = (element_ % '/') >-lit("/");
        }
    };



    //------------------------------------------------------------------------
    template<typename ITERT>
    struct nxpath_parser : boost::spirit::qi::grammar<ITERT,
                                       boost::spirit::locals
                                       <
                                           nxpath::elements_type,
                                           pni::core::string
                                       >,
                                       nxpath()>
    {
        boost::spirit::qi::rule<ITERT,
                 boost::spirit::locals
                 <
                     nxpath::elements_type,
                     pni::core::string
                 >,
                 nxpath()> nxpath_rule;

        boost::spirit::qi::rule<ITERT,nxpath::element_type()> root_rule;
                
        id_parser<ITERT> id_;

        elements_parser<ITERT> element_rule;

        //--------------------------------------------------------------------
        nxpath_parser(const pni::core::string &fname="") :
            nxpath_parser::base_type(nxpath_rule),
            _filename(fname)
        {
            using namespace boost::spirit;
            using namespace boost::phoenix;
            using boost::spirit::qi::_1;
           // using boost::phoenix::merge;
            using boost::phoenix::ref;

            root_rule = lit("/")[_val = construct<nxpath::element_type>("/","NXroot")];
            root_rule.name("root_rule");
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunsequenced"
#endif
            nxpath_rule = eps[
                              //we start with an empty elements list
                              _a = construct<nxpath::elements_type>(), 
                              //and we start with an empty attribute
                              _b="",
                              //finally we start with an empty path which holds
                              //only a single root element
                              _val = construct<nxpath>(boost::phoenix::ref(_filename),_a,_b),
                              //this is where we add the root element
                              push_back(_val,construct<nxpath::element_type>("/","NXroot")) 
                              ]
                          >>
                          (   //parse the root element
                              root_rule[push_back(_a,_1)] 
                           || 
                              element_rule[pni::io::nx::insert(_a,end(_a),begin(_1),end(_1))]
                           || 
                              //here we do the attribute part
                              (lit("@")>id_[_b=_1])
                           ) [_val = construct<nxpath>(boost::phoenix::ref(_filename),_a,_b)] 
                          >eoi; //finally EOI is the terminal for the string
#ifdef __clang__
#pragma clang diagnostic pop
#endif
        }

        private:
            pni::core::string _filename;
    };

    //------------------------------------------------------------------------
    nxpath parse_path(const pni::core::string &input);

//end of parser namespace
}
                                    
//end of namespace
}
}
}