AndroMeta/include/AndroMeta/MMap.h

Go to the documentation of this file.

/*
 * Copyright 2009-2012 AndroMeta LLC. All rights reserved.
 *
 * AndroMeta LLC retains all intellectual property and proprietary 
 * rights to this software and related documentation and any modifications 
 * thereto.  Any use, reproduction, disclosure, or distribution of this 
 * software and related documentation without an express license agreement 
 * from AndroMeta LLC is strictly prohibited.
 * 
 */

#include <map>
#include <ostream>

#ifndef ANDROMETA_M_MAP_H
#define ANDROMETA_M_MAP_H

namespace Meta{
  
  template<class Key, class T, class Compare = std::less<Key>,
  class Allocator = std::allocator<std::pair<const Key,T> > >
  class MMap{
  public:
    typedef std::map<Key, T, Compare, Allocator> Map_;
    
    typedef typename Map_::iterator iterator;
    typedef typename Map_::const_iterator const_iterator;
    typedef typename Map_::key_type key_type;
    typedef typename Map_::allocator_type allocator_type;
    typedef typename Map_::value_type value_type;
    typedef typename Map_::key_compare key_compare;
    typedef typename Map_::reverse_iterator reverse_iterator;
    typedef typename Map_::const_reverse_iterator const_reverse_iterator;
    typedef typename Map_::value_compare value_compare;
    
    explicit MMap(const Compare& comp=Compare(),
                  const Allocator& allocator=Allocator())
    : map_(comp, allocator){
      
    }
    
    template<class InputIterator>
    MMap(InputIterator first,
         InputIterator last,
         const Compare& comp=Compare(),
         const Allocator& allocator=Allocator())
    : map_(first, last, comp, allocator){
      
    }
    
    MMap(const MMap<Key, T, Compare, Allocator>& x)
    : map_(x.map_){
    }
    
    virtual ~MMap(){
      
    }
    
    const Map_ map() const{
      return map_;
    }
    
    Map_ map(){
      return map_;
    }
    
    iterator begin(){
      return map_.begin();
    }
    
    const_iterator begin() const{
      return map_.begin();
    }
    
    void clear(){
      map_.clear();
    }
    
    size_t count(const key_type& x) const{
      return map_.count(x);
    }
    
    bool empty() const{
      return map_.empty();
    }
    
    bool isEmpty() const{
      return map_.isEmpty();
    }
    
    iterator end(){
      return map_.end();
    }
    
    const_iterator end() const{
      return map_.end();
    }
    
    std::pair<iterator,iterator>
    equal_range(const key_type& x){
      return map_.equal_range(x);
    }
    
    std::pair<const_iterator,const_iterator>
    equal_range(const key_type& x) const{
      return map_.equal_range(x);
    }
    
    std::pair<iterator,iterator>
    equalRange(const key_type& x){
      return map_.equal_range(x);
    }
    
    std::pair<const_iterator,const_iterator>
    equalRange(const key_type& x) const{
      return map_.equal_range(x);
    }
    
    void erase(iterator position){
      map_.erase(position);
    }
    
    size_t erase(const key_type& x){
      return map_.erase(x);
    }
    
    void erase(iterator first, iterator last){
      map_.erase(first, last);
    }
    
    iterator find(const key_type& x){
      return map_.find(x);
    }
    
    bool hasKey(const key_type& x) const{
      return map_.find(x) != map_.end();
    }
    
    const_iterator find(const key_type& x) const{
      return map_.find(x);
    }
    
    allocator_type get_allocator() const{
      return map_.get_allocator();
    }
    
    allocator_type getAllocator() const{
      return map_.get_allocator();
    }
    
    std::pair<iterator, bool> insert(const value_type& x){
      return map_.insert(x);
    }
    
    iterator insert(iterator position, const value_type& x){
      return map_.insert(position, x);
    }
    
    void merge(const MMap<Key,T,Compare,Allocator>& m){
      map_.insert(m.begin(), m.end());
    }
    
    void outerMerge(const MMap<Key,T,Compare,Allocator>& m){
      typename MMap<Key,T,Compare,Allocator>::const_iterator i = m.begin();
      while(i != m.end()){
        typename MMap<Key,T,Compare,Allocator>::iterator j = map_.find(i->first);
        if(j != map_.end()){
          j->second = i->second;
        }
        else{
          map_.insert(std::pair<Key,T>(i->first, i->second));
        }
        ++i;
      }
    }
    
    template<class InputIterator>
    void insert(InputIterator first, InputIterator last){
      map_.insert(first, last);
    }
    
    MMap<Key,T,Compare,Allocator>&
    add(const Key& k, const T& t){
      map_.insert(std::make_pair(k, t));
      return *this;
    }
    
    key_compare key_comp() const{
      return map_.key_comp();
    }
    
    key_compare keyCompare() const{
      return map_.key_comp();
    }
    
    iterator lower_bound(const key_type& x){
      return map_.lower_bound(x);
    }
    
    const_iterator lower_bound(const key_type& x) const{
      return map_.lower_bound(x);
    }
    
    iterator lowerBound(const key_type& x){
      return map_.lower_bound(x);
    }
    
    const_iterator lowerBound(const key_type& x) const{
      return map_.lower_bound(x);
    }
    
    size_t max_size() const{
      return map_.max_size();
    }
    
    size_t maxSize() const{
      return map_.maxSize();
    }
    
    MMap<Key,T,Compare,Allocator>&
    operator=(const MMap<Key,T,Compare,Allocator>& x){
      map_ = x.map_;
      return *this;
    }
    
    T& operator[](const key_type& x){
      return map_[x];
    }
    
    reverse_iterator rbegin(){
      return map_.rbegin();
    }
    
    const_reverse_iterator rbegin() const{
      return map_.rbegin();
    }
    
    reverse_iterator rend(){
      return map_.rend();
    }
    
    const_reverse_iterator rend() const{
      return map_.rend();
    }
    
    size_t size() const{
      return map_.size();
    }
    
    void swap(MMap<Key,T,Compare,Allocator>& mp){
      map_.swap(mp);
    }
    
    iterator upper_bound(const key_type& x){
      return map_.upper_bound(x);
    }
    
    const_iterator upper_bound(const key_type& x) const{
      return map_.upper_bound(x);
    }
    
    iterator upperBound(const key_type& x){
      return map_.upper_bound(x);
    }
    
    const_iterator upperBound(const key_type& x) const{
      return map_.upper_bound(x);
    }
    
    value_compare value_comp() const{
      return map_.value_comp();
    }
    
    value_compare valueCompare() const{
      return map_.value_comp();
    }
    
  private:
    Map_ map_;
  };
  
  template<class Key, class T, class Compare, class Allocator>
  bool operator==(const MMap<Key,T,Compare,Allocator>& x,
                  const MMap<Key,T,Compare,Allocator>& y){
    return x.map() == y.map();
  }
  
  template<class Key, class T, class Compare, class Allocator>
  bool operator!=(const MMap<Key,T,Compare,Allocator>& x,
                  const MMap<Key,T,Compare,Allocator>& y){
    return x.map() != y.map();
  }
  
  template<class Key, class T, class Compare, class Allocator>
  bool operator<(const MMap<Key,T,Compare,Allocator>& x,
                 const MMap<Key,T,Compare,Allocator>& y){
    return x.map() < y.map();
  }
  
  template<class Key, class T, class Compare, class Allocator>
  bool operator>(const MMap<Key,T,Compare,Allocator>& x,
                 const MMap<Key,T,Compare,Allocator>& y){
    return x.map() > y.map();
  }
  
  template<class Key, class T, class Compare, class Allocator>
  bool operator<=(const MMap<Key,T,Compare,Allocator>& x,
                  const MMap<Key,T,Compare,Allocator>& y){
    return x.map() <= y.map();
  }
  
  template<class Key, class T, class Compare, class Allocator>
  bool operator>=(const MMap<Key,T,Compare,Allocator>& x,
                  const MMap<Key,T,Compare,Allocator>& y){
    return x.map() >= y.map();
  }
  
  template<typename K, typename T>
  std::ostream& operator<<(std::ostream& ostr, const MMap<K,T>& m){
    typename MMap<K,T>::const_iterator itr = m.begin();
    ostr << "[";
    while(itr != m.end()){
      if(itr != m.begin()){
        ostr << ", ";
      }
      ostr << itr->first << ":";
      ostr << itr->second;
      ++itr;
    }
    ostr << "]";
    return ostr;
  }
  
} // end namespace Meta

#endif // ANDROMETA_M_MAP_H