boourns-memcached 1.4.6

data/ext/extconf.rb

@@ -0,0 +1,87 @@
+require 'mkmf'
+require 'rbconfig'
+
+HERE = File.expand_path(File.dirname(__FILE__))
+BUNDLE_PATH = Dir.glob("libmemcached-*").first
+
+SOLARIS_32 = Config::CONFIG['target'] == "i386-pc-solaris2.10"
+BSD = Config::CONFIG['host_os'].downcase =~ /bsd/
+
+$CFLAGS = "#{Config::CONFIG['CFLAGS']} #{$CFLAGS}".gsub("$(cflags)", "").gsub("-fno-common", "").gsub("-Werror=declaration-after-statement", "")
+$CFLAGS << " -std=gnu99" if SOLARIS_32
+$CFLAGS << " -I/usr/local/include" if BSD
+$EXTRA_CONF = " --disable-64bit" if SOLARIS_32
+$LDFLAGS = "#{Config::CONFIG['LDFLAGS']} #{$LDFLAGS} -L#{Config::CONFIG['libdir']}".gsub("$(ldflags)", "").gsub("-fno-common", "")
+$CXXFLAGS = "#{Config::CONFIG['CXXFLAGS']} -std=gnu++98"
+$CC = "CC=#{Config::MAKEFILE_CONFIG["CC"].inspect}"
+
+# JRuby's default configure options can't build libmemcached properly
+LIBM_CFLAGS = defined?(JRUBY_VERSION) ? "-fPIC -g -O2" : $CFLAGS
+LIBM_LDFLAGS = defined?(JRUBY_VERSION) ? "-fPIC -lsasl2 -lm" : $LDFLAGS
+
+GMAKE_CMD = Config::CONFIG['host_os'].downcase =~ /bsd|solaris/ ? "gmake" : "make"
+TAR_CMD = SOLARIS_32 ? 'gtar' : 'tar'
+PATCH_CMD = SOLARIS_32 ? 'gpatch' : 'patch'
+
+if ENV['DEBUG']
+  puts "Setting debug flags."
+  $CFLAGS << " -O0 -ggdb -DHAVE_DEBUG"
+  $EXTRA_CONF = ""
+end
+
+def run(cmd, reason)
+  puts reason
+  puts cmd
+  raise "'#{cmd}' failed" unless system(cmd)
+end
+
+def check_libmemcached
+  return if ENV["EXTERNAL_LIB"]
+
+  $includes = " -I#{HERE}/include"
+  $defines = " -DLIBMEMCACHED_WITH_SASL_SUPPORT"
+  $libraries = " -L#{HERE}/lib"
+  $CFLAGS = "#{$includes} #{$libraries} #{$CFLAGS}"
+  $LDFLAGS = "-lsasl2 -lm #{$libraries} #{$LDFLAGS}"
+  $LIBPATH = ["#{HERE}/lib"]
+  $DEFLIBPATH = [] unless SOLARIS_32
+
+  Dir.chdir(HERE) do
+    Dir.chdir(BUNDLE_PATH) do
+      run("find . | xargs touch", "Touching all files so autoconf doesn't run.")
+      run("env CFLAGS='-fPIC #{LIBM_CFLAGS}' LDFLAGS='-fPIC #{LIBM_LDFLAGS}' ./configure --prefix=#{HERE} --without-memcached --disable-shared --disable-utils --disable-dependency-tracking #{$CC} #{$EXTRA_CONF} 2>&1", "Configuring libmemcached.")
+    end
+
+    Dir.chdir(BUNDLE_PATH) do
+      #Running the make command in another script invoked by another shell command solves the "cd ." issue on FreeBSD 6+
+      run("GMAKE_CMD='#{GMAKE_CMD}' CXXFLAGS='#{$CXXFLAGS} #{LIBM_CFLAGS}' SOURCE_DIR='#{BUNDLE_PATH}' HERE='#{HERE}' ruby ../extconf-make.rb", "Making libmemcached.")
+    end
+  end
+
+  # Absolutely prevent the linker from picking up any other libmemcached
+  Dir.chdir("#{HERE}/lib") do
+    system("cp -f libmemcached.a libmemcached_gem.a")
+    system("cp -f libmemcached.la libmemcached_gem.la")
+  end
+  $LIBS << " -lmemcached_gem -lsasl2"
+end
+
+check_libmemcached
+
+if ENV['SWIG']
+  puts "WARNING: Swig 2.0.2 not found. Other versions may not work." if (`swig -version`!~ /2.0.2/)
+  run("swig #{$defines} #{$includes} -ruby -autorename -o rlibmemcached_wrap.c.in rlibmemcached.i", "Running SWIG.")
+  swig_patches = {
+    "STR2CSTR" => "StringValuePtr",                                # Patching SWIG output for Ruby 1.9.
+    "\"swig_runtime_data\"" =>  "\"SwigRuntimeData\"",             # Patching SWIG output for Ruby 1.9.
+    "#ifndef RUBY_INIT_STACK" => "#ifdef __NEVER__",               # Patching SWIG output for JRuby.
+  }.map{|pair| "s/#{pair.join('/')}/"}.join(';')
+
+  # sed has different syntax for inplace switch in BSD and GNU version, so using intermediate file
+  run("sed '#{swig_patches}' rlibmemcached_wrap.c.in > rlibmemcached_wrap.c", "Apply patches to SWIG output")
+end
+
+$CFLAGS << " -Os"
+create_makefile 'rlibmemcached'
+run("mv Makefile Makefile.in", "Copy Makefile")
+run("sed 's/-I.opt.local.include//' Makefile.in > Makefile", "Remove MacPorts from the include path")

data/ext/include/libmemcached/memcached.h

@@ -0,0 +1,304 @@
+/*
+ * Summary: interface for memcached server
+ * Description: main include file for libmemcached
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Brian Aker
+ */
+
+#ifndef LIBMEMCACHED_MEMCACHED_H
+#define LIBMEMCACHED_MEMCACHED_H
+
+#include <stdlib.h>
+#include <inttypes.h>
+#if !defined(__cplusplus)
+# include <stdbool.h>
+#endif
+#include <sys/types.h>
+#include <netinet/in.h>
+
+#include <libmemcached/visibility.h>
+#include <libmemcached/memcached_configure.h>
+#include <libmemcached/memcached_constants.h>
+#include <libmemcached/memcached_types.h>
+#include <libmemcached/memcached_get.h>
+#include <libmemcached/memcached_touch.h>
+#include <libmemcached/memcached_server.h>
+#include <libmemcached/memcached_string.h>
+#include <libmemcached/memcached_result.h>
+#include <libmemcached/memcached_storage.h>
+#include <libmemcached/memcached_exist.h>
+#include <libmemcached/memcached_sasl.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define MEMCACHED_VERSION_STRING_LENGTH 24
+#define LIBMEMCACHED_VERSION_STRING "0.32"
+
+struct memcached_analysis_st {
+  uint32_t average_item_size;
+  uint32_t longest_uptime;
+  uint32_t least_free_server;
+  uint32_t most_consumed_server;
+  uint32_t oldest_server;
+  double pool_hit_ratio;
+  uint64_t most_used_bytes;
+  uint64_t least_remaining_bytes;
+};
+
+struct memcached_stat_st {
+  uint32_t connection_structures;
+  uint32_t curr_connections;
+  uint32_t curr_items;
+  uint32_t pid;
+  uint32_t pointer_size;
+  uint32_t rusage_system_microseconds;
+  uint32_t rusage_system_seconds;
+  uint32_t rusage_user_microseconds;
+  uint32_t rusage_user_seconds;
+  uint32_t threads;
+  uint32_t time;
+  uint32_t total_connections;
+  uint32_t total_items;
+  uint32_t uptime;
+  uint64_t bytes;
+  uint64_t bytes_read;
+  uint64_t bytes_written;
+  uint64_t cmd_get;
+  uint64_t cmd_set;
+  uint64_t evictions;
+  uint64_t get_hits;
+  uint64_t get_misses;
+  uint64_t limit_maxbytes;
+  char version[MEMCACHED_VERSION_STRING_LENGTH];
+};
+
+struct memcached_st {
+  uint8_t purging;
+  bool is_allocated;
+  uint8_t distribution;
+  uint8_t hash;
+  uint32_t continuum_points_counter;
+  memcached_server_st *hosts;
+  int32_t snd_timeout;
+  int32_t rcv_timeout;
+  uint32_t server_failure_limit;
+  uint32_t io_msg_watermark;
+  uint32_t io_bytes_watermark;
+  uint32_t io_key_prefetch;
+  uint32_t number_of_hosts;
+  uint32_t cursor_server;
+  int cached_errno;
+  uint32_t flags;
+  int32_t poll_timeout;
+  int32_t connect_timeout;
+  int32_t retry_timeout;
+  uint32_t continuum_count;
+  int send_size;
+  int recv_size;
+  void *user_data;
+  time_t next_distribution_rebuild;
+  size_t prefix_key_length;
+  memcached_hash hash_continuum;
+  memcached_result_st result;
+  memcached_continuum_item_st *continuum;
+  memcached_clone_func on_clone;
+  memcached_cleanup_func on_cleanup;
+  memcached_free_function call_free;
+  memcached_malloc_function call_malloc;
+  memcached_realloc_function call_realloc;
+  memcached_calloc_function call_calloc;
+  memcached_trigger_key get_key_failure;
+  memcached_trigger_delete_key delete_trigger;
+  char prefix_key[MEMCACHED_PREFIX_KEY_MAX_SIZE];
+  uint32_t number_of_live_hosts;
+  uint32_t *live_host_indices;
+  uint32_t live_host_indices_size;
+#ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
+  const sasl_callback_t *sasl_callbacks;
+#endif
+  int last_server_key;
+};
+
+LIBMEMCACHED_API
+memcached_return memcached_version(memcached_st *ptr);
+
+/* Public API */
+
+LIBMEMCACHED_API
+const char * memcached_lib_version(void);
+
+LIBMEMCACHED_API
+memcached_st *memcached_create(memcached_st *ptr);
+LIBMEMCACHED_API
+void memcached_free(memcached_st *ptr);
+LIBMEMCACHED_API
+memcached_st *memcached_clone(memcached_st *clone, memcached_st *ptr);
+
+LIBMEMCACHED_API
+memcached_return memcached_delete(memcached_st *ptr, const char *key, size_t key_length,
+                                  time_t expiration);
+LIBMEMCACHED_API
+memcached_return memcached_increment(memcached_st *ptr,
+                                     const char *key, size_t key_length,
+                                     uint32_t offset,
+                                     uint64_t *value);
+LIBMEMCACHED_API
+memcached_return memcached_decrement(memcached_st *ptr,
+                                     const char *key, size_t key_length,
+                                     uint32_t offset,
+                                     uint64_t *value);
+LIBMEMCACHED_API
+memcached_return memcached_increment_with_initial(memcached_st *ptr,
+                                                  const char *key,
+                                                  size_t key_length,
+                                                  uint64_t offset,
+                                                  uint64_t initial,
+                                                  time_t expiration,
+                                                  uint64_t *value);
+LIBMEMCACHED_API
+memcached_return memcached_decrement_with_initial(memcached_st *ptr,
+                                                  const char *key,
+                                                  size_t key_length,
+                                                  uint64_t offset,
+                                                  uint64_t initial,
+                                                  time_t expiration,
+                                                  uint64_t *value);
+LIBMEMCACHED_API
+void memcached_stat_free(memcached_st *, memcached_stat_st *);
+LIBMEMCACHED_API
+memcached_stat_st *memcached_stat(memcached_st *ptr, char *args, memcached_return *error);
+LIBMEMCACHED_API
+memcached_return memcached_stat_servername(memcached_stat_st *memc_stat, char *args,
+                                           char *hostname, unsigned int port);
+LIBMEMCACHED_API
+memcached_return memcached_flush(memcached_st *ptr, time_t expiration);
+LIBMEMCACHED_API
+memcached_return memcached_verbosity(memcached_st *ptr, unsigned int verbosity);
+LIBMEMCACHED_API
+void memcached_quit(memcached_st *ptr);
+LIBMEMCACHED_API
+const char *memcached_strerror(memcached_st *ptr, memcached_return rc);
+LIBMEMCACHED_API
+memcached_return memcached_behavior_set(memcached_st *ptr, memcached_behavior flag, uint64_t data);
+LIBMEMCACHED_API
+uint64_t memcached_behavior_get(memcached_st *ptr, memcached_behavior flag);
+
+/* The two public hash bits */
+LIBMEMCACHED_API
+uint32_t memcached_generate_hash_value(const char *key, size_t key_length, memcached_hash hash_algorithm);
+LIBMEMCACHED_API
+uint32_t memcached_generate_hash(memcached_st *ptr, const char *key, size_t key_length);
+
+LIBMEMCACHED_API
+memcached_return memcached_flush_buffers(memcached_st *mem);
+
+/* Server Public functions */
+
+LIBMEMCACHED_API
+memcached_return memcached_server_add_udp(memcached_st *ptr,
+                                          const char *hostname,
+                                          unsigned int port);
+LIBMEMCACHED_API
+memcached_return memcached_server_add_unix_socket(memcached_st *ptr,
+                                                  const char *filename);
+LIBMEMCACHED_API
+memcached_return memcached_server_add(memcached_st *ptr, const char *hostname,
+                                      unsigned int port);
+
+LIBMEMCACHED_API
+memcached_return memcached_server_add_udp_with_weight(memcached_st *ptr,
+                                                      const char *hostname,
+                                                      unsigned int port,
+                                                      uint32_t weight);
+LIBMEMCACHED_API
+memcached_return memcached_server_add_unix_socket_with_weight(memcached_st *ptr,
+                                                              const char *filename,
+                                                              uint32_t weight);
+LIBMEMCACHED_API
+memcached_return memcached_server_add_with_weight(memcached_st *ptr, const char *hostname,
+                                                  unsigned int port,
+                                                  uint32_t weight);
+LIBMEMCACHED_API
+void memcached_server_list_free(memcached_server_st *ptr);
+LIBMEMCACHED_API
+memcached_return memcached_server_push(memcached_st *ptr, memcached_server_st *list);
+
+LIBMEMCACHED_API
+memcached_server_st *memcached_server_list_append(memcached_server_st *ptr,
+                                                  const char *hostname,
+                                                  unsigned int port,
+                                                  memcached_return *error);
+LIBMEMCACHED_API
+memcached_server_st *memcached_server_list_append_with_weight(memcached_server_st *ptr,
+                                                              const char *hostname,
+                                                              unsigned int port,
+                                                              uint32_t weight,
+                                                              memcached_return *error);
+LIBMEMCACHED_API
+unsigned int memcached_server_list_count(memcached_server_st *ptr);
+LIBMEMCACHED_API
+memcached_server_st *memcached_servers_parse(const char *server_strings);
+
+LIBMEMCACHED_API
+char *memcached_stat_get_value(memcached_st *ptr, memcached_stat_st *memc_stat,
+                               const char *key, memcached_return *error);
+LIBMEMCACHED_API
+char ** memcached_stat_get_keys(memcached_st *ptr, memcached_stat_st *memc_stat,
+                                memcached_return *error);
+
+LIBMEMCACHED_API
+memcached_return memcached_delete_by_key(memcached_st *ptr,
+                                         const char *master_key, size_t master_key_length,
+                                         const char *key, size_t key_length,
+                                         time_t expiration);
+
+LIBMEMCACHED_API
+memcached_return memcached_fetch_execute(memcached_st *ptr,
+                                             memcached_execute_function *callback,
+                                             void *context,
+                                             unsigned int number_of_callbacks);
+
+LIBMEMCACHED_API
+memcached_return memcached_callback_set(memcached_st *ptr,
+                                        memcached_callback flag,
+                                        void *data);
+LIBMEMCACHED_API
+void *memcached_callback_get(memcached_st *ptr,
+                             memcached_callback flag,
+                             memcached_return *error);
+
+LIBMEMCACHED_API
+memcached_return memcached_dump(memcached_st *ptr, memcached_dump_func *function, void *context, uint32_t number_of_callbacks);
+
+
+LIBMEMCACHED_API
+memcached_return memcached_set_memory_allocators(memcached_st *ptr,
+                                                 memcached_malloc_function mem_malloc,
+                                                 memcached_free_function mem_free,
+                                                 memcached_realloc_function mem_realloc,
+                                                 memcached_calloc_function mem_calloc);
+
+LIBMEMCACHED_API
+void memcached_get_memory_allocators(memcached_st *ptr,
+                                     memcached_malloc_function *mem_malloc,
+                                     memcached_free_function *mem_free,
+                                     memcached_realloc_function *mem_realloc,
+                                     memcached_calloc_function *mem_calloc);
+
+LIBMEMCACHED_API
+void *memcached_get_user_data(memcached_st *ptr);
+LIBMEMCACHED_API
+void *memcached_set_user_data(memcached_st *ptr, void *data);
+
+LIBMEMCACHED_API
+memcached_return run_distribution(memcached_st *ptr);
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* LIBMEMCACHED_MEMCACHED_H */

data/ext/include/libmemcached/memcached.hpp

@@ -0,0 +1,799 @@
+/*
+ * 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);
+  }
+
+  /**
+   * Fetches an individual value from the server. mget() must always
+   * be called before using this method.
+   *
+   * @param[in] key key of object to fetch
+   * @param[out] ret_val store returned object in this vector
+   * @return a memcached return structure
+   */
+  memcached_return fetch(std::string &key, 
+                         std::vector<char> &ret_val)
+  {
+    char ret_key[MEMCACHED_MAX_KEY];
+    size_t value_length= 0;
+    size_t key_length= 0;
+    memcached_return rc;
+    uint32_t flags= 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 rc;
+  }
+
+  /**
+   * Fetches an individual value from the server.
+   *
+   * @param[in] key key of object whose value to get
+   * @param[out] ret_val object that is retrieved is stored in
+   *                     this vector
+   * @return true on success; false otherwise
+   */
+  bool 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 false;
+    }
+    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 true;
+    }
+    return false;
+  }
+
+  /**
+   * Fetches an individual from a server which is specified by
+   * the master_key parameter that is used for determining which
+   * server an object was stored in if key partitioning was 
+   * used for storage.
+   *
+   * @param[in] master_key key that specifies server object is stored on
+   * @param[in] key key of object whose value to get
+   * @param[out] ret_val object that is retrieved is stored in
+   *                     this vector
+   * @return true on success; false otherwise
+   */
+  bool 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 false;
+    }
+    char *value= memcached_get_by_key(&memc, 
+                                      master_key.c_str(), master_key.length(), 
+                                      key.c_str(), key.length(),
+                                      GET_LEN_ARG_UNSPECIFIED,
+                                      &value_length, &flags, &rc);
+    if (value)
+    {
+      ret_val.reserve(value_length);
+      ret_val.assign(value, value + value_length);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Selects multiple keys at once. This method always
+   * works asynchronously.
+   *
+   * @param[in] keys vector of keys to select
+   * @return true if all keys are found
+   */
+  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;
+  }
+
+  /**
+   * Writes an object to the server. If the object already exists, it will
+   * overwrite the existing object. This method always returns true
+   * when using non-blocking mode unless a network error occurs.
+   *
+   * @param[in] key key of object to write to server
+   * @param[in] value value of object to write to server
+   * @param[in] expiration time to keep the object stored in the server for
+   * @param[in] flags flags to store with the object
+   * @return true on succcess; false otherwise
+   */
+  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);
+  }
+
+  /**
+   * Writes an object to a server specified by the master_key parameter.
+   * If the object already exists, it will overwrite the existing object.
+   *
+   * @param[in] master_key key that specifies server to write to
+   * @param[in] key key of object to write to server
+   * @param[in] value value of object to write to server
+   * @param[in] expiration time to keep the object stored in the server for
+   * @param[in] flags flags to store with the object
+   * @return true on succcess; false otherwise
+   */
+  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);
+  }
+
+  /**
+   * Writes a list of objects to the server. Objects are specified by
+   * 2 vectors - 1 vector of keys and 1 vector of values.
+   *
+   * @param[in] keys vector of keys of objects to write to server
+   * @param[in] values vector of values of objects to write to server
+   * @param[in] expiration time to keep the objects stored in server for
+   * @param[in] flags flags to store with the objects
+   * @return true on success; false otherwise
+   */
+  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;
+  }
+
+  /**
+   * Writes a list of objects to the server. Objects are specified by
+   * a map of keys to values.
+   *
+   * @param[in] key_value_map map of keys and values to store in server
+   * @param[in] expiration time to keep the objects stored in server for
+   * @param[in] flags flags to store with the objects
+   * @return true on success; false otherwise
+   */
+  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;
+  }
+
+  /**
+   * Increment the value of the object associated with the specified
+   * key by the offset given. The resulting value is saved in the value
+   * parameter.
+   *
+   * @param[in] key key of object in server whose value to increment
+   * @param[in] offset amount to increment object's value by
+   * @param[out] value store the result of the increment here
+   * @return true on success; false otherwise
+   */
+  bool increment(const std::string &key, uint32_t 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);
+  }
+
+  /**
+   * Decrement the value of the object associated with the specified
+   * key by the offset given. The resulting value is saved in the value
+   * parameter.
+   *
+   * @param[in] key key of object in server whose value to decrement
+   * @param[in] offset amount to increment object's value by
+   * @param[out] value store the result of the decrement here
+   * @return true on success; false otherwise
+   */
+  bool decrement(const std::string &key, uint32_t 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);
+  }
+
+
+  /**
+   * Add an object with the specified key and value to the server. This
+   * function returns false if the object already exists on the server.
+   *
+   * @param[in] key key of object to add
+   * @param[in] value of object to add
+   * @return true on success; false otherwise
+   */
+  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);
+  }
+
+  /**
+   * Add an object with the specified key and value to the server. This
+   * function returns false if the object already exists on the server. The
+   * server to add the object to is specified by the master_key parameter.
+   *
+   * @param[in[ master_key key of server to add object to
+   * @param[in] key key of object to add
+   * @param[in] value of object to add
+   * @return true on success; false otherwise
+   */
+  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);
+  }
+
+  /**
+   * Replaces an object on the server. This method only succeeds
+   * if the object is already present on the server.
+   *
+   * @param[in] key key of object to replace
+   * @param[in[ value value to replace object with
+   * @return true on success; false otherwise
+   */
+  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);
+  }
+
+  /**
+   * Replaces an object on the server. This method only succeeds
+   * if the object is already present on the server. The server
+   * to replace the object on is specified by the master_key param.
+   *
+   * @param[in] master_key key of server to replace object on
+   * @param[in] key key of object to replace
+   * @param[in[ value value to replace object with
+   * @return true on success; false otherwise
+   */
+  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);
+  }
+
+  /**
+   * Places a segment of data before the last piece of data stored.
+   *
+   * @param[in] key key of object whose value we will prepend data to
+   * @param[in] value data to prepend to object's value
+   * @return true on success; false otherwise
+   */
+  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);
+  }
+
+  /**
+   * Places a segment of data before the last piece of data stored. The
+   * server on which the object where we will be prepending data is stored
+   * on is specified by the master_key parameter.
+   *
+   * @param[in] master_key key of server where object is stored
+   * @param[in] key key of object whose value we will prepend data to
+   * @param[in] value data to prepend to object's value
+   * @return true on success; false otherwise
+   */
+  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);
+  }
+
+  /**
+   * Places a segment of data at the end of the last piece of data stored.
+   *
+   * @param[in] key key of object whose value we will append data to
+   * @param[in] value data to append to object's value
+   * @return true on success; false otherwise
+   */
+  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);
+  }
+
+  /**
+   * Places a segment of data at the end of the last piece of data stored. The
+   * server on which the object where we will be appending data is stored
+   * on is specified by the master_key parameter.
+   *
+   * @param[in] master_key key of server where object is stored
+   * @param[in] key key of object whose value we will append data to
+   * @param[in] value data to append to object's value
+   * @return true on success; false otherwise
+   */
+  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);
+  }
+
+  /**
+   * Overwrite data in the server as long as the cas_arg value
+   * is still the same in the server.
+   *
+   * @param[in] key key of object in server
+   * @param[in] value value to store for object in server
+   * @param[in] cas_arg "cas" value
+   */
+  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);
+  }
+
+  /**
+   * Overwrite data in the server as long as the cas_arg value
+   * is still the same in the server. The server to use is
+   * specified by the master_key parameter.
+   *
+   * @param[in] master_key specifies server to operate on
+   * @param[in] key key of object in server
+   * @param[in] value value to store for object in server
+   * @param[in] cas_arg "cas" value
+   */
+  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);
+  }
+
+  /**
+   * Delete an object from the server specified by the key given.
+   *
+   * @param[in] key key of object to delete
+   * @return true on success; false otherwise
+   */
+  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);
+  }
+
+  /**
+   * Delete an object from the server specified by the key given.
+   *
+   * @param[in] key key of object to delete
+   * @param[in] expiration time to delete the object after
+   * @return true on success; false otherwise
+   */
+  bool remove(const std::string &key,
+              time_t expiration)
+  {
+    if (key.empty())
+    {
+      return false;
+    }
+    memcached_return rc= memcached_delete(&memc, 
+                                          key.c_str(), 
+                                          key.length(), 
+                                          expiration);
+    return (rc == MEMCACHED_SUCCESS);
+  }
+
+  /**
+   * Delete an object from the server specified by the key given. 
+   *
+   * @param[in] master_key specifies server to remove object from
+   * @param[in] key key of object to delete
+   * @return true on success; false otherwise
+   */
+  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);
+  }
+
+  /**
+   * Delete an object from the server specified by the key given. 
+   *
+   * @param[in] master_key specifies server to remove object from
+   * @param[in] key key of object to delete
+   * @param[in] expiration time to delete the object after
+   * @return true on success; false otherwise
+   */
+  bool removeByKey(const std::string &master_key, 
+                   const std::string &key,
+                   time_t expiration)
+  {
+    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(), 
+                                                 expiration);
+    return (rc == MEMCACHED_SUCCESS);
+  }
+
+  /**
+   * Wipe the contents of memcached servers.
+   *
+   * @param[in] expiration time to wait until wiping contents of
+   *                       memcached servers
+   * @return true on success; false otherwise
+   */
+  bool flush(time_t expiration)
+  {
+    memcached_return rc= memcached_flush(&memc, expiration);
+    return (rc == MEMCACHED_SUCCESS);
+  }
+
+  /**
+   * Callback function for result sets. It passes the result
+   * sets to the list of functions provided.
+   *
+   * @param[in] callback list of callback functions
+   * @param[in] context pointer to memory reference that is
+   *                    supplied to the calling function
+   * @param[in] num_of_callbacks number of callback functions
+   * @return true on success; false otherwise
+   */
+  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 */