default_type_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_PARSERDEFAULT_TYPE_PARSER_H
#define GRAMMAR_TO_PARSERDEFAULT_TYPE_PARSER_H

#include "object_parser.h"

namespace grammar_to_parser {

const char* DEFAULT_TYPE_PARSER = "DefaultTypeParser";
template< typename E, typename A >
class basic_default_type_parser : public basic_object_parser<E,A>
{
public:
    basic_default_type_parser( const char* name = DEFAULT_TYPE_PARSER );
        basic_default_type_parser( const basic_default_type_parser& rhs );
        basic_default_type_parser( const A& obj, const char* name = DEFAULT_TYPE_PARSER );

    virtual ~basic_default_type_parser();

    virtual std::basic_ostream<E>& format( std::basic_ostream<E>& os );
};

template< typename A >
class default_type_parser : 
        public basic_default_type_parser<char,A>
{
public:
    default_type_parser() : basic_default_type_parser<char,A>() {};
        default_type_parser(const default_type_parser& rhs) : 
                basic_default_type_parser<char,A>( rhs ) {};
        default_type_parser(const A& obj) : 
                basic_default_type_parser<char,A>( obj ) {};
};

template< typename A >
class wdefault_type_parser : 
        public basic_default_type_parser<wchar_t,A>
{
public:
    wdefault_type_parser() : basic_default_type_parser<wchar_t,A>() {};
        wdefault_type_parser(const wdefault_type_parser& rhs) : 
                basic_default_type_parser<wchar_t,A>( rhs ) {};
        wdefault_type_parser(const A& obj) : 
                basic_default_type_parser<wchar_t,A>( obj ) {};
};

template< typename E, typename A >
basic_default_type_parser<E,A>::basic_default_type_parser(const char* name)
 : basic_object_parser<E,A>(name,terminal_type)
{
}


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

template< typename E, typename A >
basic_default_type_parser<E,A>::basic_default_type_parser( 
                                                const basic_default_type_parser& rhs )
 : basic_object_parser<E,A>(rhs)
{
}

template< typename E, typename A >
basic_default_type_parser<E,A>::basic_default_type_parser( 
                                                                                const A& obj, const char* name )
 : basic_object_parser<E,A>(name, obj, terminal_type)
{
}

template< typename E, typename A >
std::basic_ostream<E>& basic_default_type_parser<E,A>::format( 
                                                                                std::basic_ostream<E>& os )
{
        prepare_for_formatting();

        std::streampos strPos = os.tellp();
        os << get_valid();
        if( ( m_is_formatted = os.good() ) ) 
        {
                m_formatted_size = os.tellp() - strPos;
        }
        else
        {
                os.seekp(strPos);
        }
        return os;
}


};

#endif

---