tpl_dynMapTree.H

# ifndef TPL_DYNMAPTREE_H
# define TPL_DYNMAPTREE_H

# include <tpl_dynSetTree.H>
 
using namespace Aleph;

namespace Aleph {

template <
  typename Key, typename Data,
  template <typename, class> class Tree = Avl_Tree,
  class Compare = Aleph::less<Key>>
class DynMapTree : 
public DynSetTree<std::pair<Key, Data>, Tree, Dft_Pair_Cmp<Key, Data, Compare>>
{
  typedef std::pair<Key, Data> Pair;

  typedef DynSetTree<Pair, Tree, Dft_Pair_Cmp<Key, Data, Compare>> Base;

public:

  typedef Key Key_Type;

  typedef Key Item_Type;

  typedef Data Value_Type;

  using Base::Base;  

    Data & get_data(const Key & key)
    {
      return key_to_pair<Key, Data>(&const_cast<Key&>(key))->second;    
    }

    const Key & get_key(Data * data_ptr)
    {
      return data_to_pair<Key, Data>(data_ptr)->first;
    }

  Key * insert(const Key & key, const Data & data)
  {
    Pair * p = this->Base::insert(Pair(key, data));
    return p != NULL ? &p->first : NULL;
  }

  Key * insert(const Key & key, Data && data = Data())
  {
    Pair * p = this->Base::insert(Pair(key, std::move(data)));
    return p != NULL ? &p->first : NULL;
  }
  
  Key * insert(Key && key, const Data & data)
  {
    Pair * p = this->Base::insert(Pair(std::move(key), data));
    return p != NULL ? &p->first : NULL;
  }

  Key * insert(Key && key, Data && data = Data())
  {
    Pair * p = this->Base::insert(Pair(std::move(key), std::move(data)));
    return p != NULL ? &p->first : NULL;
  }

  Key * search_or_insert(const Key & key, const Data & data)
  {
    return &this->Base::search_or_insert(Pair(key, data))->first;
  }

  Data * search_or_insert(const Key & key, Data && data)
  {
    return &this->Base::search_or_insert(Pair(key, std::move(data)))->first;
  }

  Data * search_or_insert(Key && key, const Data & data)
  {
    return &this->Base::search_or_insert(Pair(std::move(key), data))->first;
  }

  Data * search_or_insert(Key && key, Data && data)
  {
    return &search_or_insert(Pair(std::move(key), std::move(data)))->first;
  }

  Key * put(const Key & key, const Data & data)
  {
    return insert(key, data);
  }

  Key * put(const Key & key, Data && data)
  {
    return insert(key, std::move(data));
  }

  Key * put(Key && key, const Data & data)
  {
    return insert(std::move(key), data);
  }

  Key * put(Key && key, Data && data)
  {
    return insert(std::move(key), std::move(data));
  }

  size_t remove(const Key & key)
  {
    return this->Base::remove(Pair(key, Data()));
  }

  bool test_key(const Key & key) const
  {
    return this->Base::exist(Pair(key, Data()));
  }

  bool has(const Key & key) const { return test_key(key); }

  Data * test(const Key & key)
  {
    Pair * p = this->Base::search(Pair(key, Data()));
    return p != NULL ? &p->second : NULL;
  }

  Data * search(const Key & key) const
  {
    Pair * p = this->Base::search(Pair(key, Data()));
    return p != NULL ? &p->second : NULL;
  }

  Data & find(const Key & key) 
  { 
    return this->Base::find(Pair(key, Data())).second;
  }

  Map_Sequences_Methods();

  Generate_Proxy_Operator(DynMapTree);
};
} // end namespace Aleph


# include <tpl_binTree.H>
# include <tpl_avl.H>
# include <tpl_rb_tree.H>
# include <tpl_rand_tree.H>
# include <tpl_treap.H>
# include <tpl_treapRk.H>
# include <tpl_splay_tree.H>

namespace Aleph {
  template <typename Key, typename Type, class Compare = Aleph::less<Key> >
  class DynMapBinTree : public DynMapTree<Key, Type, BinTree, Compare> {};

  template <typename Key, typename Type, class Compare = Aleph::less<Key> >
  class DynMapAvlTree : public DynMapTree<Key, Type, Avl_Tree, Compare> {};
    template <typename Key, typename Type, class Compare = Aleph::less<Key> >
    class DynMapRbTree : public DynMapTree<Key, Type, Rb_Tree, Compare>
    { /* empty */ };

    template <typename Key, typename Type, class Compare = Aleph::less<Key> >
    class DynMapRandTree : public DynMapTree<Key, Type, Rand_Tree, Compare>
    { /* empty */ };

    template <typename Key, typename Type, class Compare = Aleph::less<Key> >
    class DynMapTreap : public DynMapTree<Key, Type, Treap, Compare>
    { /* empty */ };

    template <typename Key, typename Type, class Compare = Aleph::less<Key> >
    class DynMapTreapRk : public DynMapTree<Key, Type, Treap_Rk, Compare>
    { /* empty */ };

    template <typename Key, typename Type, class Compare = Aleph::less<Key> >
    class DynMapSplayTree : public DynMapTree<Key, Type, Splay_Tree, Compare>
    { /* empty */ };

} // end namespace Aleph

# endif /* TPL_DYNMAPTREE_H */