string_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_PARSERBASIC_STRING_PARSER_H
#define GRAMMAR_TO_PARSERBASIC_STRING_PARSER_H

#include <sstream>

namespace grammar_to_parser {

template<typename E>
class basic_string_parser : 
        public basic_value_parser< E, std::basic_string<E> >
{
public:
typedef std::basic_string<E> std_string;
        enum white_chars
        {
                NEW_LINE= '\n',
                SPACE = ' ',
                TAB = '\t',
                CARRIAGE_RETURN = 13,
                LINE_FEED = 10
        };
        
        enum directives
        {
                NONE = 0,
                NO_NEW_LINES = 1,
                NO_SPACES = 2,
                NO_TABS = 4,
                NO_CARRIAGE_RETURNS = 8,
                NO_LINE_FEEDS = 16
        };
        
        enum string_type
        {
                STRING = NONE,
                NORMALIZED_STRING = NO_CARRIAGE_RETURNS |
                                                        NO_LINE_FEEDS |
                                                        NO_TABS,
                TOKEN = NO_SPACES |
                                NO_LINE_FEEDS |
                                NO_TABS,
                NMTOKEN = NO_SPACES |
                                NO_LINE_FEEDS |
                                NO_TABS
        };
                
        basic_string_parser();
        basic_string_parser(const E separator, int a_directives);
        ~basic_string_parser();
        
        unsigned long parse( const E* buf, const unsigned long buf_length );
        std::basic_istream<E>& parse( std::basic_istream<E>& is );
        operator std::basic_string<E>() { return get_valid(); }
        
protected:
        E                       m_separator;
        int                     m_directives;
        
};

template< typename E >
basic_string_parser<E>::basic_string_parser() :
        basic_value_parser< E, std::basic_string<E> >(),
        m_separator(NEW_LINE),
        m_directives(NO_NEW_LINES)
{
}
        
template< typename E >
basic_string_parser<E>::basic_string_parser(const E separator, int a_directives) : 
        basic_value_parser< E, std::basic_string<E> >(),
        m_separator(separator),
        m_directives(a_directives)
{
}

template< typename E >
basic_string_parser<E>::~basic_string_parser()
{
}

template< typename E >
unsigned long basic_string_parser<E>::parse( const E* buf, 
                                                                        const unsigned long buf_length )
{
        prepare_for_parsing();
        
        m_is_parsed = true;
        int i = 0;
        for( i=0; i<buf_length && buf[i] != m_separator; i++ )
        {
                if( m_directives & NO_NEW_LINES && buf[i] == NEW_LINE ||
                        m_directives & NO_SPACES && buf[i] == SPACE ||
                        m_directives & NO_TABS && buf[i] == TAB ||
                        m_directives & NO_CARRIAGE_RETURNS && buf[i] == CARRIAGE_RETURN ||
                        m_directives & NO_LINE_FEEDS && buf[i] == LINE_FEED )
                {
                        m_is_parsed = false;
                        break;
                }
                        
        };
        
        if( m_is_parsed )
        {
                get_valid() = std::basic_string<E>( buf, i );
                m_parsed_size = get_valid().length();
        }
        return m_parsed_size;
}

template< typename E >
std::basic_istream<E>& basic_string_parser<E>::parse( std::basic_istream<E>& is )
{
        prepare_for_parsing();
        
        std::streampos str_pos = is.tellg();
        std::basic_stringbuf<E> buf;
        is.get( buf, m_separator );
        typename std_string::iterator it = buf.str().begin();
        
        m_is_parsed = true;
        E input = 0;
        while( it != buf.str().end() )
        {
                input = (*it);
                if( m_directives & NO_NEW_LINES && input == NEW_LINE ||
                        m_directives & NO_SPACES && input == SPACE ||
                        m_directives & NO_TABS && input == TAB ||
                        m_directives & NO_CARRIAGE_RETURNS && input == CARRIAGE_RETURN ||
                        m_directives & NO_LINE_FEEDS && input == LINE_FEED )
                {
                        m_is_parsed = false;
                        break;
                }
                it++;
        };
                
        if( m_is_parsed )
        {       
                get_valid() = buf.str();
                m_parsed_size = get_valid().length();
        }
        else
        {
                is.clear();
                is.seekg(str_pos);
        }       
        return is;
}

typedef basic_string_parser<char> string_parser;
typedef basic_string_parser<wchar_t> wstring_parser;

};

#endif

---