/home/mhx/git/github/libmoost/include/moost/kvds/kvds_pod_type.hpp

Go to the documentation of this file.

/* vim:set ts=3 sw=3 sts=3 et: */


#include <vector>

#include <boost/type_traits.hpp>
#include <boost/static_assert.hpp>

#include "ikvds.hpp"

#ifndef MOOST_KVDS_KVDS_POD_TYPE_HPP__
#define MOOST_KVDS_KVDS_POD_TYPE_HPP__

namespace moost { namespace kvds {



   template <typename T>
   class KvdsPodType 
   {
   public:
      typedef T kvds_type;

      BOOST_STATIC_ASSERT(boost::is_pod<T>::value);

      KvdsPodType(T & t) : t_(t), size_(sizeof(T)) {}

      KvdsPodType(KvdsPodType const & t) : t_(t.t_), size_(t.size_) {}

      KvdsPodType & operator = (KvdsPodType const & rhs)
      {
         t_ = rhs.t_;
         size_ = rhs.size_;
      }

      bool operator == (T const & t) const { return t_ == t; }
      bool operator != (T const & t) const { return !(t_ == t); }
      bool operator == (KvdsPodType<T> const & t) const { return t_ == t.t_; }
      bool operator != (KvdsPodType<T> const & t) const { return !(*this == t); }


      size_t size() const { return size_; }

      kvds_type const * operator & () const { return &t_; }

      kvds_type & operator * () const { return t_; }


      size_t & size() { return size_; }

      kvds_type * operator & () { return &t_; }

      kvds_type & operator * () { return t_; }

      class vector_type
      {
      public:
         template <typename U>
         struct kvds_vector
         {
            typedef std::vector<U> type;
            private: kvds_vector();
         };

         template <typename U>
         struct kvds_vector<U const>
         {
            typedef std::vector<typename boost::remove_const<U>::type> const type;
            private: kvds_vector();
         };

         typedef typename kvds_vector<kvds_type>::type kvds_vector_type;

         vector_type(kvds_vector_type & kvt) : kvt_(kvt), kvt_size_(kvt.size() * sizeof(kvds_type)) {}

         void resize(size_t const size)
         {
            if(0 != (size % sizeof(kvds_type)))
            {
               throw std::runtime_error("size is invalid for kvds_type");
            }

            kvt_size_ = size;
            kvt_.resize(kvt_size_ / sizeof(kvds_type));
         }

         size_t size() const { return kvt_size_; }

         kvds_type * operator & () { return &kvt_[0]; }

         kvds_vector_type & operator * () { return kvt_; }

      private:
         kvds_vector_type & kvt_;
         size_t kvt_size_;
      };

   private:
      kvds_type & t_;
      size_t size_;
   };

}}

#endif // MOOST_KVDS_KVDS_POD_TYPE_HPP__