equivalence_class.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_EXPRESSIONEQUIVALENCE_CLASS_H
#define BRACKET_EXPRESSIONEQUIVALENCE_CLASS_H

namespace bracket_expression {

template<typename E>
class equivalence_class
{
typedef typename grammar_to_parser::basic_parser<E>::parser_list 
                                                                                                                                parser_list;
        
        class equivalence_base
        {
        protected:
                int m_size;
        public:
                equivalence_base() : m_size(0) {};
                int matched_size() { return m_size; }
        };
        
        class openequal_coll_elem_single_equalclose : public equivalence_base
        {
                grammar_to_parser::basic_terminal<E, '['>       m_open;
                grammar_to_parser::basic_terminal<E, '='>       m_left_equal;
                grammar_to_parser::basic_except_terminal<E,meta_char_choice<E> >        
                                                                                                        m_coll_elem_single;
                grammar_to_parser::basic_terminal<E, '='>       m_right_equal;
                grammar_to_parser::basic_terminal<E, ']'>       m_close;
        public:
                                
                void push_parsers( parser_list &l )
                {
                        l.push_back(&m_open);
                        l.push_back(&m_left_equal);
                        l.push_back(&m_coll_elem_single);
                        l.push_back(&m_right_equal);
                        l.push_back(&m_close);
                }
                int compare( const E* buf, const unsigned long buf_length )
                {
                        int ret = std::use_facet< std::collate<E> >(std::locale()).compare(
                                                                                                buf,
                                                                                                buf,
                                                                                                m_coll_elem_single.get(),
                                                                                                m_coll_elem_single.get() );
                        if( ret == 0 )
                                m_size = 1;
                        else
                                m_size = 0;
                        return ret;
                }       
        };
        
        class openequal_coll_elem_multi_equalclose : public equivalence_base
        {
                typedef std::ctype_base ctypebase;
                grammar_to_parser::basic_terminal<E, '['>       m_open;
                grammar_to_parser::basic_terminal<E, '.'>       m_left_equal;
                grammar_to_parser::basic_string_parser<E>       m_coll_elem_multi;
                grammar_to_parser::basic_terminal<E, '.'>       m_right_equal;
                grammar_to_parser::basic_terminal<E, ']'>       m_close;
        public:
                openequal_coll_elem_multi_equalclose() : 
                        m_coll_elem_multi('.', grammar_to_parser::basic_string_parser<E>::NONE) {};
                void push_parsers( parser_list &l )
                {
                        l.push_back(&m_open);
                        l.push_back(&m_left_equal);
                        l.push_back(&m_coll_elem_multi);
                        l.push_back(&m_right_equal);
                        l.push_back(&m_close);
                }
                int compare( const E* buf, const unsigned long buf_length )
                {
                        unsigned long to_compare_length = 0;
                        // check the size of element in buf  - try the longest
                        while( to_compare_length < buf_length )
                        {
                                to_compare_length++;
                                ctypebase::mask m = ctypebase::print;
                                if( !std::use_facet< std::ctype<E> >(std::locale()).is( buf, 
                                                                                                                buf+to_compare_length, &m ) )
                                {
                                        break;
                                }
                                        
                        }
                        std::basic_string<E> multichar = *(m_coll_elem_multi.get());
                        int ret = std::use_facet< std::collate<E> >(std::locale()).compare(
                                                                                buf,
                                                                                buf+to_compare_length,
                                                                                multichar.c_str(),
                                                                                multichar.c_str() + multichar.length() );
                        m_size = to_compare_length;
                        return ret;
                }       
        };
        int m_size;
public:
        grammar_to_parser::basic_non_terminal<E, openequal_coll_elem_single_equalclose>
                                                                                                        m_coll_elem_single;
        grammar_to_parser::basic_non_terminal<E, openequal_coll_elem_multi_equalclose>
                                                                                                        m_multichar;
public:
    equivalence_class() : 
                m_coll_elem_single(),
                m_multichar(),
                m_size(0) {};
        
        int matched_size() { return m_size; }

        void push_parsers( parser_list &l )
        {
                l.push_back(&m_coll_elem_single);
                l.push_back(&m_multichar);
        }       
        int compare( const E* buf, const unsigned long buf_length )
        {
                int ret = 0;
                if( m_coll_elem_single.is_parsed() )
                {
                        ret = m_coll_elem_single->compare( buf, buf_length );
                        m_size = m_coll_elem_single->matched_size();
                }
                else
                {
                        ret = m_multichar->compare( buf, buf_length );
                        m_size = m_multichar->matched_size();
                }
                return ret;
        }
};

};

#endif

---