white_space_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_PARSERWHITE_SPACE_PARSER_H
#define GRAMMAR_TO_PARSERWHITE_SPACE_PARSER_H

#include "default_type_parser.h"

namespace grammar_to_parser {

template< typename E >
class basic_white_space_parser : 
        public basic_default_type_parser< E,std::basic_string<E> >
{
typedef std::basic_string<E> std_string;
typedef std::basic_istream<E> std_istream;
typedef std::ctype<E> std_ctype;
typedef std::char_traits<E> std_char_traits;
public:
    basic_white_space_parser() : 
                basic_default_type_parser< E,std::basic_string<E> >() {};
        
        basic_white_space_parser( const basic_white_space_parser &rhs ) :
                basic_default_type_parser< E,std::basic_string<E> >(rhs) {};
        
        basic_white_space_parser( const std::basic_string<E> &space ) :
                basic_default_type_parser< E,std::basic_string<E> >(space) {};
    
        virtual ~basic_white_space_parser() {};
    virtual unsigned long parse( const E *buf, const unsigned long buf_length )
        {
                prepare_for_parsing();
        
                typename std_string::iterator it = get_valid().begin();
                
                while( m_parsed_size < buf_length && is_space( buf[m_parsed_size] ) )
                {
                        m_parsed_size++;
                        get_valid() += buf[m_parsed_size];
                }
                m_is_parsed = true;
                return m_parsed_size;
        }

        virtual std::basic_istream<E>& parse( std::basic_istream<E>& is )
        {
                prepare_for_parsing();
        
                typename std_string::iterator it = get_valid().begin();
                std::streampos strPos = is.tellg();
                E input = 0;
        
                while( is.good() && is_space( is ) )
                {
                        is.read( &input, 1 );
                        m_parsed_size++;
                        get_valid() += input;
                        strPos = is.tellg();
                }
                m_is_parsed = true;
                is.clear();
                is.seekg( strPos );
                return is;
        }
protected:
        bool is_space( E input )
        {
                const std::locale loc;
                const std_ctype& fac = std::use_facet( loc, (std::ctype<E>*)0, true );
                return fac.is( std_ctype::space, input );
        }
        bool is_space( std::basic_istream<E>& is )
        {
                E input = 0;
                is.read( &input, 1 );
                if( is.good() )
                {
                        const std::locale loc;
                        const std_ctype& fac = std::use_facet( loc, (std::ctype<E>*)0, true );
                        return fac.is( std_ctype::space, input );
                }
                return false;
        }
};

typedef basic_white_space_parser<char> white_space_parser;
typedef basic_white_space_parser<wchar_t> wwhite_space_parser;

};

#endif

---