AndroMeta/include/AndroMeta/MMultiMap.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_MULTI_MAP_H
#define ANDROMETA_M_MULTI_MAP_H

namespace Meta{
  
  template<class Key, class T, class Compare = std::less<Key>,
  class Allocator = std::allocator<std::pair<const Key,T> > >
  class MMultiMap{
  public:
    typedef std::multimap<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 MMultiMap(const Compare& comp=Compare(),
                       const Allocator& allocator=Allocator()) 
    : map_(comp, allocator){
    }
    
    template<class InputIterator>
    MMultiMap(InputIterator first, InputIterator last,
              const Compare& comp=Compare(),
              const Allocator& allocator=Allocator())
    : map_(first, last, comp, allocator){
    }
    
    MMultiMap(const MMultiMap<Key,T,Compare,Allocator>& x)
    : map_(x.map_){
      
    }
    
    virtual ~MMultiMap(){
      
    }
    
    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();
    }
    
    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);
    }
    
    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);
    }
    
    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();
    }
    
    iterator insert(const value_type& x){
      return map_.insert(x);
    }
    
    iterator insert(iterator position, const value_type& x){
      return map_.insert(position, x);
    }
    
    template<class InputIterator>
    void insert(InputIterator first, InputIterator last){
      map_.insert(first, last);
    }
    
    MMultiMap<Key,T,Compare,Allocator>&
    add(const Key& k, const T& t){
      map_.insert(std::make_pair(k, t));
      return *this;
    }
    
    void merge(const MMultiMap<Key,T,Compare,Allocator>& m){
      map_.insert(m.begin(), m.end());
    }
    
    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);
    }
    
    iterator lowerBound(const key_type& x){
      return map_.lower_bound(x);
    }
    
    const_iterator lower_bound(const key_type& x) const{
      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_.max_size();
    }
    
    MMultiMap<Key,T,Compare,Allocator>&
    operator=(const MMultiMap<Key,T,Compare,Allocator>& x){
      map_ = x.map_;
      return *this;
    }
    
    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(MMultiMap<Key,T,Compare,Allocator>& m){
      map_.swap(m.map_);
    }
    
    iterator upper_bound(const key_type& x){
      return map_.upper_bound(x);
    }
    
    iterator upperBound(const key_type& x){
      return map_.upper_bound(x);
    }
    
    const_iterator upper_bound(const key_type& x) const{
      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();
    }
    
    const Map_& map() const{
      return map_;
    }
    
    Map_& map(){
      return map_;
    }
    
  private:
    Map_ map_;
  };
  
  template <class Key, class T, class Compare, class Allocator>
  bool operator==(const MMultiMap<Key,T,Compare,Allocator>& x,
                  const MMultiMap<Key,T,Compare,Allocator>& y){
    return x.map() == y.map();
  }
  
  template <class Key, class T, class Compare, class Allocator>
  bool operator<(const MMultiMap<Key,T,Compare,Allocator>& x,
                 const MMultiMap<Key,T,Compare,Allocator>& y){
    return x.map() < y.map();
  }
  
  template <class Key, class T, class Compare, class Allocator>
  bool operator!=(const MMultiMap<Key,T,Compare,Allocator>& x,
                  const MMultiMap<Key,T,Compare,Allocator>& y){
    return x.map() != y.map();
  }
  
  template <class Key, class T, class Compare, class Allocator>
  bool operator>(const MMultiMap<Key,T,Compare,Allocator>& x,
                 const MMultiMap<Key,T,Compare,Allocator>& y){
    return x.map() > y.map();
  }
  
  template <class Key, class T, class Compare, class Allocator>
  bool operator>=(const MMultiMap<Key,T,Compare,Allocator>& x,
                  const MMultiMap<Key,T,Compare,Allocator>& y){
    return x.map() >= y.map();
  }
  
  template <class Key, class T, class Compare, class Allocator>
  bool operator<=(const MMultiMap<Key,T,Compare,Allocator>& x,
                  const MMultiMap<Key,T,Compare,Allocator>& y){
    return x.map() <= y.map();
  }
  
  template<typename K, typename T>
  std::ostream& operator<<(std::ostream& ostr, const MMultiMap<K,T>& m){
    typename MMultiMap<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_MULTI_MAP_H