/home/mhx/git/github/libmoost/include/moost/kvstore/kyoto_tycoon_client.hpp

Go to the documentation of this file.

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


















#ifndef MOOST_KVSTORE_KYOTO_TYCOON_CLIENT_HPP
#define MOOST_KVSTORE_KYOTO_TYCOON_CLIENT_HPP

#include <stdexcept>
#include <vector>

#include "i_kyoto_tycoon_connection.h"

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

namespace moost { namespace kvstore {

class KyotoTycoonClient
{
public:
   typedef IKyotoTycoonConnection connection_type;

private:
   connection_type& m_conn;

public:
   KyotoTycoonClient(connection_type& conn)
     : m_conn(conn)
   {
   }

   // vector values, returns false if key not found, throws if data alignment is wrong
   template <typename TKey, typename TVal>
   bool get(const TKey& key, std::vector<TVal>& val) const
   {
      return get(&key, sizeof(TKey), val);
   }

   // generic values, returns false if key not found, throws if value is wrong size
   template <typename TKey, typename TVal>
   bool get(const TKey& key, TVal& val) const
   {
      return get(&key, sizeof(TKey), val);
   }

   // override for string key
   template <typename TVal>
   bool get(const std::string& key, TVal& val) const
   {
      return get(key.data(), key.size(), val);
   }

   // override for string key
   template <typename TVal>
   bool get(const std::string& key, std::vector<TVal>& val) const
   {
      return get(key.data(), key.size(), val);
   }

private:

   // vector values, returns false if key not found, throws if data alignment is wrong
   template <typename TVal>
   bool get(const void* pkey, size_t ksize, std::vector<TVal>& val) const
   {
      size_t vsize;
      boost::shared_array<char> sa = m_conn.get(pkey, ksize, vsize);
      TVal *pv = reinterpret_cast<TVal *>(sa.get());
      bool found = (0 != pv);

      if (found)
      {
         if (vsize % sizeof(TVal) == 0)
         {
            val.assign(pv, pv + vsize/sizeof(TVal));
         }
         else
         {
            throw std::runtime_error("Retrieved value has incorrect data alignment");
         }
      }

      return found;
   }

   // generic values, returns false if key not found, throws if value is wrong size
   template <typename TVal>
   bool get(const void* pkey, size_t ksize, TVal& val) const
   {
      size_t vsize;
      boost::shared_array<char> sa = m_conn.get(pkey, ksize, vsize);
      TVal *pv = reinterpret_cast<TVal *>(sa.get());
      bool found = (0 != pv);

      if (found)
      {
         if (vsize == sizeof(TVal))
         {
            val = *pv;
         }
         else
         {
            throw std::runtime_error("Retrieved value has incorrect size");
         }
      }

      return found;
   }

public:

   // vector values, throws on failure
   template <typename TKey, typename TVal>
   void set(const TKey& key, const std::vector<TVal>& val) const
   {
      BOOST_STATIC_ASSERT((boost::is_pod<TKey>::value));
      BOOST_STATIC_ASSERT((boost::is_pod<TVal>::value));

      m_conn.set(&key, sizeof(key), &val[0], sizeof(TVal) * val.size());
   }

   // generic values, throws on failure
   template <typename TKey, typename TVal>
   void set(const TKey& key, const TVal& val) const
   {
      BOOST_STATIC_ASSERT((boost::is_pod<TKey>::value));
      BOOST_STATIC_ASSERT((boost::is_pod<TVal>::value));

      m_conn.set(&key, sizeof(key), &val, sizeof(val));
   }

   // vector values, throws on failure
   template <typename TKey, typename TVal>
   void cache(const TKey& key, const std::vector<TVal>& val, boost::int64_t expirySecs) const
   {
      BOOST_STATIC_ASSERT((boost::is_pod<TKey>::value));
      BOOST_STATIC_ASSERT((boost::is_pod<TVal>::value));

      m_conn.cache(&key, sizeof(key), &val[0], sizeof(TVal) * val.size(), expirySecs);
   }

   // generic values, throws on failure
   template <typename TKey, typename TVal>
   void cache(const TKey& key, const TVal& val, boost::int64_t expirySecs) const
   {
      BOOST_STATIC_ASSERT((boost::is_pod<TKey>::value));
      BOOST_STATIC_ASSERT((boost::is_pod<TVal>::value));

      m_conn.cache(&key, sizeof(key), &val, sizeof(val), expirySecs);
   }

   // vector values, throws on failure (std::string key override)
   template <typename TVal>
   void set(const std::string& key, const std::vector<TVal>& val) const
   {
      BOOST_STATIC_ASSERT((boost::is_pod<TVal>::value));

      m_conn.set(key.data(), key.size(), &val[0], sizeof(TVal) * val.size());
   }

   // generic values, throws on failure (std::string key override)
   template <typename TVal>
   void set(const std::string& key, const TVal& val) const
   {
      BOOST_STATIC_ASSERT((boost::is_pod<TVal>::value));

      m_conn.set(key.data(), key.size(), &val, sizeof(val));
   }

   // vector values, throws on failure (std::string key override)
   template <typename TVal>
   void cache(const std::string& key, const std::vector<TVal>& val, boost::int64_t expirySecs) const
   {
      BOOST_STATIC_ASSERT((boost::is_pod<TVal>::value));

      m_conn.cache(key.data(), key.size(), &val[0], sizeof(TVal) * val.size(), expirySecs);
   }

   // generic values, throws on failure (std::string key override)
   template <typename TVal>
   void cache(const std::string& key, const TVal& val, boost::int64_t expirySecs) const
   {
      BOOST_STATIC_ASSERT((boost::is_pod<TVal>::value));

      m_conn.cache(key.data(), key.size(), &val, sizeof(val), expirySecs);
   }
};

}}  // end namespace

#endif