map2.h

Go to the documentation of this file.

/*****************************************************************************
* Copyright (c) 2001 - 2008 Marcus Boerger.  All rights reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
* ========================================================================= */

/* ------------------------------------------------------------------------ */
/* Name:      map2.h
 *
 * Requires:  
 * - Mbo.h
 * - list2.h
 * - vector2.h
 * - deque2.h
 */
/* ------------------------------------------------------------------------ */

#if defined(_MSC_VER) && _MSC_VER >= 1200
# pragma once
#endif

#ifndef _MAP2_H_
#define _MAP2_H_

#include "Mbo.h"

#include "list2.h"
#include "vector2.h"
#include "deque2.h"
#include <map>
#include <functional>
#include <stdexcept>

namespace std
{

template <class _Tp, class _Arg>
class check_fun_t
    : public binary_function<_Tp,const _Arg&,bool> 
{
typedef bool (_Tp::*_fun_type)(const _Arg&) const; 
public:
    explicit check_fun_t(_fun_type __pf) : _M_f(__pf) {}

    bool operator()(const _Tp& __r, const _Arg & __x) const 
    { 
        return (__r.*_M_f)(__x); 
    }
private:
    _fun_type _M_f; 
}; 

template <class _Tp, class _Arg>
check_fun_t<_Tp,_Arg> check_fun(bool (_Tp::*__f)(const _Arg&) const) 
{ 
    return check_fun_t<_Tp,_Arg>(__f); 
};

#define MAP_CONTAINER std::deque2

template <class __Kty,
    class __Ty,
    class __Kty_container = MAP_CONTAINER<__Kty>,
    class __Ty_container  = MAP_CONTAINER<__Ty>,
    class __Pr            = less<__Kty>,
    class __Alloc         = allocator<pair<const __Kty, __Ty> > >
class map2
    : public map<__Kty, __Ty, __Pr, __Alloc> // ms<_Ty>
{
public:
    typedef typename __Kty_container                     _Kty_container;       
    typedef typename __Ty_container                      _Ty_container;        
    typedef map2<__Kty, __Ty, _Kty_container, _Ty_container, __Pr, __Alloc> _Myt; 
    typedef map<__Kty, __Ty, __Pr, __Alloc>              _Mybase;              
    typedef pair<const __Kty, __Ty>                      _Element;             
    typedef typename __Kty                               _Kty;                 
    typedef typename __Ty                                _Ty;                  
    typedef typename check_fun_t<_Myt,_Element>          _Element_check_fun_t; 
    typedef typename check_fun_t<_Kty_container,__Kty>   _Kty_check_fun_t;     
    typedef typename check_fun_t<_Ty_container,__Ty>     _Ty_check_fun_t;      
    // inherit array operator
    _Ty& operator[] (const _Kty & key)
    {
        iterator it = insert_elem(key, _Ty()).first;
        return (*it).second;
    }

    _Kty_container keys() const
    {
        _Kty_container __container;
        for (const_iterator it=begin(); it!=end(); ++it)
        {
            __container.push_back(it->first);
        }
        return __container;
    }

    _Kty_container keys(_IN _Kty_check_fun_t check) const
    {
        _Kty_container container;
        for (const_iterator it=begin(); it!=end(); ++it)
        {
            if (check(container, it->first))
            {
                container.push_back(it->first);
            }
        }
        return container;
    }

    _Ty_container values() const
    {
        _Ty_container container;
        for (const_iterator it=begin(); it!=end(); ++it)
        {
            container.push_back(it->second);
        }
        return container;
    }

    _Ty_container values(_IN _Ty_check_fun_t check) const
    {
        _Ty_container container;
        for (const_iterator it=begin(); it!=end(); ++it)
        {
            if (check(container, it->second))
            {
                container.push_back(it->second);
            }
        }
        return container;
    }

    inline pair<iterator, bool> insert_elem(_IN const _Kty & key, _IN const _Ty& val)
    {
        return /*_Mybase::*/insert(make_pair(key, val));
    }

    _Myt select(_IN _Element_check_fun_t check) const
    {
        _Myt container;
        for (const_iterator it=begin(); it!=end(); ++it)
        {
            if (check(container, *it))
            {
                container.insert(*it);
            }
        }
        return container;
    }

    inline bool contains_key(_IN const _Kty & key) const
    {
        return find(key) != end();
    }

    const _Kty& first_key(_IN const _Kty& if_empty) const
    {
        if (size())
        {
            return begin()->first;
        }
        else
        {
            return if_empty;
        }
    }

    _Ty& first_elem(_IN _Ty& if_empty)
    {
        if (size())
        {
            return begin()->second;
        }
        else
        {
            return if_empty;
        }
    }

    const _Ty& first_elem(_IN const _Ty& if_empty) const
    {
        if (size())
        {
            return begin()->second;
        }
        else
        {
            return if_empty;
        }
    }
};

}; // namespace std

#endif // _MAP2_H_

---