matches.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_EXPRESSIONMATCHES_H
#define EXTENDED_REGULAR_EXPRESSIONMATCHES_H

namespace extended_regular_expression {


class matches
{
public:
        
typedef std::map<std::string, match>                    matches_coll;
typedef matches_coll::key_type                                  match_key;
typedef matches_coll::value_type                                match_value;
typedef std::list<match>                                                matches_ret_coll;

protected:
        matches_coll                                                            m_matches;

public: 
        void insert( match_key key, match value )
        {
                m_matches.insert( match_value( key, value ) );
                
        }
        
        match get( match_key key )
        {
                matches_coll::iterator it = m_matches.find( key );
                if( it != m_matches.end() )
                {
                        return (*it).second;
                }
                else
                {
                        return match(); // with return match, which is not valid (its 
                                                        // is_valid() returns false)
                }
        }
        
        void get_all(matches_ret_coll& l)
        {
                matches_coll::iterator it = m_matches.begin();
                while( it != m_matches.end() )
                {
                        l.push_back( (*it).second );
                        it++;
                }
        }
        
        void get_all(matches_coll& m)
        {
                m = m_matches;
        }
        
        void clear()
        {
                m_matches.clear();
        }
        
        void extend( matches::match_key parent_key, 
                                matches& sub_matches )
        {
                matches_coll ret_coll;
                sub_matches.get_all( ret_coll );
                
                matches_coll::iterator it = ret_coll.begin();
                while( it != ret_coll.end() )
                {
                        matches::match_key new_key = parent_key;
                        new_key += (*it).first; // the key if (*it).first must begin with dot
                        insert( new_key, (*it).second );
                        it++;
                }
        }
        
    matches() {};
    ~matches() {};

};

};

#endif

---