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

Go to the documentation of this file.

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

#include <cassert>
#include <stdexcept>
#include <vector>

#include <boost/shared_ptr.hpp>

#include "ikvds.hpp"
#include "kvds_integral_type.hpp"

#ifndef MOOST_KVDS_KVDS_HPP__
#define MOOST_KVDS_KVDS_HPP__

namespace moost { namespace kvds {

   typedef boost::shared_ptr<IKvds> ikvds_ptr_t;




   template <
      typename keyT, // the type of the key
      typename valT, // the type of the value

      // policy for serialising the key -- default is to treat it as an integeral type
      template <typename> class KvdsTypeKey = KvdsIntegralType,

      // policy for serialising the value -- default is to treat it as an integeral type
      template <typename> class KvdsTypeVal = KvdsIntegralType
   >
   class Kvds
   {
      template <typename kvdsT> friend class KvdsKeyIterator;

   public:
      typedef keyT key_type;
      typedef valT val_type;
      typedef std::vector<val_type> kvds_values_t;

      typedef std::pair<key_type, val_type> value_type;
      typedef val_type data_type;

   private:
      typedef KvdsTypeKey<key_type> kvds_key_t;
      typedef KvdsTypeVal<val_type> kvds_val_t;
      typedef KvdsTypeKey<key_type const> kvds_key_const_t;
      typedef KvdsTypeVal<val_type const> kvds_val_const_t;

   public:
      Kvds(ikvds_ptr_t ikvds_ptr) :
         ikvds_ptr_(ikvds_ptr)
         {
            assert(ikvds_ptr_); // catch it in debug!
            if(!ikvds_ptr_) { throw std::runtime_error("Datastore cannot be initialised with a null ikvds"); }
         }

         bool put(kvds_key_const_t const & key, kvds_val_const_t const & val) const
         {
            return ikvds_ptr_->put(
               &key, key.size(),
               &val, val.size()
               );
         }

         bool put(kvds_key_const_t const & key, kvds_values_t const & vals) const
         {
            typename kvds_val_const_t::vector_type kvds_val_vector(vals);

            return ikvds_ptr_->put(
               &key, key.size(),
               &kvds_val_vector, kvds_val_vector.size()
               );
         }

         bool get(kvds_key_const_t const & key, kvds_val_t val) const
         {
            bool found = ikvds_ptr_->get(
               &key, key.size(),
               &val, val.size()
               );

            *val; // Reassemble val

            return found;
         }

         bool get(kvds_key_const_t const & key, kvds_values_t & vals, size_t const count) const
         {
            vals.resize(count);
            typename kvds_val_t::vector_type kvds_val_vector(vals);

            size_t esize = kvds_val_vector.size();

            bool found = esize > 0 ? ikvds_ptr_->get(&key, key.size(), &kvds_val_vector, esize) : false;

            if(found)
            {
               if(esize < kvds_val_vector.size())
               {
                  // read less than the buffer size so before we must resize buffer
                  kvds_val_vector.resize(esize);
               }

               *kvds_val_vector; // Reassemble vals
            }

            return found;
         }

         bool get(kvds_key_const_t const & key, kvds_values_t & vals) const
         {
            typename kvds_val_t::vector_type kvds_val_vector(vals);

            bool found = false;
            size_t esize = 0;

            if(ikvds_ptr_->siz(&key, key.size(), esize))
            {
               kvds_val_vector.resize(esize);

               found = ikvds_ptr_->all(&key, key.size(), &kvds_val_vector, esize);

               if(found)
               {
                  *kvds_val_vector; // Reassemble vals
               }
            }

            return found;
         }

         bool insert(value_type const & kvp) // Just to be more STL map like
         {
            return put(kvp.first, kvp.second);
         }

         bool add(kvds_key_const_t const & key, kvds_val_const_t const & val) const
         {
            return ikvds_ptr_->add(
               &key, key.size(),
               &val, val.size()
               );
         }

         bool exists(kvds_key_const_t const & key) const
         {
            return ikvds_ptr_->xst(&key, key.size());
         }

         bool erase(kvds_key_const_t const & key) const
         {
            return ikvds_ptr_->del(&key, key.size());
         }

         bool clear() const
         {
            return ikvds_ptr_->clr();
         }

         bool size(kvds_key_const_t const & key, size_t & size) const
         {
            bool found = ikvds_ptr_->siz(&key, key.size(), size);

            if(found && (0 != (size % sizeof(typename kvds_values_t::value_type))))
            {
               throw std::runtime_error("value type boundary error");
            }

            size /= sizeof(typename kvds_values_t::value_type);

            return found;
         }

         size_t size(kvds_key_const_t const & key) const
         {
            size_t size = 0;

            if(!this->size(key, size))
            {
               throw std::runtime_error("item not found");
            }

            return size;
         }

         bool count(boost::uint64_t & cnt) const
         {
            return ikvds_ptr_->cnt(cnt);
         }

         boost::uint64_t size() const // Just to be more STL like
         {
            boost::uint64_t cnt = 0;

            if(!count(cnt))
            {
                throw std::runtime_error("size not available");
            }

            return cnt;
         }

         bool empty() const
         {
            bool isnil = false;

            if(!ikvds_ptr_->nil(isnil))
            {
                throw std::runtime_error("empty state is not available");
            }

            return isnil;
         }

         IKvds & get_ikvds() const
         {
            if(!ikvds_ptr_) { throw std::runtime_error("Invalid kvds interface"); }
            return *ikvds_ptr_;
         }

         ikvds_ptr_t get_ikvds_ptr() const
         {
            return ikvds_ptr_;
         }

   private:

      class Iow // Indexed object wrapper (needs no external visibility!)
      {
      public:
         Iow(
            Kvds & kvds,
            kvds_key_const_t const & key
            ) : kvds_(kvds), key_(key), val_(val_type()) {}

         Iow & operator = (val_type const & val)
         {
            val_ = val;

            if(!kvds_.put(key_, val_))
            {
               throw std::runtime_error("Write to datastore failed");
            }

            return *this;
         }

         val_type & operator * () { return val_; }

         operator val_type const () { return val_; }

      private:
         Kvds & kvds_;
         kvds_key_const_t const & key_;
         val_type val_;
      };
   public:
      Iow operator [](kvds_key_const_t const & key)
      {
         Iow iow(*this, key);

         if(!get(key, *iow))
         {
            // It doesn't exist, create one
            iow = val_type();
         }

         return iow;
      }

   private:
      ikvds_ptr_t ikvds_ptr_;
   };

}}

#endif /// MOOST_KVDS_KVDS_HPP__