xml_element_parser.h

/***************************************************************************
 *   Copyright (C) 2005 by Radko Mihal                                     *
 *   rmihal@pobox.sk                                                       *
 *                                                                         *
 *   This program 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.                                   *
 *                                                                         *
 *   This program 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 this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.              *
 ***************************************************************************/
#ifndef XML_PARSERBASIC_XML_ELEMENT_PARSER_H
#define XML_PARSERBASIC_XML_ELEMENT_PARSER_H


namespace xml_parser {

template< typename E, typename A >
class basic_xml_element_parser : public grammar_to_parser::basic_non_terminal<E,A>
{
public:
typedef typename grammar_to_parser::basic_parser<E>::parser_list 
                                                                                                                parser_list;
typedef typename grammar_to_parser::basic_parser<E>::parser_list_iterator 
                                                                                                                parser_list_iterator;
typedef typename basic_xml_attribute_list_parser<E>::attributes_parsers_list 
                                                                                                                attributes_parsers_list;
typedef typename std::basic_string<E> std_string;

        enum xml_special_chars {
                left_bracket = '<',
                right_bracket = '>',
                end_tag_char = '/'
        };
        
        basic_xml_element_parser(std::basic_string<E> tag_name) :
                m_begin_left_bracket(std_string(1,left_bracket)),
                m_begin_tag_name(tag_name),
                m_begin_right_bracket(std_string(1,right_bracket)),
                m_end_left_bracket(std_string(1,left_bracket)),
                m_end_char(std_string(1,end_tag_char)),
                m_end_tag_name(tag_name),
                m_end_right_bracket(std_string(1,right_bracket)),
                grammar_to_parser::basic_non_terminal<E,A>() {};
                        
protected:
        grammar_to_parser::basic_pattern_parser<E>      m_begin_left_bracket; // '<'
        grammar_to_parser::basic_pattern_parser<E>      m_begin_tag_name;
        // here will come attributes list parser from compound class 
        // implementing push_attributes_parser() method 
        basic_xml_attribute_list_parser<E>                      m_attribute_list_parser;
        grammar_to_parser::basic_pattern_parser<E>      m_begin_right_bracket;
        // here will come value parsers from compound class 
        // implementing push_value_parsers() method
        grammar_to_parser::basic_pattern_parser<E>      m_end_left_bracket;
        grammar_to_parser::basic_pattern_parser<E>      m_end_char;
        grammar_to_parser::basic_pattern_parser<E>      m_end_tag_name;
        grammar_to_parser::basic_pattern_parser<E>      m_end_right_bracket;
        
        virtual void prepare_symbols()
        {
                if( !m_symbols_valid ) 
                {
                        m_symbols.push_back(&m_begin_left_bracket);
                        m_symbols.push_back(&m_begin_tag_name);
                        
                        // assign attribute parsers into attribute list parser
                        attributes_parsers_list attributes_parsers;
                        get_valid().push_attributes_parsers(attributes_parsers);
                        m_attribute_list_parser.assign_attributes_parsers(attributes_parsers);
                        m_symbols.push_back(&m_attribute_list_parser);
                        
                        m_symbols.push_back(&m_begin_right_bracket);
                        get_valid().push_parsers(m_symbols);
                        m_symbols.push_back(&m_end_left_bracket);
                        m_symbols.push_back(&m_end_char);
                        m_symbols.push_back(&m_end_tag_name);
                        m_symbols.push_back(&m_end_right_bracket);
                        m_symbols_valid = true;
                }
                
        }
};



template<typename A>
class xml_element_parser : public basic_xml_element_parser<char,A>
{
public:
        
        xml_element_parser<A>(std::string tag_name) : 
                basic_xml_element_parser<char,A>(tag_name) {};
};

template<typename A>
class wxml_element_parser : public basic_xml_element_parser<wchar_t,A>
{
public:
        wxml_element_parser<A>(std::wstring tag_name) : 
                basic_xml_element_parser<wchar_t,A>(tag_name) {};
};


};

#endif

---