value_parser.h

/***************************************************************************
 *   Copyright (C) 2004-2006 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_PARSERVALUE_PARSER_H
#define GRAMMAR_TO_PARSERVALUE_PARSER_H

#include <iostream>
#include "default_type_parser.h"

namespace grammar_to_parser {

const char* VALUE_PARSER = "ValueParser";
template< typename E, typename A >
class basic_value_parser : public basic_default_type_parser<E,A>
{
public:
    basic_value_parser();

    ~basic_value_parser();
    virtual unsigned long parse( const E* buf, const unsigned long buf_length );
        virtual std::basic_istream<E>& parse( std::basic_istream<E>& is );

};

template< typename E, typename A >
basic_value_parser<E,A>::basic_value_parser() : 
        basic_default_type_parser<E,A>(VALUE_PARSER)
{
}

template< typename E, typename A >
basic_value_parser<E,A>::~basic_value_parser()
{
}

template< typename E, typename A >
unsigned long basic_value_parser<E,A>::parse( const E* buf, 
                                                                        const unsigned long buf_length )
{
        prepare_for_parsing();
        
        std::auto_ptr< std::basic_stringbuf<E> > strbufptr(
                        new std::basic_stringbuf<E>( std::basic_string<E>( (const E*)buf, buf_length ) ) );
        std::basic_istream<E> is(strbufptr.get());

        std::streampos begin = is.tellg();
        is >> get_valid();
        if( !(m_is_parsed = ( !is.fail() && 
                ( m_parsed_size = is.tellg() - begin ) > 0 ) ) )
        {
                m_parsed_size = 0;
        }
        return m_parsed_size;
}

template< typename E, typename A >
std::basic_istream<E>& basic_value_parser<E,A>::parse( std::basic_istream<E>& is )
{
        prepare_for_parsing();
        
        std::streampos strPos = is.tellg();
        is >> get_valid();

        m_parsed_size = (std::streamoff)is.tellg() - (std::streamoff)strPos;
        m_is_parsed = !is.fail() && m_parsed_size > 0; 

        if( !m_is_parsed )
        {
                is.clear();
                is.seekg( strPos );
                m_parsed_size = 0;
        }
        return is;
        
}

template< typename A >
class value_parser : public basic_value_parser<char,A>
{
public:
    value_parser() : basic_value_parser<char,A>() {};
    ~value_parser () {};
};

template< typename A >
class wvalue_parser : public basic_value_parser<wchar_t,A>
{
public:
    wvalue_parser() : basic_value_parser<wchar_t,A>() {};
    ~wvalue_parser () {};
};

};

#endif

---