StlMultiMap.hxx

Go to the documentation of this file.

 
#ifndef _UTILS_STLMULTIMAP_HXX_
#define _UTILS_STLMULTIMAP_HXX_
 
#include <map>
 
#include "utils/Allocator.hxx"
#include "utils/macros.h"
 
template <typename Key, typename Value> class StlMultiMap
{
public:
    StlMultiMap()
        : mappingAllocator(NULL),
          mapping(new Mapping())
    {
    }
 
    StlMultiMap(size_t entries) 
        : mappingAllocator(new MappingAllocator(std::less<Key>(), Allocator<std::pair<const Key, Value>>(entries))),
          mapping(NULL)
    {
    }
 
    ~StlMultiMap()
    {
        if (mappingAllocator)
        {
            delete mappingAllocator;
        }
        if (mapping)
        {
            delete mapping;
        }
    }
 
    typedef std::pair<Key, Value> Pair;
 
    typedef typename std::multimap<Key, Value>::iterator Iterator;
 
    size_t erase(Key key)
    {
        return mapping ? mapping->erase(key) : mappingAllocator->erase(key);
    }
    
    void erase(Iterator it)
    {
        mapping ? mapping->erase(it) : mappingAllocator->erase(it);
    }
 
    Iterator insert(const Iterator pos, const Pair& val)
    {
        return mapping ? mapping->insert(pos, val) : mappingAllocator->insert(pos, val);
    }
 
    Iterator insert(const Pair& val)
    {
        return mapping ? mapping->insert(val) : mappingAllocator->insert(val);
    }
 
    size_t size()
    {
        return mapping ? mapping->size() : mappingAllocator->size();
    }
 
    size_t max_size()
    {
        return mapping ? mapping->max_size() : mappingAllocator->max_size();
    }
 
    Iterator find( const Key &key )
    {
        return mapping ? mapping->find(key) : mappingAllocator->find(key);
    }
    
    Iterator lower_bound(const Key& key)
    {
        return mapping ? mapping->lower_bound(key) : mappingAllocator->lower_bound(key);
    }
 
    Iterator upper_bound(const Key& key)
    {
        return mapping ? mapping->upper_bound(key) : mappingAllocator->upper_bound(key);
    }
 
    Iterator end()
    {
        return mapping ? mapping->end() : mappingAllocator->end();
    }
    
    Iterator begin()
    {
        return mapping ? mapping->begin() : mappingAllocator->begin();
    }
 
    size_t count(const Key& key) const
    {
        return mapping ? mapping->count(key) : mappingAllocator->count(key);
    }
 
private:
    typedef std::multimap<Key, Value, std::less<Key>, Allocator<std::pair<const Key, Value>>> MappingAllocator;
    
    typedef std::multimap<Key, Value> Mapping;
    
    MappingAllocator *mappingAllocator;
    
    Mapping *mapping;
 
    DISALLOW_COPY_AND_ASSIGN(StlMultiMap);
};
 
#endif /* _UTILS_STLMULTIMAP_HXX_ */