collating_symbol.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_EXPRESSIONCOLLATING_SYMBOL_H
#define BRACKET_EXPRESSIONCOLLATING_SYMBOL_H

namespace bracket_expression {

template< typename E >
class collating_symbol
{
typedef typename grammar_to_parser::basic_parser<E>::parser_list 
                                                                                                                                parser_list;

        class collating_base
        {
        protected:
                int m_size;
        public:
                int matched_size() { return m_size; }
                collating_base() : m_size(0) {};
        };
        
        class opendot_coll_elem_single_dotclose : public collating_base
        {
                grammar_to_parser::basic_terminal<E, '['>       m_open;
                grammar_to_parser::basic_terminal<E, '.'>       m_left_dot;
                grammar_to_parser::basic_except_terminal<E,meta_char_choice<E> >        
                                                                                                        m_coll_elem_single;
                grammar_to_parser::basic_terminal<E, '.'>       m_right_dot;
                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_dot);
                        l.push_back(&m_coll_elem_single);
                        l.push_back(&m_right_dot);
                        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 opendot_coll_elem_multi_dotclose : public collating_base
        {
                typedef std::ctype_base ctypebase;
                grammar_to_parser::basic_terminal<E, '['>       m_open;
                grammar_to_parser::basic_terminal<E, '.'>       m_left_dot;
                grammar_to_parser::basic_string_parser<E>       m_coll_elem_multi;
                // right dot is also used as separator in string parser - see constructor
                grammar_to_parser::basic_terminal<E, '.'>       m_right_dot;
                grammar_to_parser::basic_terminal<E, ']'>       m_close;
        public:
                opendot_coll_elem_multi_dotclose() : 
                        collating_base(),
                        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_dot);
                        l.push_back(&m_coll_elem_multi);
                        l.push_back(&m_right_dot);
                        l.push_back(&m_close);
                }
                int compare( const E* buf, const unsigned long buf_length )
                {                       
                        unsigned long to_compare_length =
                                                collating_symbol<E>::get_symbol_len(buf,buf_length);
                        std::basic_string<E> multichar = *(m_coll_elem_multi.get());
                        // check the size of element in buf  - try the longest
                        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;
                }       
        };
        
        class opendot_metachar_dotclose : public collating_base
        {
                grammar_to_parser::basic_terminal<E, '['>       m_open;
                grammar_to_parser::basic_terminal<E, '.'>       m_left_dot;
                grammar_to_parser::basic_choice<E,meta_char_choice<E> > 
                                                                                                        m_meta_char;
                grammar_to_parser::basic_terminal<E, '.'>       m_right_dot;
                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_dot);
                        l.push_back(&m_meta_char);
                        l.push_back(&m_right_dot);
                        l.push_back(&m_close);
                }       
                int compare( const E* buf, const unsigned long buf_length )
                {
                        int ret = m_meta_char->compare(buf,buf_length);
                        m_size = 1; //m_meta_char->matched_size();
                        return ret;
                }       
        };
        grammar_to_parser::basic_non_terminal<E, opendot_coll_elem_single_dotclose>
                                                                                                        m_coll_elem_single;
        grammar_to_parser::basic_non_terminal<E, opendot_coll_elem_multi_dotclose>
                                                                                                        m_multichar;
        grammar_to_parser::basic_non_terminal<E, opendot_metachar_dotclose>
                                                                                                        m_metachar;
        int m_size;
public:
    collating_symbol() : 
                m_coll_elem_single(),
                m_metachar(),
                m_multichar(),
                m_size(0) {};

        void push_parsers( parser_list &l )
        {
                l.push_back(&m_multichar);
                l.push_back(&m_metachar);
                l.push_back(&m_coll_elem_single);
        }       
        
        int matched_size() { return m_size; }
        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 if( m_multichar.is_parsed() )
                {
                        ret = m_multichar->compare( buf, buf_length );
                        m_size = m_multichar->matched_size();
                }
                else
                {
                        ret = m_metachar->compare( buf, buf_length );
                        m_size = m_metachar->matched_size();
                }
                return ret;
        }
        static unsigned long get_symbol_len( const E* buf, const unsigned long buf_length );
};


unsigned long collating_symbol<char>::get_symbol_len( const char* buf, 
                                                                                                        const unsigned long buf_length )
{
        // TODO - don't know how to test this - when mbrlen returns value > 1?
        // I tested with setting the diferent locales and sending digraph values (like ch for 
        // czech locale, but never get value > 1
        //std::mbstate_t state;
        //std::memset( &state,'\0',sizeof(state) );
        return 1;
        int len = mblen( buf, buf_length );
        if( len < 0 ) 
        {
                len = 0;
        }
        return (unsigned long)len;
}

unsigned long collating_symbol<wchar_t>::get_symbol_len( const wchar_t* buf,
                                                                                                        const unsigned long buf_length )
{
        // TODO - check, if this is OK
        if( buf_length > 0 )
                return 1;
        else
                return 0;
}

};

#endif

---