list_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 GRAMMAR_TO_PARSERLIST_PARSER_H
#define GRAMMAR_TO_PARSERLIST_PARSER_H

#include "object_parser.h"

namespace grammar_to_parser {

const char* LIST = "List";

template< class E, class A, class S = basic_terminal<E,'\n'> >
class basic_list_parser : public basic_object_parser< E, std::list<A> >
{
typedef std::list<A> std_list_A;
typedef typename std_list_A::iterator std_list_A_iterator;
typedef typename basic_parser<E>::parser_list parser_list;
typedef typename basic_parser<E>::parser_list_iterator parser_list_iterator;

public:
typedef std::list<A> parser_list;

    basic_list_parser() :
                        basic_object_parser< E, std_list_A >(LIST,non_terminal_type),
                        m_min(0),
                        m_max(-1)
        {};
        
        // max_size = -1 - unbounded size (more exactly, limited by INT_MAX)
    basic_list_parser( int min_size, int max_size) :
                        basic_object_parser< E, std_list_A >(LIST,non_terminal_type),
                        m_min(min_size),
                        m_max(max_size)
        {};

    ~basic_list_parser()
        {};

        template< class R >
        void get_list( std::list<R>& l )
        {
                std_list_A_iterator it = get_valid().begin();
                while( it != get_valid().end() )
                {
                        l.push_back( (*it).get_valid() );
                        it++;
                }
        }
        
        unsigned long parse(const E *buf, const unsigned long buf_length)
        {
                prepare_for_parsing();

                S separator_parser;
                bool to_continue = true;
                do
                {
                        A a_parser;
                        // A is inherited from auto_ptr, if is parser inherited from basic_parser
                        // from this when assigned to list the ownership is transfered
                        m_parsed_size += 
                                        a_parser.parse(buf+m_parsed_size, buf_length-m_parsed_size);
                        if( a_parser.is_parsed() )
                                get_valid().push_back(a_parser);
                        else
                                to_continue = false;
                        // eat out separator
                        m_parsed_size += separator_parser.parse( buf+m_parsed_size, 
                                                                                                        buf_length-m_parsed_size );
                }
                while( to_continue );

                m_is_parsed = get_valid().size() >= m_min && 
                                                ( m_max == -1  || get_valid().size() < m_max );
                                                
                return m_parsed_size;
        }

        std::basic_istream<E>& parse( std::basic_istream<E>& is )
        {
                prepare_for_parsing();
                
                S separator_parser;
                bool to_continue = true;
                do
                {
                        A a_parser;
                        // A is inherited from auto_ptr, if is parser inherited from basic_parser
                        // from this when assigned to list the ownership is transfered
                        a_parser.parse( is );
                        m_parsed_size += a_parser.parsed_size();
                        if( a_parser.is_parsed() )
                                get_valid().push_back(a_parser);
                        else
                                to_continue = false;
                        // eat out separator
                        separator_parser.parse( is );
                        m_parsed_size += separator_parser.parsed_size(); 
                }
                while( to_continue );

                m_is_parsed = true;
                return is;
        }
        
        std::basic_ostream<E>& format( std::basic_ostream<E>&os )
        {
                prepare_for_formatting();
                
                std_list_A_iterator it = get_valid().begin();
                while( it != get_valid().end() )
                {
                        (*it).format(os);
                        it++;
                        if( it != get_valid().end() ) 
                        {
                                S separator_parser;
                                separator_parser.format( os );
                        }

                }
                return os;
        }
protected:
        int m_min;
        int m_max;

};

template< class A, class S = terminal<'\n'> >
class list_parser : public basic_list_parser< char, A, S >
{
typedef std::list<A> std_list_A;
typedef std::list<A> std_list_A_iterator;

public:
        list_parser() : basic_list_parser<char, A, S >() {};
    list_parser( int min_size, int max_size ) : 
                basic_list_parser<char, A, S >( min_size, max_size ) {};
    ~list_parser() {};
};

template< class A, class S = wterminal<'\n'> >
class wlist_parser : public basic_list_parser< wchar_t, A, S >
{
typedef std::list<A> std_list_A;
typedef std::list<A> std_list_A_iterator;

public:
    wlist_parser() : basic_list_parser< wchar_t, A, S >() {};
    wlist_parser( int min_size, int max_size ) : 
                basic_list_parser< wchar_t, A, S >( min_size, max_size ) {};
    ~wlist_parser() {};
};

};
#endif

---