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

Go to the documentation of this file.

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

#include "generic_map.hpp"
#include <vector>

namespace moost { namespace container { namespace policies {

template <typename TVal>
class vector_map : public generic_map< std::vector<TVal> >
{
public:

   typedef typename std::vector<TVal> map_type;

public:

   vector_map(size_t vector_size = 0)
      : m_initial_vector_size(vector_size)
   {}

   virtual ~vector_map(){}

   virtual void init(map_type& map) const
   {
      if ( m_initial_vector_size > 0 )
         map.resize(m_initial_vector_size);
   }

   virtual void resize(map_type& map, size_t numKeys) const
   { map.resize(numKeys); }

   template <typename TKey>
   TVal operator()( const std::vector<TVal>& vec, const TKey& key ) const
   {
      if ( static_cast<size_t>(key) >= vec.size() )
         throw std::runtime_error("vector_map_policy::operator(): key not found");
      else
         return vec[key];
   }

   template <typename TKey>
   bool operator()( const std::vector<TVal>& vec, const TKey& key, TVal& val ) const
   {
      if ( static_cast<size_t>(key) >= vec.size() )
         return false;
      else
         val = vec[key];
      return true;
   }


   template <typename TKey, typename TMapIterator>
   TKey get_key( const std::vector<TVal>& vec, const TMapIterator& it ) const
   { return static_cast<int>(it - vec.begin()); }

   template <typename TIgnoreThis, typename TMapIterator>
   TVal get_value( const std::vector<TVal>& /*vec*/, const TMapIterator& it ) const
   { return *it; }

   //template <typename TKey>
   //bool find(const std::vector<TVal>& vec, const TKey& key) const
   //{
   //   if ( static_cast<size_t>(key) >= vec.size() )
   //      return vec.end();
   //   else
   //      return vec.begin() + key;
   //}

private:
   const size_t m_initial_vector_size;
};

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

template <typename TKey, typename TVal>
struct map_policy_selector< TKey, TVal, std::vector<TVal> >
{
   // will return generic_map
   typedef vector_map<TVal> policy_type;
};

}}}

#endif // MOOST_VECTOR_POLICY_HPP