From: Padraig O'Sullivan <osullivan.padraig@gmail.com>
Date: Sun, 26 Jul 2009 23:46:39 +0000 (-0400)
Subject: This commit contains the following changes:
X-Git-Tag: 0.32~6^2~6
X-Git-Url: https://git.m6w6.name/?a=commitdiff_plain;h=e072f345a0df02cd6f437e9965debeb6afacb366;p=m6w6%2Flibmemcached

This commit contains the following changes:

 * added a memcache namespace
 * renamed C++ API header file to *.hpp extension
 * modified the C++ API test cases
---

diff --git a/libmemcached/memcached.hh b/libmemcached/memcached.hh
deleted file mode 100644
index b6bcf516..00000000
--- a/libmemcached/memcached.hh
+++ /dev/null
@@ -1,508 +0,0 @@
-/*
- * Summary: C++ interface for memcached server
- *
- * Copy: See Copyright for the status of this software.
- *
- * Authors: Padraig O'Sullivan <osullivan.padraig@gmail.com>
- *          Patrick Galbraith <patg@patg.net>
- */
-
-/**
- * @file memcached.hh
- * @brief Libmemcached C++ interface
- */
-
-#ifndef LIBMEMCACHEDPP_H
-#define LIBMEMCACHEDPP_H
-
-#include <libmemcached/memcached.h>
-
-#include <string.h>
-
-#include <string>
-#include <vector>
-
-/**
- * This is the core memcached library (if later, other objects
- * are needed, they will be created from this class).
- */
-class Memcached
-{
-public:
-
-  Memcached() 
-    : 
-      memc(),
-      result()
-  {
-    memcached_create(&memc);
-  }
-
-  Memcached(memcached_st *clone) 
-    : 
-      memc(),
-      result()
-  {
-    memcached_clone(&memc, clone);
-  }
-
-  Memcached(const Memcached &rhs)
-    :
-      memc(),
-      result()
-  {
-    memcached_clone(&memc, const_cast<memcached_st *>(&rhs.getImpl()));
-  }
-
-  ~Memcached()
-  {
-    memcached_free(&memc);
-  }
-
-  /**
-   * Get the internal memcached_st *
-   */
-  memcached_st &getImpl()
-  {
-    return memc;
-  }
-
-  /**
-   * Get the internal memcached_st *
-   */
-  const memcached_st &getImpl() const
-  {
-    return memc;
-  }
-
-  /**
-   * Return an error string for the given return structure.
-   *
-   * @param[in] rc a memcached_return structure
-   * @return error string corresponding to given return code in the library.
-   */
-  const std::string getError(memcached_return rc) const
-  {
-    /* first parameter to strerror is unused */
-    return memcached_strerror(NULL, rc);
-  }
-
-  bool fetch(std::string &key, 
-             std::vector<char> &ret_val,
-             uint32_t *flags,
-             memcached_return *rc)
-  {
-    char ret_key[MEMCACHED_MAX_KEY];
-    size_t value_length= 0;
-    size_t key_length= 0;
-    char *value= memcached_fetch(&memc, ret_key, &key_length,
-                                 &value_length, flags, rc);
-    if (value && ret_val.empty())
-    {
-      ret_val.reserve(value_length);
-      memcpy(&*ret_val.begin(), value, value_length);
-      key.assign(ret_key);
-      return true;
-    }
-    return false;
-  }
-
-  std::vector<char> &get(const std::string &key, 
-                         std::vector<char> &ret_val)
-  {
-    uint32_t flags= 0;
-    memcached_return rc;
-    size_t value_length= 0;
-
-    if (key.empty())
-    {
-      return ret_val;
-    }
-    char *value= memcached_get(&memc, key.c_str(), key.length(),
-                               &value_length, &flags, &rc);
-    if (value != NULL && ret_val.empty())
-    {
-      ret_val.reserve(value_length);
-      memcpy(&ret_val[0], value, value_length);
-    }
-    return ret_val;
-  }
-
-  std::vector<char> &getByKey(const std::string &master_key, 
-                              const std::string &key, 
-                              std::vector<char> &ret_val)
-  {
-    uint32_t flags= 0;
-    memcached_return rc;
-    size_t value_length= 0;
-
-    if (master_key.empty() || key.empty())
-    {
-      return ret_val;
-    }
-    char *value= memcached_get_by_key(&memc, 
-                                      master_key.c_str(), master_key.length(), 
-                                      key.c_str(), key.length(),
-                                      &value_length, &flags, &rc);
-    if (value)
-    {
-      ret_val.reserve(value_length);
-      memcpy(&*ret_val.begin(), value, value_length);
-    }
-    return ret_val;
-  }
-
-  bool mget(std::vector<std::string> &keys)
-  {
-    std::vector<const char *> real_keys;
-    std::vector<size_t> key_len;
-    /*
-     * Construct an array which will contain the length
-     * of each of the strings in the input vector. Also, to
-     * interface with the memcached C API, we need to convert
-     * the vector of std::string's to a vector of char *.
-     */
-    real_keys.reserve(keys.size());
-    key_len.reserve(keys.size());
-
-    std::vector<std::string>::iterator it= keys.begin();
-
-    while (it != keys.end())
-    {
-      real_keys.push_back(const_cast<char *>((*it).c_str()));
-      key_len.push_back((*it).length());
-      ++it;
-    }
-
-    /*
-     * If the std::vector of keys is empty then we cannot 
-     * call memcached_mget as we will get undefined behavior.
-     */
-    if (! real_keys.empty())
-    {
-      memcached_return rc= memcached_mget(&memc, &real_keys[0], &key_len[0], 
-                                          real_keys.size());
-      return (rc == MEMCACHED_SUCCESS);
-    }
-
-    return false;
-  }
-
-  bool set(const std::string &key, 
-           const std::vector<char> &value,
-           time_t expiration,
-           uint32_t flags)
-  {
-    if (key.empty() || value.empty())
-    {
-      return false;
-    }
-    memcached_return rc= memcached_set(&memc, 
-                                       key.c_str(), key.length(),
-                                       &value[0], value.size(),
-                                       expiration, flags);
-    return (rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
-  }
-
-  bool setAll(std::vector<std::string> &keys,
-              std::vector< std::vector<char> > &values,
-              time_t expiration,
-              uint32_t flags)
-  {
-    if (keys.size() != values.size())
-    {
-      return false;
-    }
-    bool retval= true;
-    std::vector<std::string>::iterator key_it= keys.begin();
-    std::vector< std::vector<char> >::iterator val_it= values.begin();
-    while (key_it != keys.end())
-    {
-      retval= set((*key_it), (*val_it), expiration, flags);
-      if (retval == false)
-      {
-        return retval;
-      }
-      ++key_it;
-      ++val_it;
-    }
-    return retval;
-  }
-
-  bool setByKey(const std::string &master_key, 
-                const std::string &key, 
-                const std::vector<char> &value,
-                time_t expiration,
-                uint32_t flags)
-  {
-    if (master_key.empty() ||
-        key.empty() ||
-        value.empty())
-    {
-      return false;
-    }
-    memcached_return rc= memcached_set_by_key(&memc, master_key.c_str(), 
-                                              master_key.length(),
-                                              key.c_str(), key.length(),
-                                              &value[0], value.size(),
-                                              expiration,
-                                              flags);
-    return (rc == MEMCACHED_SUCCESS);
-  }
-
-  bool increment(const std::string &key, unsigned int offset, uint64_t *value)
-  {
-    if (key.empty())
-    {
-      return false;
-    }
-    memcached_return rc= memcached_increment(&memc, key.c_str(), key.length(),
-                                             offset, value);
-    return (rc == MEMCACHED_SUCCESS);
-  }
-
-  bool decrement(const std::string &key, unsigned int offset, uint64_t *value)
-  {
-    if (key.empty())
-    {
-      return false;
-    }
-    memcached_return rc= memcached_decrement(&memc, key.c_str(), 
-                                             key.length(),
-                                             offset, value);
-    return (rc == MEMCACHED_SUCCESS);
-  }
-
-
-  bool add(const std::string &key, const std::vector<char> &value)
-  {
-    if (key.empty() || value.empty())
-    {
-      return false;
-    }
-    memcached_return rc= memcached_add(&memc, key.c_str(), key.length(), 
-                                       &value[0], value.size(), 0, 0);
-    return (rc == MEMCACHED_SUCCESS);
-  }
-
-  bool addByKey(const std::string &master_key, 
-                const std::string &key, 
-                const std::vector<char> &value)
-  {
-    if (master_key.empty() ||
-        key.empty() || 
-        value.empty())
-    {
-      return false;
-    }
-    memcached_return rc= memcached_add_by_key(&memc, 
-                                              master_key.c_str(),
-                                              master_key.length(),
-                                              key.c_str(),
-                                              key.length(),
-                                              &value[0], 
-                                              value.size(),
-                                              0, 0);
-    return (rc == MEMCACHED_SUCCESS);
-  }
-
-  bool replace(const std::string &key, const std::vector<char> &value)
-  {
-    if (key.empty() ||
-        value.empty())
-    {
-      return false;
-    }
-    memcached_return rc= memcached_replace(&memc, key.c_str(), key.length(),
-                                           &value[0], value.size(),
-                                           0, 0);
-    return (rc == MEMCACHED_SUCCESS);
-  }
-
-  bool replaceByKey(const std::string &master_key, 
-                    const std::string &key, 
-                    const std::vector<char> &value)
-  {
-    if (master_key.empty() ||
-        key.empty() ||
-        value.empty())
-    {
-      return false;
-    }
-    memcached_return rc= memcached_replace_by_key(&memc, 
-                                                  master_key.c_str(), 
-                                                  master_key.length(),
-                                                  key.c_str(), 
-                                                  key.length(),
-                                                  &value[0], 
-                                                  value.size(), 
-                                                  0, 0);
-    return (rc == MEMCACHED_SUCCESS);
-  }
-
-  bool prepend(const std::string &key, const std::vector<char> &value)
-  {
-    if (key.empty() || value.empty())
-    {
-      return false;
-    }
-    memcached_return rc= memcached_prepend(&memc, key.c_str(), key.length(),
-                                           &value[0], value.size(), 0, 0);
-    return (rc == MEMCACHED_SUCCESS);
-  }
-
-  bool prependByKey(const std::string &master_key, 
-                    const std::string &key, 
-                    const std::vector<char> &value)
-  {
-    if (master_key.empty() ||
-        key.empty() ||
-        value.empty())
-    {
-      return false;
-    }
-    memcached_return rc= memcached_prepend_by_key(&memc, 
-                                                  master_key.c_str(), 
-                                                  master_key.length(),
-                                                  key.c_str(), 
-                                                  key.length(),
-                                                  &value[0], 
-                                                  value.size(),
-                                                  0,
-                                                  0);
-    return (rc == MEMCACHED_SUCCESS);
-  }
-
-  bool append(const std::string &key, const std::vector<char> &value)
-  {
-    if (key.empty() || value.empty())
-    {
-      return false;
-    }
-    memcached_return rc= memcached_append(&memc, 
-                                          key.c_str(), 
-                                          key.length(),
-                                          &value[0], 
-                                          value.size(), 
-                                          0, 0);
-    return (rc == MEMCACHED_SUCCESS);
-  }
-
-  bool appendByKey(const std::string &master_key, 
-                   const std::string &key, 
-                   const std::vector<char> &value)
-  {
-    if (master_key.empty() ||
-        key.empty() ||
-        value.empty())
-    {
-      return false;
-    }
-    memcached_return rc= memcached_append_by_key(&memc,
-                                                 master_key.c_str(), 
-                                                 master_key.length(),
-                                                 key.c_str(), 
-                                                 key.length(),
-                                                 &value[0], 
-                                                 value.size(), 
-                                                 0, 0);
-    return (rc == MEMCACHED_SUCCESS);
-  }
-
-  bool cas(const std::string &key, 
-           const std::vector<char> &value, 
-           uint64_t cas_arg)
-  {
-    if (key.empty() || value.empty())
-    {
-      return false;
-    }
-    memcached_return rc= memcached_cas(&memc, key.c_str(), key.length(),
-                                       &value[0], value.size(), 
-                                       0, 0, cas_arg);
-    return (rc == MEMCACHED_SUCCESS);
-  }
-
-  bool casByKey(const std::string &master_key, 
-                const std::string &key, 
-                const std::vector<char> &value, 
-                uint64_t cas_arg)
-  {
-    if (master_key.empty() ||
-        key.empty() ||
-        value.empty())
-    {
-      return false;
-    }
-    memcached_return rc= memcached_cas_by_key(&memc,
-                                              master_key.c_str(), 
-                                              master_key.length(),
-                                              key.c_str(), 
-                                              key.length(),
-                                              &value[0], 
-                                              value.size(),
-                                              0, 0, cas_arg);
-    return (rc == MEMCACHED_SUCCESS);
-  }
-
-  bool remove(const std::string &key)
-  {
-    if (key.empty())
-    {
-      return false;
-    }
-    memcached_return rc= memcached_delete(&memc, key.c_str(), key.length(), 0);
-    return (rc == MEMCACHED_SUCCESS);
-  }
-
-  bool removeByKey(const std::string &master_key, 
-                   const std::string &key)
-  {
-    if (master_key.empty() || key.empty())
-    {
-      return false;
-    }
-    memcached_return rc= memcached_delete_by_key(&memc, 
-                                                 master_key.c_str(), 
-                                                 master_key.length(),
-                                                 key.c_str(), 
-                                                 key.length(), 
-                                                 0);
-    return (rc == MEMCACHED_SUCCESS);
-  }
-
-  bool flush(time_t expiration)
-  {
-    memcached_return rc= memcached_flush(&memc, expiration);
-    return (rc == MEMCACHED_SUCCESS);
-  }
-
-  bool fetchExecute(memcached_execute_function *callback,
-                    void *context,
-                    unsigned int num_of_callbacks)
-  {
-    memcached_return rc= memcached_fetch_execute(&memc,
-                                                 callback,
-                                                 context,
-                                                 num_of_callbacks);
-    return (rc == MEMCACHED_SUCCESS);
-  }
-
-  /**
-   * Get the library version string.
-   * @return std::string containing a copy of the library version string.
-   */
-  const std::string libVersion() const
-  {
-    const char *ver= memcached_lib_version();
-    const std::string version(ver);
-    return version;
-  }
-
-private:
-
-  memcached_st memc;
-  memcached_result_st result;
-};
-
-#endif /* LIBMEMCACHEDPP_H */
diff --git a/libmemcached/memcached.hpp b/libmemcached/memcached.hpp
new file mode 100644
index 00000000..ecb474aa
--- /dev/null
+++ b/libmemcached/memcached.hpp
@@ -0,0 +1,537 @@
+/*
+ * Summary: C++ interface for memcached server
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Authors: Padraig O'Sullivan <osullivan.padraig@gmail.com>
+ *          Patrick Galbraith <patg@patg.net>
+ */
+
+/**
+ * @file memcached.hpp
+ * @brief Libmemcached C++ interface
+ */
+
+#ifndef LIBMEMCACHEDPP_H
+#define LIBMEMCACHEDPP_H
+
+#include <libmemcached/memcached.h>
+
+#include <string.h>
+
+#include <string>
+#include <vector>
+#include <map>
+
+namespace memcache
+{
+
+/**
+ * This is the core memcached library (if later, other objects
+ * are needed, they will be created from this class).
+ */
+class Memcache
+{
+public:
+
+  Memcache() 
+    : 
+      memc(),
+      result()
+  {
+    memcached_create(&memc);
+  }
+
+  Memcache(memcached_st *clone) 
+    : 
+      memc(),
+      result()
+  {
+    memcached_clone(&memc, clone);
+  }
+
+  Memcache(const Memcache &rhs)
+    :
+      memc(),
+      result()
+  {
+    memcached_clone(&memc, const_cast<memcached_st *>(&rhs.getImpl()));
+  }
+
+  ~Memcache()
+  {
+    memcached_free(&memc);
+  }
+
+  /**
+   * Get the internal memcached_st *
+   */
+  memcached_st &getImpl()
+  {
+    return memc;
+  }
+
+  /**
+   * Get the internal memcached_st *
+   */
+  const memcached_st &getImpl() const
+  {
+    return memc;
+  }
+
+  /**
+   * Return an error string for the given return structure.
+   *
+   * @param[in] rc a memcached_return structure
+   * @return error string corresponding to given return code in the library.
+   */
+  const std::string getError(memcached_return rc) const
+  {
+    /* first parameter to strerror is unused */
+    return memcached_strerror(NULL, rc);
+  }
+
+  bool fetch(std::string &key, 
+             std::vector<char> &ret_val,
+             uint32_t *flags,
+             memcached_return *rc)
+  {
+    char ret_key[MEMCACHED_MAX_KEY];
+    size_t value_length= 0;
+    size_t key_length= 0;
+    char *value= memcached_fetch(&memc, ret_key, &key_length,
+                                 &value_length, flags, rc);
+    if (value && ret_val.empty())
+    {
+      ret_val.reserve(value_length);
+      ret_val.assign(value, value + value_length);
+      key.assign(ret_key);
+      return true;
+    }
+    return false;
+  }
+
+  std::vector<char> &get(const std::string &key, 
+                         std::vector<char> &ret_val)
+  {
+    uint32_t flags= 0;
+    memcached_return rc;
+    size_t value_length= 0;
+
+    if (key.empty())
+    {
+      return ret_val;
+    }
+    char *value= memcached_get(&memc, key.c_str(), key.length(),
+                               &value_length, &flags, &rc);
+    if (value != NULL && ret_val.empty())
+    {
+      ret_val.reserve(value_length);
+      ret_val.assign(value, value + value_length);
+    }
+    return ret_val;
+  }
+
+  std::vector<char> &getByKey(const std::string &master_key, 
+                              const std::string &key, 
+                              std::vector<char> &ret_val)
+  {
+    uint32_t flags= 0;
+    memcached_return rc;
+    size_t value_length= 0;
+
+    if (master_key.empty() || key.empty())
+    {
+      return ret_val;
+    }
+    char *value= memcached_get_by_key(&memc, 
+                                      master_key.c_str(), master_key.length(), 
+                                      key.c_str(), key.length(),
+                                      &value_length, &flags, &rc);
+    if (value)
+    {
+      ret_val.reserve(value_length);
+      ret_val.assign(value, value + value_length);
+    }
+    return ret_val;
+  }
+
+  bool mget(std::vector<std::string> &keys)
+  {
+    std::vector<const char *> real_keys;
+    std::vector<size_t> key_len;
+    /*
+     * Construct an array which will contain the length
+     * of each of the strings in the input vector. Also, to
+     * interface with the memcached C API, we need to convert
+     * the vector of std::string's to a vector of char *.
+     */
+    real_keys.reserve(keys.size());
+    key_len.reserve(keys.size());
+
+    std::vector<std::string>::iterator it= keys.begin();
+
+    while (it != keys.end())
+    {
+      real_keys.push_back(const_cast<char *>((*it).c_str()));
+      key_len.push_back((*it).length());
+      ++it;
+    }
+
+    /*
+     * If the std::vector of keys is empty then we cannot 
+     * call memcached_mget as we will get undefined behavior.
+     */
+    if (! real_keys.empty())
+    {
+      memcached_return rc= memcached_mget(&memc, &real_keys[0], &key_len[0], 
+                                          real_keys.size());
+      return (rc == MEMCACHED_SUCCESS);
+    }
+
+    return false;
+  }
+
+  bool set(const std::string &key, 
+           const std::vector<char> &value,
+           time_t expiration,
+           uint32_t flags)
+  {
+    if (key.empty() || value.empty())
+    {
+      return false;
+    }
+    memcached_return rc= memcached_set(&memc, 
+                                       key.c_str(), key.length(),
+                                       &value[0], value.size(),
+                                       expiration, flags);
+    return (rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+  }
+
+  bool setAll(std::vector<std::string> &keys,
+              std::vector< std::vector<char> *> &values,
+              time_t expiration,
+              uint32_t flags)
+  {
+    if (keys.size() != values.size())
+    {
+      return false;
+    }
+    bool retval= true;
+    std::vector<std::string>::iterator key_it= keys.begin();
+    std::vector< std::vector<char> *>::iterator val_it= values.begin();
+    while (key_it != keys.end())
+    {
+      retval= set((*key_it), *(*val_it), expiration, flags);
+      if (retval == false)
+      {
+        return retval;
+      }
+      ++key_it;
+      ++val_it;
+    }
+    return retval;
+  }
+
+  bool setAll(std::map<const std::string, std::vector<char> > key_value_map,
+              time_t expiration,
+              uint32_t flags)
+  {
+    if (key_value_map.empty())
+    {
+      return false;
+    }
+    bool retval= true;
+    std::map<const std::string, std::vector<char> >::iterator it=
+      key_value_map.begin();
+    while (it != key_value_map.end())
+    {
+      retval= set(it->first, it->second, expiration, flags);
+      if (retval == false)
+      {
+        return false;
+      }
+      ++it;
+    }
+    return true;
+  }
+
+  bool setByKey(const std::string &master_key, 
+                const std::string &key, 
+                const std::vector<char> &value,
+                time_t expiration,
+                uint32_t flags)
+  {
+    if (master_key.empty() ||
+        key.empty() ||
+        value.empty())
+    {
+      return false;
+    }
+    memcached_return rc= memcached_set_by_key(&memc, master_key.c_str(), 
+                                              master_key.length(),
+                                              key.c_str(), key.length(),
+                                              &value[0], value.size(),
+                                              expiration,
+                                              flags);
+    return (rc == MEMCACHED_SUCCESS);
+  }
+
+  bool increment(const std::string &key, unsigned int offset, uint64_t *value)
+  {
+    if (key.empty())
+    {
+      return false;
+    }
+    memcached_return rc= memcached_increment(&memc, key.c_str(), key.length(),
+                                             offset, value);
+    return (rc == MEMCACHED_SUCCESS);
+  }
+
+  bool decrement(const std::string &key, unsigned int offset, uint64_t *value)
+  {
+    if (key.empty())
+    {
+      return false;
+    }
+    memcached_return rc= memcached_decrement(&memc, key.c_str(), 
+                                             key.length(),
+                                             offset, value);
+    return (rc == MEMCACHED_SUCCESS);
+  }
+
+
+  bool add(const std::string &key, const std::vector<char> &value)
+  {
+    if (key.empty() || value.empty())
+    {
+      return false;
+    }
+    memcached_return rc= memcached_add(&memc, key.c_str(), key.length(), 
+                                       &value[0], value.size(), 0, 0);
+    return (rc == MEMCACHED_SUCCESS);
+  }
+
+  bool addByKey(const std::string &master_key, 
+                const std::string &key, 
+                const std::vector<char> &value)
+  {
+    if (master_key.empty() ||
+        key.empty() || 
+        value.empty())
+    {
+      return false;
+    }
+    memcached_return rc= memcached_add_by_key(&memc, 
+                                              master_key.c_str(),
+                                              master_key.length(),
+                                              key.c_str(),
+                                              key.length(),
+                                              &value[0], 
+                                              value.size(),
+                                              0, 0);
+    return (rc == MEMCACHED_SUCCESS);
+  }
+
+  bool replace(const std::string &key, const std::vector<char> &value)
+  {
+    if (key.empty() ||
+        value.empty())
+    {
+      return false;
+    }
+    memcached_return rc= memcached_replace(&memc, key.c_str(), key.length(),
+                                           &value[0], value.size(),
+                                           0, 0);
+    return (rc == MEMCACHED_SUCCESS);
+  }
+
+  bool replaceByKey(const std::string &master_key, 
+                    const std::string &key, 
+                    const std::vector<char> &value)
+  {
+    if (master_key.empty() ||
+        key.empty() ||
+        value.empty())
+    {
+      return false;
+    }
+    memcached_return rc= memcached_replace_by_key(&memc, 
+                                                  master_key.c_str(), 
+                                                  master_key.length(),
+                                                  key.c_str(), 
+                                                  key.length(),
+                                                  &value[0], 
+                                                  value.size(), 
+                                                  0, 0);
+    return (rc == MEMCACHED_SUCCESS);
+  }
+
+  bool prepend(const std::string &key, const std::vector<char> &value)
+  {
+    if (key.empty() || value.empty())
+    {
+      return false;
+    }
+    memcached_return rc= memcached_prepend(&memc, key.c_str(), key.length(),
+                                           &value[0], value.size(), 0, 0);
+    return (rc == MEMCACHED_SUCCESS);
+  }
+
+  bool prependByKey(const std::string &master_key, 
+                    const std::string &key, 
+                    const std::vector<char> &value)
+  {
+    if (master_key.empty() ||
+        key.empty() ||
+        value.empty())
+    {
+      return false;
+    }
+    memcached_return rc= memcached_prepend_by_key(&memc, 
+                                                  master_key.c_str(), 
+                                                  master_key.length(),
+                                                  key.c_str(), 
+                                                  key.length(),
+                                                  &value[0], 
+                                                  value.size(),
+                                                  0,
+                                                  0);
+    return (rc == MEMCACHED_SUCCESS);
+  }
+
+  bool append(const std::string &key, const std::vector<char> &value)
+  {
+    if (key.empty() || value.empty())
+    {
+      return false;
+    }
+    memcached_return rc= memcached_append(&memc, 
+                                          key.c_str(), 
+                                          key.length(),
+                                          &value[0], 
+                                          value.size(), 
+                                          0, 0);
+    return (rc == MEMCACHED_SUCCESS);
+  }
+
+  bool appendByKey(const std::string &master_key, 
+                   const std::string &key, 
+                   const std::vector<char> &value)
+  {
+    if (master_key.empty() ||
+        key.empty() ||
+        value.empty())
+    {
+      return false;
+    }
+    memcached_return rc= memcached_append_by_key(&memc,
+                                                 master_key.c_str(), 
+                                                 master_key.length(),
+                                                 key.c_str(), 
+                                                 key.length(),
+                                                 &value[0], 
+                                                 value.size(), 
+                                                 0, 0);
+    return (rc == MEMCACHED_SUCCESS);
+  }
+
+  bool cas(const std::string &key, 
+           const std::vector<char> &value, 
+           uint64_t cas_arg)
+  {
+    if (key.empty() || value.empty())
+    {
+      return false;
+    }
+    memcached_return rc= memcached_cas(&memc, key.c_str(), key.length(),
+                                       &value[0], value.size(), 
+                                       0, 0, cas_arg);
+    return (rc == MEMCACHED_SUCCESS);
+  }
+
+  bool casByKey(const std::string &master_key, 
+                const std::string &key, 
+                const std::vector<char> &value, 
+                uint64_t cas_arg)
+  {
+    if (master_key.empty() ||
+        key.empty() ||
+        value.empty())
+    {
+      return false;
+    }
+    memcached_return rc= memcached_cas_by_key(&memc,
+                                              master_key.c_str(), 
+                                              master_key.length(),
+                                              key.c_str(), 
+                                              key.length(),
+                                              &value[0], 
+                                              value.size(),
+                                              0, 0, cas_arg);
+    return (rc == MEMCACHED_SUCCESS);
+  }
+
+  bool remove(const std::string &key)
+  {
+    if (key.empty())
+    {
+      return false;
+    }
+    memcached_return rc= memcached_delete(&memc, key.c_str(), key.length(), 0);
+    return (rc == MEMCACHED_SUCCESS);
+  }
+
+  bool removeByKey(const std::string &master_key, 
+                   const std::string &key)
+  {
+    if (master_key.empty() || key.empty())
+    {
+      return false;
+    }
+    memcached_return rc= memcached_delete_by_key(&memc, 
+                                                 master_key.c_str(), 
+                                                 master_key.length(),
+                                                 key.c_str(), 
+                                                 key.length(), 
+                                                 0);
+    return (rc == MEMCACHED_SUCCESS);
+  }
+
+  bool flush(time_t expiration)
+  {
+    memcached_return rc= memcached_flush(&memc, expiration);
+    return (rc == MEMCACHED_SUCCESS);
+  }
+
+  bool fetchExecute(memcached_execute_function *callback,
+                    void *context,
+                    unsigned int num_of_callbacks)
+  {
+    memcached_return rc= memcached_fetch_execute(&memc,
+                                                 callback,
+                                                 context,
+                                                 num_of_callbacks);
+    return (rc == MEMCACHED_SUCCESS);
+  }
+
+  /**
+   * Get the library version string.
+   * @return std::string containing a copy of the library version string.
+   */
+  const std::string libVersion() const
+  {
+    const char *ver= memcached_lib_version();
+    const std::string version(ver);
+    return version;
+  }
+
+private:
+
+  memcached_st memc;
+  memcached_result_st result;
+};
+
+}
+
+#endif /* LIBMEMCACHEDPP_H */
diff --git a/tests/plus.cpp b/tests/plus.cpp
index 28d72870..3431fd18 100644
--- a/tests/plus.cpp
+++ b/tests/plus.cpp
@@ -1,7 +1,7 @@
 /*
   C++ interface test
 */
-#include "libmemcached/memcached.hh"
+#include "libmemcached/memcached.hpp"
 
 #include <assert.h>
 #include <stdio.h>
@@ -19,6 +19,7 @@
 #include <string>
 
 using namespace std;
+using namespace memcache;
 
 extern "C" {
    test_return basic_test(memcached_st *memc);
@@ -36,23 +37,21 @@ extern "C" {
 static void populate_vector(vector<char> &vec, const string &str)
 {
   vec.reserve(str.length());
-  memcpy(&*vec.begin(), str.c_str(), str.length());
+  vec.assign(str.begin(), str.end());
 }
 
 static void copy_vec_to_string(vector<char> &vec, string &str)
 {
   str.clear();
-  char *tmp= static_cast<char *>(malloc(vec.size() * sizeof(char)));
-  if (!vec.empty())
+  if (! vec.empty())
   {
-    memcpy(tmp, &vec[0], vec.size());
-    str.assign(tmp);
+    str.assign(vec.begin(), vec.end());
   }
 }
 
 test_return basic_test(memcached_st *memc)
 {
-  Memcached foo(memc);
+  Memcache foo(memc);
   const string value_set("This is some data");
   std::vector<char> value;
   std::vector<char> test_value;
@@ -69,7 +68,7 @@ test_return basic_test(memcached_st *memc)
 
 test_return increment_test(memcached_st *memc)
 {
-  Memcached mcach(memc);
+  Memcache mcach(memc);
   bool rc;
   const string key("blah");
   const string inc_value("1");
@@ -93,8 +92,6 @@ test_return increment_test(memcached_st *memc)
   }
   copy_vec_to_string(ret_value, ret_string);
 
-  printf("string is: %s\n", ret_string.c_str());
-
   int_inc_value= uint64_t(atol(inc_value.c_str()));
   int_ret_value= uint64_t(atol(ret_string.c_str()));
   assert(int_ret_value == int_inc_value); 
@@ -116,7 +113,7 @@ test_return increment_test(memcached_st *memc)
 
 test_return basic_master_key_test(memcached_st *memc)
 {
-  Memcached foo(memc);
+  Memcache foo(memc);
   const string value_set("Data for server A");
   vector<char> value;
   vector<char> test_value;
@@ -153,13 +150,13 @@ memcached_return callback_counter(memcached_st *,
 
 test_return mget_result_function(memcached_st *memc)
 {
-  Memcached mc(memc);
+  Memcache mc(memc);
   bool rc;
   string key1("fudge");
   string key2("son");
   string key3("food");
   vector<string> keys;
-  vector< vector<char> > values;
+  vector< vector<char> *> values;
   vector<char> val1;
   vector<char> val2;
   vector<char> val3;
@@ -171,9 +168,9 @@ test_return mget_result_function(memcached_st *memc)
   keys.push_back(key2);
   keys.push_back(key3);
   values.reserve(3);
-  values.push_back(val1);
-  values.push_back(val2);
-  values.push_back(val3);
+  values.push_back(&val1);
+  values.push_back(&val2);
+  values.push_back(&val3);
   unsigned int counter;
   memcached_execute_function callbacks[1];
 
@@ -196,11 +193,11 @@ test_return mget_result_function(memcached_st *memc)
 
 test_return mget_test(memcached_st *memc)
 {
-  Memcached mc(memc);
+  Memcache mc(memc);
   bool rc;
   memcached_return mc_rc;
   vector<string> keys;
-  vector< vector<char> > values;
+  vector< vector<char> *> values;
   keys.reserve(3);
   keys.push_back("fudge");
   keys.push_back("son");
@@ -212,9 +209,9 @@ test_return mget_test(memcached_st *memc)
   populate_vector(val2, "son");
   populate_vector(val3, "food");
   values.reserve(3);
-  values.push_back(val1);
-  values.push_back(val2);
-  values.push_back(val3);
+  values.push_back(&val1);
+  values.push_back(&val2);
+  values.push_back(&val3);
   uint32_t flags;
 
   string return_key;