extended_regular_expression.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 EXTENDED_REGULAR_EXPRESSIONERE_H
#define EXTENDED_REGULAR_EXPRESSIONERE_H

#include <map>
#include <list>

#include "grammar_to_parser.h"

#include "match.h"
#include "matches.h"
#include "bracket_expression.h"
#include "ere_base.h" 
#include "ere_dupl_symbol.h"
#include "ere_dups.h"
#include "special_chars.h"
#include "one_char_or_coll_elem_ere.h"
#include "ere_expression.h"
#include "ere_branch.h"
#include "extended_reg_exp.h"

namespace extended_regular_expression
{
        
template< typename E >
class ere
{
typedef typename grammar_to_parser::basic_parser<E>::parser_list parser_list;

        grammar_to_parser::basic_choice< E, extended_reg_exp<E> >       m_ext_reg_exp;
        unsigned long   m_rec_size;
        unsigned long   m_rec_pos;
        bool                    m_is_rec;

public:
        ere() : m_rec_size(0), m_rec_pos(0), m_is_rec(false)  {};
        ~ere() {};
        
        unsigned long recognize( const E* buf, 
                                                        const unsigned long buf_length,
                                                        bool try_positions = true )
        {
                m_ext_reg_exp->recognize( buf, buf_length, 0, try_positions );
                m_is_rec = m_ext_reg_exp->is_recognized();
                m_rec_pos = m_ext_reg_exp->recognized_position();
                m_rec_size = m_ext_reg_exp->recognized_size();
                return m_rec_size;
        }
        void assign_matches( matches& m )
        {
                unsigned long branch_pos = 0;
                matches::match_key key = "1";
                if( m_ext_reg_exp.is_parsed() ) m_ext_reg_exp->assign_matches( key, branch_pos, m );
        };
        
        void push_parsers( parser_list& l )
        {
                l.push_back( &m_ext_reg_exp );
        }
        
        bool is_recognized()
        {
                return m_is_rec;
        }
        
        const unsigned long recognized_size() const
        {
                return m_rec_size;
        }
        
        const unsigned long recognized_position() const
        {
                return m_rec_pos;
        }
};

};

#endif

---