ascii_range_terminal.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_PARSERASCII_RANGE_TERMINAL_H
#define GRAMMAR_TO_PARSERASCII_RANGE_TERMINAL_H

#include <object_parser.h>

namespace grammar_to_parser {

template<typename E>
class basic_ascii_range_terminal : public basic_object_parser<E,E>
{
typedef std::auto_ptr<E> std_auto_ptr;
public:
    basic_ascii_range_terminal( E from_char, E to_char ) :
                basic_object_parser<E,E>(),
                m_from_char(from_char),
                m_to_char(to_char) {};
    ~basic_ascii_range_terminal() {};
        
    unsigned long parse( const E *buf, const unsigned long buf_length );
        std::basic_istream<E>& parse( std::basic_istream<E>& is );
        
    std::basic_ostream<E>& format( std::basic_ostream<E>& os );
private:
        E                       m_from_char;
        E                       m_to_char;
};


template< typename E >
unsigned long basic_ascii_range_terminal<E>::parse( const E *buf, 
                                                                                const unsigned long buf_length )
{
        prepare_for_parsing();

        if( (*buf) >= m_from_char && (*buf) <= m_to_char )
        {
                std_auto_ptr::operator = ( std_auto_ptr( new E(*buf) ) );
                m_parsed_size = 1;
                m_is_parsed = true;
        }
        return m_parsed_size;
}

template< typename E >
std::basic_istream<E>& basic_ascii_range_terminal<E>::parse( 
                                                                                        std::basic_istream<E>& is )
{
        prepare_for_parsing();
        if( !is.good() )
        {
                return is;
        }
        E input = m_from_char;
        std::streampos str_pos = is.tellg();

        is.read( &input, 1 );

        if( is.good() && input >= m_from_char && input <= m_to_char )
        {
                m_parsed_size = 1;
                m_is_parsed = true;
                get_valid() = input;
        }
        else 
        {
                is.clear();
                is.seekg( str_pos );
        }
        return is;
}

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

        std::streampos strPos = os.tellp();
        if( (std::streamoff)strPos < 0 ) strPos = 0;

        int out = get_valid();
        if( os.good() ) 
        {
                os.write( (const E*)&out,sizeof(E) );
                m_formatted_size = sizeof(E);
                m_is_formatted = true;
        }
        else 
        {
                os.clear();
                os.seekp( strPos );
        }
        return os;
}

typedef basic_ascii_range_terminal<char>        ascii_range_terminal;
typedef basic_ascii_range_terminal<wchar_t>     wascii_range_terminal;
};

#endif

---