class_name.h

/***************************************************************************
 *   Copyright (C) 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 BRACKET_EXPRESSIONCLASS_NAME_H
#define BRACKET_EXPRESSIONCLASS_NAME_H

namespace bracket_expression {

template<typename E>
class class_name
{
typedef typename grammar_to_parser::basic_parser<E>::parser_list parser_list;
typedef std::ctype_base ctypebase;

        grammar_to_parser::basic_pattern_parser<E>              m_alnum;
        grammar_to_parser::basic_pattern_parser<E>              m_cntrl;
        grammar_to_parser::basic_pattern_parser<E>              m_lower;
        grammar_to_parser::basic_pattern_parser<E>              m_space;
        grammar_to_parser::basic_pattern_parser<E>              m_alpha;
        grammar_to_parser::basic_pattern_parser<E>              m_digit;
        grammar_to_parser::basic_pattern_parser<E>              m_print;
        grammar_to_parser::basic_pattern_parser<E>              m_upper;
        grammar_to_parser::basic_pattern_parser<E>              m_blank;
        grammar_to_parser::basic_pattern_parser<E>              m_graph;
        grammar_to_parser::basic_pattern_parser<E>              m_punct;
        grammar_to_parser::basic_pattern_parser<E>              m_xdigit;
        
        int m_size;     
public:
    class_name() : 
                m_alnum( "alnum" ),
                m_cntrl( "cntrl" ),
                m_lower( "lower" ),
                m_space( "space" ),
                m_alpha( "alpha" ),
                m_digit( "digit" ),
                m_print( "print" ),
                m_upper( "upper" ),
                m_blank( "blank" ),
                m_graph( "graph" ),
                m_punct( "punct" ),
                m_xdigit( "xdigit" ),
                m_size(0) {};
        
        int matched_size() { return m_size; }
        
        void push_parsers( parser_list &l )
        {
                l.push_back(&m_alnum);
                l.push_back(&m_cntrl);
                l.push_back(&m_lower);
                l.push_back(&m_space);
                l.push_back(&m_alpha);
                l.push_back(&m_digit);
                l.push_back(&m_print);
                l.push_back(&m_upper);
                l.push_back(&m_blank);
                l.push_back(&m_graph);
                l.push_back(&m_punct);
                l.push_back(&m_xdigit);
        }
        
        unsigned long compare( const E* buf, const unsigned long buf_length )
        {
                std::ctype_base t;
                int ret = 0;
                ctypebase::mask m;
                
                
                if( m_alnum.is_parsed() ) m=ctypebase::alnum;
                if( m_cntrl.is_parsed() ) m=ctypebase::cntrl;
                if( m_lower.is_parsed() ) m=ctypebase::lower;
                if( m_space.is_parsed() ) m=ctypebase::space;
                if( m_alpha.is_parsed() ) m=ctypebase::alpha;
                if( m_digit.is_parsed() ) m=ctypebase::digit;
                if( m_print.is_parsed() ) m=ctypebase::print;
                if( m_upper.is_parsed() ) m=ctypebase::upper;
//              if( m_blank.is_parsed() ) m=ctypebase::blank;
                if( m_graph.is_parsed() ) m=ctypebase::graph;
                if( m_punct.is_parsed() ) m=ctypebase::punct;
                if( m_xdigit.is_parsed() ) m=ctypebase::xdigit;
                
                while( m_size < buf_length )
                {
                        if( !std::use_facet< std::ctype<E> >(std::locale()).is( buf, 
                                                                                                        buf+m_size+1, &m ) )
                        {
                                break;
                        }
                        m_size++;
                }
                
                if( m_size > 0 )
                        return 0;
                else
                        return 1;
        }
        

    ~class_name()
        {
        }

};

};

#endif

---