/home/mhx/git/github/libmoost/include/moost/container/policies/generic_map.hpp

Go to the documentation of this file.

/* vim:set ts=3 sw=3 sts=3 et: */
#ifndef MOOST_GENERIC_MAP_POLICY_HPP
#define MOOST_GENERIC_MAP_POLICY_HPP

#include <vector>
#include <stdexcept>

namespace moost { namespace container { namespace policies {

template <typename TMap>
class generic_map
{
public:

   typedef TMap map_type;

   virtual ~generic_map() {}

   virtual void init(TMap& /*map*/) const
   {}

   virtual void resize(TMap& /*map*/, size_t /*numKeys*/) const
   {}

   virtual void swap(TMap& first, TMap& second) const
   { first.swap(second); }

   virtual size_t size(const TMap& map) const
   { return map.size(); }

   virtual void clear(TMap& map) const
   { map.clear(); }

   template <typename TKey>
   bool remove(TMap& map, const TKey& key) const
   {
      typename TMap::iterator it = map.find(key);
      if ( it == map.end() )
         return false;
      map.erase(it);
      return true;
   }

   template <typename TKey>
   bool find(const TMap& map, const TKey& key) const
   { return map.find(key) != map.end(); }

   template <typename TKey, typename TVal>
   TVal operator()( const TMap& map, const TKey& key ) const
   {
      typename TMap::const_iterator it = map.find(key);
      if ( it == map.end() )
         throw std::runtime_error("generic_policy::operator(): key not found");
      return get_value<TVal>(map, it);
   }

   template <typename TKey, typename TVal>
   bool operator()( const TMap& map, const TKey& key, TVal& val ) const
   {
      typename TMap::const_iterator it = map.find(key);
      if ( it == map.end() )
         return false;
      get_value(val, map, it);
      return true;
   }

   template <typename Key, typename T>
   bool put( TMap& map, const Key& key, const T& val ) const
   {
      map[key] = val;
      return true;
   }

   template <typename TKey>
   void get_keys( const TMap& map, std::vector<TKey>& keys ) const
   {
      typename TMap::const_iterator it;
      keys.resize( size(map) );
      int i = 0;
      for ( it = map.begin(); it != map.end(); ++it, ++i)
         keys[i] = get_key<TKey>(map, it);
   }

   // if not using maps with first and second, those need to be
   // overridden

   template <typename TKey, typename TMapIterator>
   TKey get_key( const TMap& /*map*/, const TMapIterator& it ) const
   { return it->first; }

   template <typename TVal, typename TMapIterator>
   TVal get_value( const TMap& /*map*/, const TMapIterator& it ) const
   { return it->second; }

   template <typename TKey, typename TMapIterator>
   void get_key( TKey& key, const TMap& map, const TMapIterator& it ) const
   { key = get_key<TKey>(map, it); }

   template <typename TVal, typename TMapIterator>
   void get_value( TVal& value, const TMap& map, const TMapIterator& it ) const
   { value = get_value<TVal>(map, it); }
};

// -----------------------------------------------------------------------------

template <typename TKey, typename TVal, typename TMap>
struct map_policy_selector
{
   // will return generic_map
   typedef generic_map<TMap> policy_type;
};


}}}

#endif // MOOST_GENERIC_MAP_POLICY_HPP