memcached 0.6 → 0.7

data/BENCHMARKS

@@ -0,0 +1,101 @@
+
+Here are some benchmarks for various architectures and operating systems. 
+
+You can easily run your own benchmarks, as long as you have memcached itself on your system:
+  $ ruby -e 'system("ruby #{File.dirname(`gem which memcached`.split("\n").
+    last)}/../test/profile/benchmark.rb")'
+
+== x86-32 OS X
+
+These benchmarks were run on 32-bit Intel OS X 10.4:
+
+                                       user     system      total        real
+  set:plain:noblock:memcached      0.140000   0.010000   0.150000 (  0.511496)
+  set:plain:memcached              0.300000   0.330000   0.630000 (  1.885052)
+  set:plain:memcache-client       47.900000   1.320000  49.220000 ( 65.757080)
+  set:ruby:noblock:memcached       0.240000   0.010000   0.250000 (  0.721554)
+  set:ruby:memcached               0.400000   0.300000   0.700000 (  2.206571)
+  set:ruby:caffeine                6.150000   0.910000   7.060000 ( 11.954644)
+  set:ruby:memcache-client        47.450000   1.260000  48.710000 ( 62.016943)
+  get:plain:memcached              0.360000   0.310000   0.670000 (  2.232519)
+  get:plain:memcache-client       47.010000   1.000000  48.010000 ( 54.759212)
+  get:ruby:memcached               0.380000   0.320000   0.700000 (  1.681682)
+  get:ruby:caffeine                5.780000   0.920000   6.700000 (  9.658255)
+  get:ruby:memcache-client        47.820000   1.250000  49.070000 ( 67.857959)
+  missing:ruby:memcached           0.760000   0.360000   1.120000 (  2.500735)
+  missing:ruby:caffeine            5.510000   0.900000   6.410000 (  9.652409)
+  missing:ruby:memcache-client    47.100000   1.180000  48.280000 ( 63.901434)
+  mixed:ruby:noblock:memcached     0.810000   0.690000   1.500000 (  4.270386)
+  mixed:ruby:memcached             0.820000   0.660000   1.480000 (  4.272916)
+  mixed:ruby:caffeine             10.590000   1.850000  12.440000 ( 20.338369)
+  mixed:ruby:memcache-client      95.730000   2.400000  98.130000 (121.600738)
+  hash:fnv1_32:memcached           1.310000   1.330000   2.640000 (  8.634078)
+  hash:fnv1_64:memcached           1.390000   1.340000   2.730000 (  9.794876)
+  hash:md5:memcached               1.460000   1.300000   2.760000 (  9.080550)
+  hash:hsieh:memcached             1.310000   1.350000   2.660000 (  7.182591)
+  hash:ketama:memcached            1.470000   1.260000   2.730000 (  7.366949)
+  hash:fnv1a_32:memcached          1.290000   1.350000   2.640000 (  7.134969)
+  hash:default:memcached           1.360000   1.350000   2.710000 (  8.464221)
+  hash:fnv1a_64:memcached          1.350000   1.290000   2.640000 ( 10.121386)
+  hash:crc:memcached               1.370000   1.210000   2.580000 (  9.665065)
+
+
+== x86-64 Linux
+  
+These benchmarks were run on AMD64 RHEL4:
+
+                                       user     system      total        real
+  set:plain:noblock:memcached      0.120000   0.010000   0.130000 (  3.700668)
+  set:plain:memcached              0.200000   0.190000   0.390000 (  0.787187)
+  set:plain:memcache-client       13.860000   0.210000  14.070000 ( 14.562234)
+  set:ruby:noblock:memcached       0.190000   0.010000   0.200000 (  5.347384)
+  set:ruby:memcached               0.290000   0.150000   0.440000 (  0.884206)
+  set:ruby:memcache-client        13.980000   0.200000  14.180000 ( 14.752663)
+  get:plain:memcached              0.270000   0.170000   0.440000 (  0.745219)
+  get:plain:memcache-client       14.070000   0.210000  14.280000 ( 14.794583)
+  get:ruby:memcached               0.370000   0.180000   0.550000 (  0.910926)
+  get:ruby:memcache-client        14.120000   0.220000  14.340000 ( 14.921784)
+  missing:ruby:memcached           0.550000   0.180000   0.730000 (  1.111790)
+  missing:ruby:memcache-client    13.600000   0.220000  13.820000 ( 14.427924)
+  mixed:ruby:noblock:memcached     0.560000   0.300000   0.860000 (  1.496428)
+  mixed:ruby:memcached             0.620000   0.370000   0.990000 (  1.654926)
+  mixed:ruby:memcache-client      27.580000   0.410000  27.990000 ( 28.854146)
+  hash:fnv1a_64:memcached          0.980000   0.740000   1.720000 (  3.162248)
+  hash:fnv1_32:memcached           0.990000   0.710000   1.700000 (  3.008045)
+  hash:fnv1_64:memcached           0.990000   0.710000   1.700000 (  3.018584)
+  hash:default:memcached           1.060000   0.680000   1.740000 (  3.094764)
+  hash:crc:memcached               0.980000   0.640000   1.620000 (  3.219268)
+  hash:hsieh:memcached             0.950000   0.770000   1.720000 (  3.328382)
+  hash:ketama:memcached            1.000000   0.770000   1.770000 (  3.120591)
+  hash:md5:memcached               0.990000   0.750000   1.740000 (  3.076737)
+  hash:fnv1a_32:memcached          0.950000   0.750000   1.700000 (  2.973986)
+  
+== x86-64 Linux/Xen
+
+These benchmarks were run on AMD64 Ubuntu 6.0.6 as a Xen guest:
+  
+                                       user     system      total        real
+  set:plain:noblock:memcached      0.090000   0.100000   0.190000 (  0.767657)
+  set:plain:memcached              0.120000   0.200000   0.320000 (  1.480487)
+  set:plain:memcache-client       18.620000  11.380000  30.000000 ( 32.116703)
+  set:ruby:noblock:memcached       0.220000   0.050000   0.270000 (  0.296509)
+  set:ruby:memcached               0.150000   0.210000   0.360000 (  1.345469)
+  set:ruby:memcache-client        19.310000  11.750000  31.060000 ( 32.858902)
+  get:plain:memcached              0.120000   0.130000   0.250000 (  1.291883)
+  get:plain:memcache-client       19.580000  11.930000  31.510000 ( 32.982464)
+  get:ruby:memcached               0.120000   0.160000   0.280000 (  1.404061)
+  get:ruby:memcache-client        19.520000  11.740000  31.260000 ( 33.537986)
+  missing:ruby:memcached           0.440000   0.240000   0.680000 (  1.527592)
+  missing:ruby:memcache-client    19.030000  11.760000  30.790000 ( 31.800959)
+  mixed:ruby:noblock:memcached     0.100000   0.080000   0.180000 (100.035915)
+  mixed:ruby:memcached             0.380000   0.380000   0.760000 (  2.728911)
+  mixed:ruby:memcache-client      38.890000  23.740000  62.630000 ( 66.185559)
+  hash:hsieh:memcached             0.440000   0.680000   1.120000 (  5.119760)
+  hash:crc:memcached               0.410000   0.810000   1.220000 (  5.378614)
+  hash:md5:memcached               0.430000   0.710000   1.140000 (  5.410604)
+  hash:ketama:memcached            0.770000   0.850000   1.620000 (  5.379337)
+  hash:fnv1a_32:memcached          0.300000   0.650000   0.950000 (  5.110063)
+  hash:default:memcached           0.220000   0.530000   0.750000 (  5.183058)
+  hash:fnv1a_64:memcached          0.300000   0.550000   0.850000 (  5.152530)
+  hash:fnv1_32:memcached           0.360000   0.770000   1.130000 (  5.150417)
+  hash:fnv1_64:memcached           0.510000   0.650000   1.160000 (  5.038078)

data/CHANGELOG

@@ -1,4 +1,6 @@
 
+v0.7. Rails compatibility wrapper; real multiget; rescue UnknownReadFailure in Interlock::Rails#get.
+
 v0.6. Better documentation; benchmark suite; improve buffered IO API; remove namespace accessor in favor of generic options hash; patch up extconf.rb to handle unusual library situations; increase test coverage.
 
 v0.5. First release.

data/COMPATIBILITY

@@ -0,0 +1,9 @@
+
+== Compatibility chart
+
+This chart shows which versions of the Ruby library are compatible with which versions of libmemcached.
+
+<b>Library version</b>:: <b>libmemcached version</b>
+0.7:: 0.15
+0.6:: 0.13
+0.5:: 0.13

data/Manifest

@@ -1,21 +1,25 @@
+BENCHMARKS
 CHANGELOG
+COMPATIBILITY
 ext/extconf.rb
-ext/libmemcached.i
-ext/libmemcached_wrap.c
+ext/rlibmemcached.i
+ext/rlibmemcached_wrap.c
 lib/memcached/behaviors.rb
 lib/memcached/exceptions.rb
 lib/memcached/integer.rb
 lib/memcached/memcached.rb
+lib/memcached/rails.rb
 lib/memcached.rb
 LICENSE
 Manifest
 README
-test/benchmark/benchmark.rb
-test/benchmark/benchmark_set_get.rb
-test/benchmark/profile.rb
+test/profile/benchmark.rb
+test/profile/profile.rb
+test/profile/valgrind.rb
 test/setup.rb
 test/teardown.rb
 test/test_helper.rb
 test/unit/binding_test.rb
 test/unit/memcached_test.rb
+test/unit/rails_test.rb
 TODO

data/README

@@ -9,7 +9,7 @@ Copyright 2008 Cloudburst, LLC. Licensed under the AFL 3. See the included LICEN
 
 The public certificate for this gem is here[http://rubyforge.org/frs/download.php/25331/evan_weaver-original-public_cert.pem]. 
 
-If you like this software, please {make a donation}[http://blog.evanweaver.com/donate/], or {recommend Evan}[http://www.workingwithrails.com/person/7739-evan-weaver] at Working with Rails.
+If you use this software, please {make a donation}[http://blog.evanweaver.com/donate/], or {recommend Evan}[http://www.workingwithrails.com/person/7739-evan-weaver] at Working with Rails.
 
 == Features
 
@@ -18,13 +18,13 @@ If you like this software, please {make a donation}[http://blog.evanweaver.com/d
 * multiple hashing modes, including consistent hashing
 * ludicrous speed, including optional non-blocking IO
 
-The <b>memcached</b> library wraps the pure-C libmemcached client via SWIG. Both libraries are very new; use caution.
+The <b>memcached</b> library wraps the pure-C libmemcached client via SWIG.
 
 == Installation
 
-You need {libmemcached 0.13}[http://tangent.org/552/libmemcached.html]. Other versions of libmemcached are not supported. You also need {memcached itself}[http://www.danga.com/memcached/] if you want to test against a local server.
+You need {libmemcached 0.15}[http://tangent.org/552/libmemcached.html]. Other versions of libmemcached are not supported. You also need {memcached itself}[http://www.danga.com/memcached/] if you want to test against a local server.
 
-Download and extract the {libmemcached tarball}[http://download.tangent.org/libmemcached-0.13.tar.gz]. Then for Linux, run:
+Download and extract the {libmemcached tarball}[http://download.tangent.org/libmemcached-0.15.tar.gz]. Then for Linux, run:
   ./configure
   make && sudo make install
   
@@ -83,7 +83,11 @@ Note that the API is not the same as that of <b>Ruby-MemCache</b> or <b>memcache
   $cache.delete 'test'
   $cache.get 'test' #=> raises Memcached::NotFound
 
-A compatibility wrapper for legacy applications is in progress.
+== Legacy applications
+
+There is a compatibility wrapper for legacy applications called Memcached::Rails. 
+
+The easiest way to use it in your app is by installing Interlock[http://blog.evanweaver.com/files/doc/fauna/interlock] and setting <tt>client: memcached</tt> in <tt>config/memcached.yml</tt>. This gives you memcached fragments by default. You do not have to use the other Interlock features unless you want to.
   
 == Threading
 
@@ -95,33 +99,17 @@ A compatibility wrapper for legacy applications is in progress.
     cache.set 'example', 1
     cache.get 'example'
     # ...
+    cache.destroy
   end  
 
   # Join the thread so that exceptions don't get lost
   thread.join
+  
+Make sure to call Memcached#destroy before your thread exits or you will leak memory.
 
 == Benchmarks
 
-<b>memcached</b> is much, much faster than <b>memcache-client</b>:
-
-                                       user     system      total        real
-  set:ruby:noblock:memcached       0.050000   0.000000   0.050000 (  0.054205)
-  set:ruby:memcached               0.130000   0.160000   0.290000 (  0.338529)
-  set:ruby:memcache-client         3.690000   0.130000   3.820000 (  4.030806)
-  ...
-  get:ruby:memcached               0.110000   0.020000   0.130000 (  0.316446)
-  get:ruby:memcache-client         3.730000   0.120000   3.850000 (  4.040446)
-  ...
-  missing:ruby:memcached           0.160000   0.090000   0.250000 (  0.401891)
-  missing:ruby:memcache-client     3.650000   0.090000   3.740000 (  3.880192)
-  ...
-  mixed:ruby:noblock:memcached     0.190000   0.230000   0.420000 (  0.667130)
-  mixed:ruby:memcached             0.250000   0.250000   0.500000 (  0.663093)
-  mixed:ruby:memcache-client       7.410000   0.210000   7.620000 (  7.942145)
-
-These benchmarks were run on x86-64 Linux. You can easily run your own benchmarks, as long as you have memcached itself on your system:
-  $ ruby -e 'system("ruby #{File.dirname(`gem which memcached`.split("\n").
-    last)}/../test/benchmark/benchmark.rb")'
+<b>memcached</b> is up to 150x faster than <b>memcache-client</b>, and up to 15x faster than <b>caffeine</b>. See BENCHMARKS[link:files/BENCHMARKS.html] for details.
 
 == Reporting problems
 

data/TODO

@@ -1,11 +1,4 @@
 
-Can happen any time:
+* Verify libmemcached version
 
-* real multiget
-* look for memory leaks
-
-Waiting on libmemcached 0.14:
-
-* verify version
 * CAS support
-* passing missing increment/decrement tests

data/ext/extconf.rb

@@ -3,15 +3,19 @@ require 'mkmf'
 
 if ENV['SWIG']
   puts "running SWIG"
-  $stdout.write `swig -I/opt/local/include -ruby -autorename libmemcached.i`
+  $stdout.write `swig -I/opt/local/include -ruby -autorename rlibmemcached.i`
 end
 
+$CFLAGS.gsub! /-O\d/, ''
+
 if ENV['DEBUG']
   puts "setting debug flags"
-  $CFLAGS << " -ggdb -DHAVE_DEBUG" 
+  $CFLAGS << " -O0 -ggdb -DHAVE_DEBUG" 
+else
+  $CFLAGS << " -O3"
 end
 
-dir_config 'libmemcached'
+dir_config 'rlibmemcached'
 
 # XXX There's probably a better way to do this
 unless find_library 'memcached', 'memcached_server_add', *ENV['LD_LIBRARY_PATH'].to_s.split(":")
@@ -21,4 +25,4 @@ unless find_header 'libmemcached/memcached.h', *ENV['INCLUDE_PATH'].to_s.split("
   raise "header file 'libmemcached/memcached.h' not  found"
 end
 
-create_makefile 'libmemcached'
+create_makefile 'rlibmemcached'

data/ext/rlibmemcached.i

@@ -0,0 +1,156 @@
+%module rlibmemcached
+%{
+#include <libmemcached/memcached.h>
+%}
+
+%warnfilter(SWIGWARN_RUBY_WRONG_NAME) memcached_st;
+%warnfilter(SWIGWARN_RUBY_WRONG_NAME) memcached_server_st;
+%warnfilter(SWIGWARN_RUBY_WRONG_NAME) memcached_stat_st;
+%warnfilter(SWIGWARN_RUBY_WRONG_NAME) memcached_string_st;
+%warnfilter(SWIGWARN_RUBY_WRONG_NAME) memcached_result_st;
+
+%include "typemaps.i"
+
+//// Input maps
+%apply unsigned short { uint8_t };
+%apply unsigned int { uint16_t };
+%apply unsigned long { uint32_t flags, uint32_t offset };
+
+// For behavior's weird set interface
+%typemap(in) (void *data) {
+  int value = FIX2INT($input);
+  if (value == 0 || value == 1) {
+    $1 = (void *) value;
+  } else {
+    // Only pass by reference for :distribution and :hash 
+    value = value - 2; 
+    $1 = &value;
+  }
+};
+
+// Array of strings map for multiget
+%typemap(in) (char **keys, size_t *key_length, unsigned int number_of_keys) {
+  int i;
+  Check_Type($input, T_ARRAY);
+  $3 = (unsigned int) RARRAY_LEN($input);
+  $2 = (size_t *) malloc(($3+1)*sizeof(size_t));
+  $1 = (char **) malloc(($3+1)*sizeof(char *)); 
+  for(i = 0; i < $3; i ++) {
+    $2[i] = strlen(StringValuePtr(RARRAY_PTR($input)[i]));
+    $1[i] = StringValuePtr(RARRAY_PTR($input)[i]);
+  }
+}
+%typemap(freearg) (char **keys, size_t *key_length, unsigned int number_of_keys) {
+   free($1);
+   free($2);
+}
+
+// Generic strings
+%typemap(in) (char *str, size_t len) {
+ $1 = STR2CSTR($input);
+ $2 = (size_t) RSTRING($input)->len;
+};
+
+%apply (char *str, size_t len) {
+  (char *key, size_t key_length), 
+  (char *value, size_t value_length)
+};
+
+//// Output maps
+%apply unsigned short *OUTPUT {memcached_return *error}
+%apply unsigned int *OUTPUT {uint32_t *flags}
+%apply size_t *OUTPUT {size_t *value_length}
+%apply unsigned long long *OUTPUT {uint64_t *value}
+
+// String
+%typemap(in, numinputs=0) (char *key, size_t *key_length) {
+  $1 = malloc(512*sizeof(char));
+  $2 = malloc(sizeof(size_t)); // XXX Could possibly be the address of a local
+}; 
+%typemap(argout) (char *key, size_t *key_length) {
+  if ($1 != NULL) {
+    rb_ary_push($result, rb_str_new($1, *$2));
+    free($1);
+    free($2);
+  }
+}
+
+// Array of strings
+%typemap(out) (char **) {
+  int i;  
+  VALUE ary = rb_ary_new();
+  $result = rb_ary_new();
+  
+  for(i=0; $1[i] != NULL; i++) {
+    rb_ary_store(ary, i, rb_str_new2($1[i]));
+  }
+  rb_ary_push($result, ary);
+  free($1);
+};
+
+%include "/opt/local/include/libmemcached/memcached.h"
+
+// Manual wrappers
+
+// Single get. SWIG likes to use SWIG_FromCharPtr instead of SWIG_FromCharPtrAndSize because 
+// of the retval/argout split, so it truncates return values with \0 in them. 
+VALUE memcached_get_rvalue(memcached_st *ptr, char *key, size_t key_length, uint32_t *flags, memcached_return *error);
+%{
+VALUE memcached_get_rvalue(memcached_st *ptr, char *key, size_t key_length, uint32_t *flags, memcached_return *error) {
+  VALUE ret;  
+  size_t value_length;
+  char *value = memcached_get(ptr, key, key_length, &value_length, flags, error);
+  ret = rb_str_new(value, value_length);
+  free(value);
+  return ret;
+};
+%}
+
+// Multi get
+VALUE memcached_fetch_rvalue(memcached_st *ptr, char *key, size_t *key_length, uint32_t *flags, memcached_return *error);
+%{
+VALUE memcached_fetch_rvalue(memcached_st *ptr, char *key, size_t *key_length, uint32_t *flags, memcached_return *error) {
+  size_t value_length;
+  VALUE result = rb_ary_new();
+  
+  char *value = memcached_fetch(ptr, key, key_length, &value_length, flags, error);
+  if (value == NULL) {
+    rb_ary_push(result, Qnil);
+  } else {
+    VALUE ret = rb_str_new(value, value_length);
+    rb_ary_push(result, ret);
+    free(value);
+  }
+  return result;
+};
+%}
+
+// We need to wrap this so it doesn't leak memory. SWIG doesn't want to automatically free. We could
+// maybe use a 'ret' %typemap, but this is ok.
+VALUE memcached_stat_get_rvalue(memcached_st *ptr, memcached_stat_st *stat, char *key, memcached_return *error);
+%{
+VALUE memcached_stat_get_rvalue(memcached_st *ptr, memcached_stat_st *stat, char *key, memcached_return *error) {
+  char *str;
+  VALUE ret;
+  str = memcached_stat_get_value(ptr, stat, key, error);
+  ret = rb_str_new2(str);
+  free(str);
+  return ret;
+};
+%}
+
+// Ruby isn't aware that the pointer is an array... there is probably a better way to do this
+memcached_server_st *memcached_select_server_at(memcached_st *in_ptr, int index);
+%{
+memcached_server_st *memcached_select_server_at(memcached_st *in_ptr, int index) {
+  return &(in_ptr->hosts[index]);
+};
+%}
+
+// Same, but for stats
+memcached_stat_st *memcached_select_stat_at(memcached_st *in_ptr, memcached_stat_st *stat_ptr, int index);
+%{
+memcached_stat_st *memcached_select_stat_at(memcached_st *in_ptr, memcached_stat_st *stat_ptr, int index) {
+  return &(stat_ptr[index]);
+};
+%}

data/ext/{libmemcached_wrap.c → rlibmemcached_wrap.c}

@@ -1511,37 +1511,43 @@ SWIG_Ruby_SetModule(swig_module_info *pointer)
 
 #define SWIGTYPE_p_addrinfo swig_types[0]
 #define SWIGTYPE_p_char swig_types[1]
-#define SWIGTYPE_p_int32_t swig_types[2]
-#define SWIGTYPE_p_memcached_allocated swig_types[3]
-#define SWIGTYPE_p_memcached_behavior swig_types[4]
-#define SWIGTYPE_p_memcached_connection swig_types[5]
-#define SWIGTYPE_p_memcached_hash swig_types[6]
-#define SWIGTYPE_p_memcached_result_st swig_types[7]
-#define SWIGTYPE_p_memcached_return swig_types[8]
-#define SWIGTYPE_p_memcached_server_distribution swig_types[9]
-#define SWIGTYPE_p_memcached_server_st swig_types[10]
-#define SWIGTYPE_p_memcached_st swig_types[11]
-#define SWIGTYPE_p_memcached_stat_st swig_types[12]
-#define SWIGTYPE_p_memcached_string_st swig_types[13]
-#define SWIGTYPE_p_p_char swig_types[14]
-#define SWIGTYPE_p_p_f_p_struct_memcached_st_p_struct_memcached_result_st_p_void__unsigned_int swig_types[15]
-#define SWIGTYPE_p_size_t swig_types[16]
-#define SWIGTYPE_p_time_t swig_types[17]
-#define SWIGTYPE_p_uint32_t swig_types[18]
-#define SWIGTYPE_p_uint64_t swig_types[19]
-#define SWIGTYPE_p_unsigned_int swig_types[20]
-#define SWIGTYPE_p_void swig_types[21]
-static swig_type_info *swig_types[23];
-static swig_module_info swig_module = {swig_types, 22, 0, 0, 0, 0};
+#define SWIGTYPE_p_f_p_struct_memcached_st__memcached_return swig_types[2]
+#define SWIGTYPE_p_f_p_struct_memcached_st_p_struct_memcached_st__memcached_return swig_types[3]
+#define SWIGTYPE_p_f_p_struct_memcached_st_p_void__void swig_types[4]
+#define SWIGTYPE_p_f_p_struct_memcached_st_p_void_q_const__size_t__p_void swig_types[5]
+#define SWIGTYPE_p_f_p_struct_memcached_st_q_const__size_t__p_void swig_types[6]
+#define SWIGTYPE_p_int32_t swig_types[7]
+#define SWIGTYPE_p_memcached_allocated swig_types[8]
+#define SWIGTYPE_p_memcached_behavior swig_types[9]
+#define SWIGTYPE_p_memcached_callback swig_types[10]
+#define SWIGTYPE_p_memcached_connection swig_types[11]
+#define SWIGTYPE_p_memcached_hash swig_types[12]
+#define SWIGTYPE_p_memcached_result_st swig_types[13]
+#define SWIGTYPE_p_memcached_return swig_types[14]
+#define SWIGTYPE_p_memcached_server_distribution swig_types[15]
+#define SWIGTYPE_p_memcached_server_st swig_types[16]
+#define SWIGTYPE_p_memcached_st swig_types[17]
+#define SWIGTYPE_p_memcached_stat_st swig_types[18]
+#define SWIGTYPE_p_memcached_string_st swig_types[19]
+#define SWIGTYPE_p_p_char swig_types[20]
+#define SWIGTYPE_p_p_f_p_struct_memcached_st_p_struct_memcached_result_st_p_void__unsigned_int swig_types[21]
+#define SWIGTYPE_p_size_t swig_types[22]
+#define SWIGTYPE_p_time_t swig_types[23]
+#define SWIGTYPE_p_uint32_t swig_types[24]
+#define SWIGTYPE_p_uint64_t swig_types[25]
+#define SWIGTYPE_p_unsigned_int swig_types[26]
+#define SWIGTYPE_p_void swig_types[27]
+static swig_type_info *swig_types[29];
+static swig_module_info swig_module = {swig_types, 28, 0, 0, 0, 0};
 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
 
 /* -------- TYPES TABLE (END) -------- */
 
-#define SWIG_init    Init_libmemcached
-#define SWIG_name    "Libmemcached"
+#define SWIG_init    Init_rlibmemcached
+#define SWIG_name    "Rlibmemcached"
 
-static VALUE mLibmemcached;
+static VALUE mRlibmemcached;
 
 #define SWIGVERSION 0x010329 
 
@@ -1609,6 +1615,30 @@ SWIG_pchar_descriptor()
 }
 
 
+SWIGINTERNINLINE VALUE 
+SWIG_FromCharPtrAndSize(const char* carray, size_t size)
+{
+  if (carray) {
+    if (size > LONG_MAX) {
+      swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
+      return pchar_descriptor ? 
+	SWIG_NewPointerObj((char *)(carray), pchar_descriptor, 0) : Qnil;
+    } else {
+      return rb_str_new(carray, (long)(size));
+    }
+  } else {
+    return Qnil;
+  }
+}
+
+
+SWIGINTERNINLINE VALUE 
+SWIG_FromCharPtr(const char *cptr)
+{ 
+  return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
+}
+
+
 SWIGINTERN int
 SWIG_AsCharPtrAndSize(VALUE obj, char** cptr, size_t* psize, int *alloc)
 {
@@ -1671,23 +1701,6 @@ SWIG_AsCharArray(VALUE obj, char *val, size_t size)
 }
 
 
-SWIGINTERNINLINE VALUE 
-SWIG_FromCharPtrAndSize(const char* carray, size_t size)
-{
-  if (carray) {
-    if (size > LONG_MAX) {
-      swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
-      return pchar_descriptor ? 
-	SWIG_NewPointerObj((char *)(carray), pchar_descriptor, 0) : Qnil;
-    } else {
-      return rb_str_new(carray, (long)(size));
-    }
-  } else {
-    return Qnil;
-  }
-}
-
-
 SWIGINTERN VALUE
 SWIG_ruby_failed(void)
 {
@@ -1819,13 +1832,6 @@ SWIG_From_size_t  (size_t value)
 
 
 
-SWIGINTERNINLINE VALUE 
-SWIG_FromCharPtr(const char *cptr)
-{ 
-  return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
-}
-
-
 SWIGINTERN int
 SWIG_AsVal_unsigned_SS_short (VALUE obj, unsigned short *val)
 {
@@ -1849,61 +1855,6 @@ SWIG_From_unsigned_SS_short  (unsigned short value)
 }
 
 
-SWIGINTERN int
-SWIG_AsVal_char (VALUE obj, char *val)
-{    
-  int res = SWIG_AsCharArray(obj, val, 1);
-  if (!SWIG_IsOK(res)) {
-    long v;
-    res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
-    if (SWIG_IsOK(res)) {
-      if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
-	if (val) *val = (char)(v);
-      } else {
-	res = SWIG_OverflowError;
-      }
-    }
-  }
-  return res;
-}
-
-
-SWIGINTERNINLINE VALUE
-SWIG_From_char  (char c) 
-{ 
-  return SWIG_FromCharPtrAndSize(&c,1);
-}
-
-
-/*@SWIG:%ruby_aux_method@*/
-SWIGINTERN VALUE SWIG_AUX_NUM2ULL(VALUE *args)
-{
-  VALUE obj = args[0];
-  VALUE type = TYPE(obj);
-  long long *res = (long long *)(args[1]);
-  *res = type == T_FIXNUM ? NUM2ULL(obj) : rb_big2ull(obj);
-  return obj;
-}
-/*@SWIG@*/
-
-SWIGINTERN int
-SWIG_AsVal_unsigned_SS_long_SS_long (VALUE obj, unsigned long long *val)
-{ 
-  VALUE type = TYPE(obj);
-  if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
-    unsigned long long v;
-    VALUE a[2];
-    a[0] = obj;
-    a[1] = (VALUE)(&v);
-    if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2ULL), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
-      if (val) *val = v;
-      return SWIG_OK;
-    }
-  }
-  return SWIG_TypeError;
-}
-
-
 SWIGINTERNINLINE VALUE 
 SWIG_From_long_SS_long  (long long value)
 {
@@ -1918,35 +1869,49 @@ SWIG_From_unsigned_SS_long_SS_long  (unsigned long long value)
 }
 
 
-VALUE memcached_get_ruby_string(memcached_st *ptr, char *key, size_t key_length, uint32_t *flags, memcached_return *error) {
-  char *svalue;
-  size_t *value_length;
-  svalue = memcached_get(ptr, key, key_length, value_length, flags, error);
-  return rb_str_new(svalue, *value_length);
+VALUE memcached_get_rvalue(memcached_st *ptr, char *key, size_t key_length, uint32_t *flags, memcached_return *error) {
+  VALUE ret;  
+  size_t value_length;
+  char *value = memcached_get(ptr, key, key_length, &value_length, flags, error);
+  ret = rb_str_new(value, value_length);
+  free(value);
+  return ret;
 };
 
 
-memcached_server_st *memcached_select_server_at(memcached_st *in_ptr, int index) {
-  return &(in_ptr->hosts[index]);
+VALUE memcached_fetch_rvalue(memcached_st *ptr, char *key, size_t *key_length, uint32_t *flags, memcached_return *error) {
+  size_t value_length;
+  VALUE result = rb_ary_new();
+  
+  char *value = memcached_fetch(ptr, key, key_length, &value_length, flags, error);
+  if (value == NULL) {
+    rb_ary_push(result, Qnil);
+  } else {
+    VALUE ret = rb_str_new(value, value_length);
+    rb_ary_push(result, ret);
+    free(value);
+  }
+  return result;
 };
 
 
-memcached_stat_st *memcached_select_stat_at(memcached_st *in_ptr, memcached_stat_st *stat_ptr, int index) {
-  return &(stat_ptr[index]);
+VALUE memcached_stat_get_rvalue(memcached_st *ptr, memcached_stat_st *stat, char *key, memcached_return *error) {
+  char *str;
+  VALUE ret;
+  str = memcached_stat_get_value(ptr, stat, key, error);
+  ret = rb_str_new2(str);
+  free(str);
+  return ret;
 };
 
 
-void memcached_repair_server_st(memcached_st *in_ptr, memcached_server_st *host) {
-    host->write_ptr= 0;
+memcached_server_st *memcached_select_server_at(memcached_st *in_ptr, int index) {
+  return &(in_ptr->hosts[index]);
 };
 
 
-memcached_return memcached_mdelete(memcached_st *ptr, char **key, size_t *key_length, unsigned int number_of_keys, time_t expiration) {
-  return;
-};
-memcached_return memcached_mdelete_by_key(memcached_st *ptr, char *master_key, size_t master_key_length,
- char **key, size_t *key_length, unsigned int number_of_keys, time_t expiration) {
-  return;
+memcached_stat_st *memcached_select_stat_at(memcached_st *in_ptr, memcached_stat_st *stat_ptr, int index) {
+  return &(stat_ptr[index]);
 };
 
 swig_class cMemcachedServerSt;
@@ -2119,6 +2084,60 @@ fail:
 }
 
 
+SWIGINTERN VALUE
+_wrap_MemcachedServerSt_cached_errno_set(int argc, VALUE *argv, VALUE self) {
+  struct memcached_server_st *arg1 = (struct memcached_server_st *) 0 ;
+  int arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_server_st, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cached_errno" "', argument " "1"" of type '" "struct memcached_server_st *""'"); 
+  }
+  arg1 = (struct memcached_server_st *)(argp1);
+  ecode2 = SWIG_AsVal_int(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cached_errno" "', argument " "2"" of type '" "int""'");
+  } 
+  arg2 = (int)(val2);
+  if (arg1) (arg1)->cached_errno = arg2;
+  
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_MemcachedServerSt_cached_errno_get(int argc, VALUE *argv, VALUE self) {
+  struct memcached_server_st *arg1 = (struct memcached_server_st *) 0 ;
+  int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_server_st, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cached_errno" "', argument " "1"" of type '" "struct memcached_server_st *""'"); 
+  }
+  arg1 = (struct memcached_server_st *)(argp1);
+  result = (int) ((arg1)->cached_errno);
+  vresult = SWIG_From_int((int)(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
 SWIGINTERN VALUE
 _wrap_MemcachedServerSt_cursor_active_set(int argc, VALUE *argv, VALUE self) {
   struct memcached_server_st *arg1 = (struct memcached_server_st *) 0 ;
@@ -2287,68 +2306,6 @@ fail:
 }
 
 
-SWIGINTERN VALUE
-_wrap_MemcachedServerSt_write_ptr_set(int argc, VALUE *argv, VALUE self) {
-  struct memcached_server_st *arg1 = (struct memcached_server_st *) 0 ;
-  char *arg2 = (char *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  int res2 ;
-  char *buf2 = 0 ;
-  int alloc2 = 0 ;
-  
-  if ((argc < 1) || (argc > 1)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
-  }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_server_st, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "write_ptr" "', argument " "1"" of type '" "struct memcached_server_st *""'"); 
-  }
-  arg1 = (struct memcached_server_st *)(argp1);
-  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "write_ptr" "', argument " "2"" of type '" "char *""'");
-  }
-  arg2 = buf2;
-  if (arg1->write_ptr) free((char*)arg1->write_ptr);
-  if (arg2) {
-    size_t size = strlen(arg2) + 1;
-    arg1->write_ptr = (char *)memcpy((char *)malloc((size)*sizeof(char)), arg2, sizeof(char)*(size));
-  } else {
-    arg1->write_ptr = 0;
-  }
-  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
-  return Qnil;
-fail:
-  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
-  return Qnil;
-}
-
-
-SWIGINTERN VALUE
-_wrap_MemcachedServerSt_write_ptr_get(int argc, VALUE *argv, VALUE self) {
-  struct memcached_server_st *arg1 = (struct memcached_server_st *) 0 ;
-  char *result = 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  VALUE vresult = Qnil;
-  
-  if ((argc < 0) || (argc > 0)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
-  }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_server_st, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "write_ptr" "', argument " "1"" of type '" "struct memcached_server_st *""'"); 
-  }
-  arg1 = (struct memcached_server_st *)(argp1);
-  result = (char *) ((arg1)->write_ptr);
-  vresult = SWIG_FromCharPtr(result);
-  return vresult;
-fail:
-  return Qnil;
-}
-
-
 SWIGINTERN VALUE
 _wrap_MemcachedServerSt_read_buffer_set(int argc, VALUE *argv, VALUE self) {
   struct memcached_server_st *arg1 = (struct memcached_server_st *) 0 ;
@@ -2957,6 +2914,60 @@ fail:
 }
 
 
+SWIGINTERN VALUE
+_wrap_MemcachedServerSt_root_set(int argc, VALUE *argv, VALUE self) {
+  struct memcached_server_st *arg1 = (struct memcached_server_st *) 0 ;
+  memcached_st *arg2 = (memcached_st *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_server_st, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "root" "', argument " "1"" of type '" "struct memcached_server_st *""'"); 
+  }
+  arg1 = (struct memcached_server_st *)(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_memcached_st, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "root" "', argument " "2"" of type '" "memcached_st *""'"); 
+  }
+  arg2 = (memcached_st *)(argp2);
+  if (arg1) (arg1)->root = arg2;
+  
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_MemcachedServerSt_root_get(int argc, VALUE *argv, VALUE self) {
+  struct memcached_server_st *arg1 = (struct memcached_server_st *) 0 ;
+  memcached_st *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_server_st, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "root" "', argument " "1"" of type '" "struct memcached_server_st *""'"); 
+  }
+  arg1 = (struct memcached_server_st *)(argp1);
+  result = (memcached_st *) ((arg1)->root);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_memcached_st, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
 SWIGINTERN VALUE
 _wrap_MemcachedServerSt_allocate(VALUE self) {
@@ -5500,61 +5511,7 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_MemcachedSt_connected_set(int argc, VALUE *argv, VALUE self) {
-  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
-  char arg2 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  char val2 ;
-  int ecode2 = 0 ;
-  
-  if ((argc < 1) || (argc > 1)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
-  }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "connected" "', argument " "1"" of type '" "struct memcached_st *""'"); 
-  }
-  arg1 = (struct memcached_st *)(argp1);
-  ecode2 = SWIG_AsVal_char(argv[0], &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "connected" "', argument " "2"" of type '" "char""'");
-  } 
-  arg2 = (char)(val2);
-  if (arg1) (arg1)->connected = arg2;
-  
-  return Qnil;
-fail:
-  return Qnil;
-}
-
-
-SWIGINTERN VALUE
-_wrap_MemcachedSt_connected_get(int argc, VALUE *argv, VALUE self) {
-  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
-  char result;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  VALUE vresult = Qnil;
-  
-  if ((argc < 0) || (argc > 0)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
-  }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "connected" "', argument " "1"" of type '" "struct memcached_st *""'"); 
-  }
-  arg1 = (struct memcached_st *)(argp1);
-  result = (char) ((arg1)->connected);
-  vresult = SWIG_From_char((char)(result));
-  return vresult;
-fail:
-  return Qnil;
-}
-
-
-SWIGINTERN VALUE
-_wrap_MemcachedSt_cached_errno_set(int argc, VALUE *argv, VALUE self) {
+_wrap_MemcachedSt_cached_errno_set(int argc, VALUE *argv, VALUE self) {
   struct memcached_st *arg1 = (struct memcached_st *) 0 ;
   int arg2 ;
   void *argp1 = 0 ;
@@ -5610,10 +5567,10 @@ fail:
 SWIGINTERN VALUE
 _wrap_MemcachedSt_flags_set(int argc, VALUE *argv, VALUE self) {
   struct memcached_st *arg1 = (struct memcached_st *) 0 ;
-  unsigned long long arg2 ;
+  uint32_t arg2 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  unsigned long long val2 ;
+  unsigned long val2 ;
   int ecode2 = 0 ;
   
   if ((argc < 1) || (argc > 1)) {
@@ -5624,11 +5581,11 @@ _wrap_MemcachedSt_flags_set(int argc, VALUE *argv, VALUE self) {
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "flags" "', argument " "1"" of type '" "struct memcached_st *""'"); 
   }
   arg1 = (struct memcached_st *)(argp1);
-  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(argv[0], &val2);
+  ecode2 = SWIG_AsVal_unsigned_SS_long(argv[0], &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "flags" "', argument " "2"" of type '" "unsigned long long""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "flags" "', argument " "2"" of type '" "uint32_t""'");
   } 
-  arg2 = (unsigned long long)(val2);
+  arg2 = (uint32_t)(val2);
   if (arg1) (arg1)->flags = arg2;
   
   return Qnil;
@@ -5640,7 +5597,7 @@ fail:
 SWIGINTERN VALUE
 _wrap_MemcachedSt_flags_get(int argc, VALUE *argv, VALUE self) {
   struct memcached_st *arg1 = (struct memcached_st *) 0 ;
-  unsigned long long result;
+  uint32_t result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   VALUE vresult = Qnil;
@@ -5653,8 +5610,8 @@ _wrap_MemcachedSt_flags_get(int argc, VALUE *argv, VALUE self) {
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "flags" "', argument " "1"" of type '" "struct memcached_st *""'"); 
   }
   arg1 = (struct memcached_st *)(argp1);
-  result = (unsigned long long) ((arg1)->flags);
-  vresult = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
+  result =  ((arg1)->flags);
+  vresult = SWIG_From_unsigned_SS_long((unsigned long)(result));
   return vresult;
 fail:
   return Qnil;
@@ -6103,6 +6060,271 @@ fail:
 }
 
 
+SWIGINTERN VALUE
+_wrap_MemcachedSt_on_clone_set(int argc, VALUE *argv, VALUE self) {
+  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
+  memcached_clone_func arg2 = (memcached_clone_func) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "on_clone" "', argument " "1"" of type '" "struct memcached_st *""'"); 
+  }
+  arg1 = (struct memcached_st *)(argp1);
+  {
+    int res = SWIG_ConvertFunctionPtr(argv[0], (void**)(&arg2), SWIGTYPE_p_f_p_struct_memcached_st_p_struct_memcached_st__memcached_return);
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "on_clone" "', argument " "2"" of type '" "memcached_clone_func""'"); 
+    }
+  }
+  if (arg1) (arg1)->on_clone = arg2;
+  
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_MemcachedSt_on_clone_get(int argc, VALUE *argv, VALUE self) {
+  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
+  memcached_clone_func result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "on_clone" "', argument " "1"" of type '" "struct memcached_st *""'"); 
+  }
+  arg1 = (struct memcached_st *)(argp1);
+  result = (memcached_clone_func) ((arg1)->on_clone);
+  vresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_struct_memcached_st_p_struct_memcached_st__memcached_return);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_MemcachedSt_on_cleanup_set(int argc, VALUE *argv, VALUE self) {
+  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
+  memcached_cleanup_func arg2 = (memcached_cleanup_func) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "on_cleanup" "', argument " "1"" of type '" "struct memcached_st *""'"); 
+  }
+  arg1 = (struct memcached_st *)(argp1);
+  {
+    int res = SWIG_ConvertFunctionPtr(argv[0], (void**)(&arg2), SWIGTYPE_p_f_p_struct_memcached_st__memcached_return);
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "on_cleanup" "', argument " "2"" of type '" "memcached_cleanup_func""'"); 
+    }
+  }
+  if (arg1) (arg1)->on_cleanup = arg2;
+  
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_MemcachedSt_on_cleanup_get(int argc, VALUE *argv, VALUE self) {
+  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
+  memcached_cleanup_func result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "on_cleanup" "', argument " "1"" of type '" "struct memcached_st *""'"); 
+  }
+  arg1 = (struct memcached_st *)(argp1);
+  result = (memcached_cleanup_func) ((arg1)->on_cleanup);
+  vresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_struct_memcached_st__memcached_return);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_MemcachedSt_call_free_set(int argc, VALUE *argv, VALUE self) {
+  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
+  memcached_free_function arg2 = (memcached_free_function) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "call_free" "', argument " "1"" of type '" "struct memcached_st *""'"); 
+  }
+  arg1 = (struct memcached_st *)(argp1);
+  {
+    int res = SWIG_ConvertFunctionPtr(argv[0], (void**)(&arg2), SWIGTYPE_p_f_p_struct_memcached_st_p_void__void);
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "call_free" "', argument " "2"" of type '" "memcached_free_function""'"); 
+    }
+  }
+  if (arg1) (arg1)->call_free = arg2;
+  
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_MemcachedSt_call_free_get(int argc, VALUE *argv, VALUE self) {
+  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
+  memcached_free_function result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "call_free" "', argument " "1"" of type '" "struct memcached_st *""'"); 
+  }
+  arg1 = (struct memcached_st *)(argp1);
+  result = (memcached_free_function) ((arg1)->call_free);
+  vresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_struct_memcached_st_p_void__void);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_MemcachedSt_call_malloc_set(int argc, VALUE *argv, VALUE self) {
+  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
+  memcached_malloc_function arg2 = (memcached_malloc_function) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "call_malloc" "', argument " "1"" of type '" "struct memcached_st *""'"); 
+  }
+  arg1 = (struct memcached_st *)(argp1);
+  {
+    int res = SWIG_ConvertFunctionPtr(argv[0], (void**)(&arg2), SWIGTYPE_p_f_p_struct_memcached_st_q_const__size_t__p_void);
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "call_malloc" "', argument " "2"" of type '" "memcached_malloc_function""'"); 
+    }
+  }
+  if (arg1) (arg1)->call_malloc = arg2;
+  
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_MemcachedSt_call_malloc_get(int argc, VALUE *argv, VALUE self) {
+  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
+  memcached_malloc_function result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "call_malloc" "', argument " "1"" of type '" "struct memcached_st *""'"); 
+  }
+  arg1 = (struct memcached_st *)(argp1);
+  result = (memcached_malloc_function) ((arg1)->call_malloc);
+  vresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_struct_memcached_st_q_const__size_t__p_void);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_MemcachedSt_call_realloc_set(int argc, VALUE *argv, VALUE self) {
+  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
+  memcached_realloc_function arg2 = (memcached_realloc_function) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "call_realloc" "', argument " "1"" of type '" "struct memcached_st *""'"); 
+  }
+  arg1 = (struct memcached_st *)(argp1);
+  {
+    int res = SWIG_ConvertFunctionPtr(argv[0], (void**)(&arg2), SWIGTYPE_p_f_p_struct_memcached_st_p_void_q_const__size_t__p_void);
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "call_realloc" "', argument " "2"" of type '" "memcached_realloc_function""'"); 
+    }
+  }
+  if (arg1) (arg1)->call_realloc = arg2;
+  
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_MemcachedSt_call_realloc_get(int argc, VALUE *argv, VALUE self) {
+  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
+  memcached_realloc_function result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "call_realloc" "', argument " "1"" of type '" "struct memcached_st *""'"); 
+  }
+  arg1 = (struct memcached_st *)(argp1);
+  result = (memcached_realloc_function) ((arg1)->call_realloc);
+  vresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_struct_memcached_st_p_void_q_const__size_t__p_void);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
 SWIGINTERN VALUE
 _wrap_MemcachedSt_allocate(VALUE self) {
@@ -6140,6 +6362,22 @@ free_memcached_st(struct memcached_st *arg1) {
     free((char *) arg1);
 }
 
+SWIGINTERN VALUE
+_wrap_memcached_lib_version(int argc, VALUE *argv, VALUE self) {
+  char *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (char *)memcached_lib_version();
+  vresult = SWIG_FromCharPtr(result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
 SWIGINTERN VALUE
 _wrap_memcached_create(int argc, VALUE *argv, VALUE self) {
   memcached_st *arg1 = (memcached_st *) 0 ;
@@ -7058,41 +7296,39 @@ _wrap_memcached_mget(int argc, VALUE *argv, VALUE self) {
   memcached_return result;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
-  void *argp3 = 0 ;
-  int res3 = 0 ;
-  unsigned int val4 ;
-  int ecode4 = 0 ;
   VALUE vresult = Qnil;
   
-  if ((argc < 4) || (argc > 4)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   }
   res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "memcached_mget" "', argument " "1"" of type '" "memcached_st *""'"); 
   }
   arg1 = (memcached_st *)(argp1);
-  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_p_char, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "memcached_mget" "', argument " "2"" of type '" "char **""'"); 
-  }
-  arg2 = (char **)(argp2);
-  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_size_t, 0 |  0 );
-  if (!SWIG_IsOK(res3)) {
-    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "memcached_mget" "', argument " "3"" of type '" "size_t *""'"); 
+  {
+    int i;
+    Check_Type(argv[1], T_ARRAY);
+    arg4 = (unsigned int) RARRAY_LEN(argv[1]);
+    arg3 = (size_t *) malloc((arg4+1)*sizeof(size_t));
+    arg2 = (char **) malloc((arg4+1)*sizeof(char *)); 
+    for(i = 0; i < arg4; i ++) {
+      arg3[i] = strlen(StringValuePtr(RARRAY_PTR(argv[1])[i]));
+      arg2[i] = StringValuePtr(RARRAY_PTR(argv[1])[i]);
+    }
   }
-  arg3 = (size_t *)(argp3);
-  ecode4 = SWIG_AsVal_unsigned_SS_int(argv[3], &val4);
-  if (!SWIG_IsOK(ecode4)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "memcached_mget" "', argument " "4"" of type '" "unsigned int""'");
-  } 
-  arg4 = (unsigned int)(val4);
   result = (memcached_return)memcached_mget(arg1,arg2,arg3,arg4);
   vresult = SWIG_From_int((int)(result));
+  {
+    free(arg2);
+    free(arg3);
+  }
   return vresult;
 fail:
+  {
+    free(arg2);
+    free(arg3);
+  }
   return Qnil;
 }
 
@@ -7108,11 +7344,6 @@ _wrap_memcached_fetch(int argc, VALUE *argv, VALUE self) {
   char *result = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  int res2 ;
-  char *buf2 = 0 ;
-  int alloc2 = 0 ;
-  void *argp3 = 0 ;
-  int res3 = 0 ;
   size_t temp4 ;
   int res4 = SWIG_TMPOBJ ;
   uint32_t temp5 ;
@@ -7121,29 +7352,30 @@ _wrap_memcached_fetch(int argc, VALUE *argv, VALUE self) {
   int res6 = SWIG_TMPOBJ ;
   VALUE vresult = Qnil;
   
+  {
+    arg2 = malloc(512*sizeof(char));
+    arg3 = malloc(sizeof(size_t)); // XXX Could possibly be the address of a local
+  }
   arg4 = &temp4;
   arg5 = &temp5;
   arg6 = &temp6;
-  if ((argc < 3) || (argc > 3)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   }
   res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "memcached_fetch" "', argument " "1"" of type '" "memcached_st *""'"); 
   }
   arg1 = (memcached_st *)(argp1);
-  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "memcached_fetch" "', argument " "2"" of type '" "char *""'");
-  }
-  arg2 = buf2;
-  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_size_t, 0 |  0 );
-  if (!SWIG_IsOK(res3)) {
-    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "memcached_fetch" "', argument " "3"" of type '" "size_t *""'"); 
-  }
-  arg3 = (size_t *)(argp3);
   result = (char *)memcached_fetch(arg1,arg2,arg3,arg4,arg5,arg6);
   vresult = SWIG_FromCharPtr(result);
+  {
+    if (arg2 != NULL) {
+      rb_ary_push(vresult, rb_str_new(arg2, *arg3));
+      free(arg2);
+      free(arg3);
+    }
+  }
   if (SWIG_IsTmpObj(res4)) {
     vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_size_t((*arg4)));
   } else {
@@ -7162,10 +7394,8 @@ _wrap_memcached_fetch(int argc, VALUE *argv, VALUE self) {
     int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
     vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_memcached_return, new_flags));
   }
-  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   return vresult;
 fail:
-  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   return Qnil;
 }
 
@@ -7690,16 +7920,10 @@ _wrap_memcached_mget_by_key(int argc, VALUE *argv, VALUE self) {
   int alloc2 = 0 ;
   size_t val3 ;
   int ecode3 = 0 ;
-  void *argp4 = 0 ;
-  int res4 = 0 ;
-  void *argp5 = 0 ;
-  int res5 = 0 ;
-  unsigned int val6 ;
-  int ecode6 = 0 ;
   VALUE vresult = Qnil;
   
-  if ((argc < 6) || (argc > 6)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
   }
   res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
@@ -7716,27 +7940,31 @@ _wrap_memcached_mget_by_key(int argc, VALUE *argv, VALUE self) {
     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "memcached_mget_by_key" "', argument " "3"" of type '" "size_t""'");
   } 
   arg3 = (size_t)(val3);
-  res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_p_char, 0 |  0 );
-  if (!SWIG_IsOK(res4)) {
-    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "memcached_mget_by_key" "', argument " "4"" of type '" "char **""'"); 
-  }
-  arg4 = (char **)(argp4);
-  res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_size_t, 0 |  0 );
-  if (!SWIG_IsOK(res5)) {
-    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "memcached_mget_by_key" "', argument " "5"" of type '" "size_t *""'"); 
-  }
-  arg5 = (size_t *)(argp5);
-  ecode6 = SWIG_AsVal_unsigned_SS_int(argv[5], &val6);
-  if (!SWIG_IsOK(ecode6)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "memcached_mget_by_key" "', argument " "6"" of type '" "unsigned int""'");
-  } 
-  arg6 = (unsigned int)(val6);
+  {
+    int i;
+    Check_Type(argv[3], T_ARRAY);
+    arg6 = (unsigned int) RARRAY_LEN(argv[3]);
+    arg5 = (size_t *) malloc((arg6+1)*sizeof(size_t));
+    arg4 = (char **) malloc((arg6+1)*sizeof(char *)); 
+    for(i = 0; i < arg6; i ++) {
+      arg5[i] = strlen(StringValuePtr(RARRAY_PTR(argv[3])[i]));
+      arg4[i] = StringValuePtr(RARRAY_PTR(argv[3])[i]);
+    }
+  }
   result = (memcached_return)memcached_mget_by_key(arg1,arg2,arg3,arg4,arg5,arg6);
   vresult = SWIG_From_int((int)(result));
   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+  {
+    free(arg4);
+    free(arg5);
+  }
   return vresult;
 fail:
   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+  {
+    free(arg4);
+    free(arg5);
+  }
   return Qnil;
 }
 
@@ -8232,53 +8460,44 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_memcached_mdelete(int argc, VALUE *argv, VALUE self) {
+_wrap_memcached_fetch_execute(int argc, VALUE *argv, VALUE self) {
   memcached_st *arg1 = (memcached_st *) 0 ;
-  char **arg2 = (char **) 0 ;
-  size_t *arg3 = (size_t *) 0 ;
+  unsigned int (**arg2)(memcached_st *,memcached_result_st *,void *) ;
+  void *arg3 = (void *) 0 ;
   unsigned int arg4 ;
-  time_t arg5 ;
   memcached_return result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   void *argp2 = 0 ;
   int res2 = 0 ;
-  void *argp3 = 0 ;
-  int res3 = 0 ;
+  int res3 ;
   unsigned int val4 ;
   int ecode4 = 0 ;
   VALUE vresult = Qnil;
   
-  if ((argc < 5) || (argc > 5)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
   }
   res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "memcached_mdelete" "', argument " "1"" of type '" "memcached_st *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "memcached_fetch_execute" "', argument " "1"" of type '" "memcached_st *""'"); 
   }
   arg1 = (memcached_st *)(argp1);
-  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_p_char, 0 |  0 );
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_p_f_p_struct_memcached_st_p_struct_memcached_result_st_p_void__unsigned_int, 0 |  0 );
   if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "memcached_mdelete" "', argument " "2"" of type '" "char **""'"); 
-  }
-  arg2 = (char **)(argp2);
-  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_size_t, 0 |  0 );
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "memcached_fetch_execute" "', argument " "2"" of type '" "unsigned int (*[])(memcached_st *,memcached_result_st *,void *)""'"); 
+  } 
+  arg2 = (unsigned int (**)(memcached_st *,memcached_result_st *,void *))(argp2);
+  res3 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg3), 0, 0);
   if (!SWIG_IsOK(res3)) {
-    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "memcached_mdelete" "', argument " "3"" of type '" "size_t *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "memcached_fetch_execute" "', argument " "3"" of type '" "void *""'"); 
   }
-  arg3 = (size_t *)(argp3);
   ecode4 = SWIG_AsVal_unsigned_SS_int(argv[3], &val4);
   if (!SWIG_IsOK(ecode4)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "memcached_mdelete" "', argument " "4"" of type '" "unsigned int""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "memcached_fetch_execute" "', argument " "4"" of type '" "unsigned int""'");
   } 
   arg4 = (unsigned int)(val4);
-  {
-    if (NIL_P(argv[4]))
-    arg5 = (time_t)-1;
-    else
-    arg5 = NUM2LONG(rb_funcall(argv[4], rb_intern("tv_sec"), 0));
-  }
-  result = (memcached_return)memcached_mdelete(arg1,arg2,arg3,arg4,arg5);
+  result = (memcached_return)memcached_fetch_execute(arg1,arg2,arg3,arg4);
   vresult = SWIG_From_int((int)(result));
   return vresult;
 fail:
@@ -8287,119 +8506,84 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_memcached_mdelete_by_key(int argc, VALUE *argv, VALUE self) {
+_wrap_memcached_callback_set(int argc, VALUE *argv, VALUE self) {
   memcached_st *arg1 = (memcached_st *) 0 ;
-  char *arg2 = (char *) 0 ;
-  size_t arg3 ;
-  char **arg4 = (char **) 0 ;
-  size_t *arg5 = (size_t *) 0 ;
-  unsigned int arg6 ;
-  time_t arg7 ;
+  memcached_callback arg2 ;
+  void *arg3 = (void *) 0 ;
   memcached_return result;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  int res2 ;
-  char *buf2 = 0 ;
-  int alloc2 = 0 ;
-  size_t val3 ;
-  int ecode3 = 0 ;
-  void *argp4 = 0 ;
-  int res4 = 0 ;
-  void *argp5 = 0 ;
-  int res5 = 0 ;
-  unsigned int val6 ;
-  int ecode6 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
   VALUE vresult = Qnil;
   
-  if ((argc < 7) || (argc > 7)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 7)",argc); SWIG_fail;
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
   }
   res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "memcached_mdelete_by_key" "', argument " "1"" of type '" "memcached_st *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "memcached_callback_set" "', argument " "1"" of type '" "memcached_st *""'"); 
   }
   arg1 = (memcached_st *)(argp1);
-  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "memcached_mdelete_by_key" "', argument " "2"" of type '" "char *""'");
-  }
-  arg2 = buf2;
-  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "memcached_mdelete_by_key" "', argument " "3"" of type '" "size_t""'");
-  } 
-  arg3 = (size_t)(val3);
-  res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_p_char, 0 |  0 );
-  if (!SWIG_IsOK(res4)) {
-    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "memcached_mdelete_by_key" "', argument " "4"" of type '" "char **""'"); 
-  }
-  arg4 = (char **)(argp4);
-  res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_size_t, 0 |  0 );
-  if (!SWIG_IsOK(res5)) {
-    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "memcached_mdelete_by_key" "', argument " "5"" of type '" "size_t *""'"); 
-  }
-  arg5 = (size_t *)(argp5);
-  ecode6 = SWIG_AsVal_unsigned_SS_int(argv[5], &val6);
-  if (!SWIG_IsOK(ecode6)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "memcached_mdelete_by_key" "', argument " "6"" of type '" "unsigned int""'");
+  ecode2 = SWIG_AsVal_int(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "memcached_callback_set" "', argument " "2"" of type '" "memcached_callback""'");
   } 
-  arg6 = (unsigned int)(val6);
+  arg2 = (memcached_callback)(val2);
   {
-    if (NIL_P(argv[6]))
-    arg7 = (time_t)-1;
-    else
-    arg7 = NUM2LONG(rb_funcall(argv[6], rb_intern("tv_sec"), 0));
+    int value = FIX2INT(argv[2]);
+    if (value == 0 || value == 1) {
+      arg3 = (void *) value;
+    } else {
+      // Only pass by reference for :distribution and :hash 
+      value = value - 2; 
+      arg3 = &value;
+    }
   }
-  result = (memcached_return)memcached_mdelete_by_key(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
+  result = (memcached_return)memcached_callback_set(arg1,arg2,arg3);
   vresult = SWIG_From_int((int)(result));
-  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   return vresult;
 fail:
-  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   return Qnil;
 }
 
 
 SWIGINTERN VALUE
-_wrap_memcached_fetch_execute(int argc, VALUE *argv, VALUE self) {
+_wrap_memcached_callback_get(int argc, VALUE *argv, VALUE self) {
   memcached_st *arg1 = (memcached_st *) 0 ;
-  unsigned int (**arg2)(memcached_st *,memcached_result_st *,void *) ;
-  void *arg3 = (void *) 0 ;
-  unsigned int arg4 ;
-  memcached_return result;
+  memcached_callback arg2 ;
+  memcached_return *arg3 = (memcached_return *) 0 ;
+  void *result = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
-  int res3 ;
-  unsigned int val4 ;
-  int ecode4 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  memcached_return temp3 ;
+  int res3 = SWIG_TMPOBJ ;
   VALUE vresult = Qnil;
   
-  if ((argc < 4) || (argc > 4)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  arg3 = &temp3;
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   }
   res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "memcached_fetch_execute" "', argument " "1"" of type '" "memcached_st *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "memcached_callback_get" "', argument " "1"" of type '" "memcached_st *""'"); 
   }
   arg1 = (memcached_st *)(argp1);
-  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_p_f_p_struct_memcached_st_p_struct_memcached_result_st_p_void__unsigned_int, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "memcached_fetch_execute" "', argument " "2"" of type '" "unsigned int (*[])(memcached_st *,memcached_result_st *,void *)""'"); 
+  ecode2 = SWIG_AsVal_int(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "memcached_callback_get" "', argument " "2"" of type '" "memcached_callback""'");
   } 
-  arg2 = (unsigned int (**)(memcached_st *,memcached_result_st *,void *))(argp2);
-  res3 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg3), 0, 0);
-  if (!SWIG_IsOK(res3)) {
-    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "memcached_fetch_execute" "', argument " "3"" of type '" "void *""'"); 
+  arg2 = (memcached_callback)(val2);
+  result = (void *)memcached_callback_get(arg1,arg2,arg3);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
+  if (SWIG_IsTmpObj(res3)) {
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_short((*arg3)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_memcached_return, new_flags));
   }
-  ecode4 = SWIG_AsVal_unsigned_SS_int(argv[3], &val4);
-  if (!SWIG_IsOK(ecode4)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "memcached_fetch_execute" "', argument " "4"" of type '" "unsigned int""'");
-  } 
-  arg4 = (unsigned int)(val4);
-  result = (memcached_return)memcached_fetch_execute(arg1,arg2,arg3,arg4);
-  vresult = SWIG_From_int((int)(result));
   return vresult;
 fail:
   return Qnil;
@@ -8508,7 +8692,7 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_memcached_get_ruby_string(int argc, VALUE *argv, VALUE self) {
+_wrap_memcached_get_rvalue(int argc, VALUE *argv, VALUE self) {
   memcached_st *arg1 = (memcached_st *) 0 ;
   char *arg2 = (char *) 0 ;
   size_t arg3 ;
@@ -8530,15 +8714,72 @@ _wrap_memcached_get_ruby_string(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "memcached_get_ruby_string" "', argument " "1"" of type '" "memcached_st *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "memcached_get_rvalue" "', argument " "1"" of type '" "memcached_st *""'"); 
   }
   arg1 = (memcached_st *)(argp1);
   {
     arg2 = STR2CSTR(argv[1]);
     arg3 = (size_t) RSTRING(argv[1])->len;
   }
-  result = (VALUE)memcached_get_ruby_string(arg1,arg2,arg3,arg4,arg5);
+  result = (VALUE)memcached_get_rvalue(arg1,arg2,arg3,arg4,arg5);
+  vresult = result;
+  if (SWIG_IsTmpObj(res4)) {
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_int((*arg4)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_uint32_t, new_flags));
+  }
+  if (SWIG_IsTmpObj(res5)) {
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_short((*arg5)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_memcached_return, new_flags));
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_memcached_fetch_rvalue(int argc, VALUE *argv, VALUE self) {
+  memcached_st *arg1 = (memcached_st *) 0 ;
+  char *arg2 = (char *) 0 ;
+  size_t *arg3 = (size_t *) 0 ;
+  uint32_t *arg4 = (uint32_t *) 0 ;
+  memcached_return *arg5 = (memcached_return *) 0 ;
+  VALUE result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  uint32_t temp4 ;
+  int res4 = SWIG_TMPOBJ ;
+  memcached_return temp5 ;
+  int res5 = SWIG_TMPOBJ ;
+  VALUE vresult = Qnil;
+  
+  {
+    arg2 = malloc(512*sizeof(char));
+    arg3 = malloc(sizeof(size_t)); // XXX Could possibly be the address of a local
+  }
+  arg4 = &temp4;
+  arg5 = &temp5;
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "memcached_fetch_rvalue" "', argument " "1"" of type '" "memcached_st *""'"); 
+  }
+  arg1 = (memcached_st *)(argp1);
+  result = (VALUE)memcached_fetch_rvalue(arg1,arg2,arg3,arg4,arg5);
   vresult = result;
+  {
+    if (arg2 != NULL) {
+      rb_ary_push(vresult, rb_str_new(arg2, *arg3));
+      free(arg2);
+      free(arg3);
+    }
+  }
   if (SWIG_IsTmpObj(res4)) {
     vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_int((*arg4)));
   } else {
@@ -8557,6 +8798,59 @@ fail:
 }
 
 
+SWIGINTERN VALUE
+_wrap_memcached_stat_get_rvalue(int argc, VALUE *argv, VALUE self) {
+  memcached_st *arg1 = (memcached_st *) 0 ;
+  memcached_stat_st *arg2 = (memcached_stat_st *) 0 ;
+  char *arg3 = (char *) 0 ;
+  memcached_return *arg4 = (memcached_return *) 0 ;
+  VALUE result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res3 ;
+  char *buf3 = 0 ;
+  int alloc3 = 0 ;
+  memcached_return temp4 ;
+  int res4 = SWIG_TMPOBJ ;
+  VALUE vresult = Qnil;
+  
+  arg4 = &temp4;
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "memcached_stat_get_rvalue" "', argument " "1"" of type '" "memcached_st *""'"); 
+  }
+  arg1 = (memcached_st *)(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_memcached_stat_st, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "memcached_stat_get_rvalue" "', argument " "2"" of type '" "memcached_stat_st *""'"); 
+  }
+  arg2 = (memcached_stat_st *)(argp2);
+  res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "memcached_stat_get_rvalue" "', argument " "3"" of type '" "char *""'");
+  }
+  arg3 = buf3;
+  result = (VALUE)memcached_stat_get_rvalue(arg1,arg2,arg3,arg4);
+  vresult = result;
+  if (SWIG_IsTmpObj(res4)) {
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_short((*arg4)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_memcached_return, new_flags));
+  }
+  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+  return vresult;
+fail:
+  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+  return Qnil;
+}
+
+
 SWIGINTERN VALUE
 _wrap_memcached_select_server_at(int argc, VALUE *argv, VALUE self) {
   memcached_st *arg1 = (memcached_st *) 0 ;
@@ -8629,43 +8923,20 @@ fail:
 }
 
 
-SWIGINTERN VALUE
-_wrap_memcached_repair_server_st(int argc, VALUE *argv, VALUE self) {
-  memcached_st *arg1 = (memcached_st *) 0 ;
-  memcached_server_st *arg2 = (memcached_server_st *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
-  
-  if ((argc < 2) || (argc > 2)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
-  }
-  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "memcached_repair_server_st" "', argument " "1"" of type '" "memcached_st *""'"); 
-  }
-  arg1 = (memcached_st *)(argp1);
-  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_memcached_server_st, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "memcached_repair_server_st" "', argument " "2"" of type '" "memcached_server_st *""'"); 
-  }
-  arg2 = (memcached_server_st *)(argp2);
-  memcached_repair_server_st(arg1,arg2);
-  return Qnil;
-fail:
-  return Qnil;
-}
-
-
 
 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
 
 static swig_type_info _swigt__p_addrinfo = {"_p_addrinfo", "struct addrinfo *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_f_p_struct_memcached_st__memcached_return = {"_p_f_p_struct_memcached_st__memcached_return", "enum memcached_return (*)(struct memcached_st *)|memcached_cleanup_func", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_f_p_struct_memcached_st_p_struct_memcached_st__memcached_return = {"_p_f_p_struct_memcached_st_p_struct_memcached_st__memcached_return", "enum memcached_return (*)(struct memcached_st *,struct memcached_st *)|memcached_clone_func", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_f_p_struct_memcached_st_p_void__void = {"_p_f_p_struct_memcached_st_p_void__void", "void (*)(struct memcached_st *,void *)|memcached_free_function", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_f_p_struct_memcached_st_p_void_q_const__size_t__p_void = {"_p_f_p_struct_memcached_st_p_void_q_const__size_t__p_void", "void *(*)(struct memcached_st *,void *,size_t const)|memcached_realloc_function", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_f_p_struct_memcached_st_q_const__size_t__p_void = {"_p_f_p_struct_memcached_st_q_const__size_t__p_void", "void *(*)(struct memcached_st *,size_t const)|memcached_malloc_function", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_int32_t = {"_p_int32_t", "int32_t *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_memcached_allocated = {"_p_memcached_allocated", "enum memcached_allocated *|memcached_allocated *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_memcached_behavior = {"_p_memcached_behavior", "enum memcached_behavior *|memcached_behavior *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_memcached_callback = {"_p_memcached_callback", "enum memcached_callback *|memcached_callback *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_memcached_connection = {"_p_memcached_connection", "enum memcached_connection *|memcached_connection *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_memcached_hash = {"_p_memcached_hash", "enum memcached_hash *|memcached_hash *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_memcached_result_st = {"_p_memcached_result_st", "struct memcached_result_st *|memcached_result_st *", 0, 0, (void*)0, 0};
@@ -8687,9 +8958,15 @@ static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
 static swig_type_info *swig_type_initial[] = {
   &_swigt__p_addrinfo,
   &_swigt__p_char,
+  &_swigt__p_f_p_struct_memcached_st__memcached_return,
+  &_swigt__p_f_p_struct_memcached_st_p_struct_memcached_st__memcached_return,
+  &_swigt__p_f_p_struct_memcached_st_p_void__void,
+  &_swigt__p_f_p_struct_memcached_st_p_void_q_const__size_t__p_void,
+  &_swigt__p_f_p_struct_memcached_st_q_const__size_t__p_void,
   &_swigt__p_int32_t,
   &_swigt__p_memcached_allocated,
   &_swigt__p_memcached_behavior,
+  &_swigt__p_memcached_callback,
   &_swigt__p_memcached_connection,
   &_swigt__p_memcached_hash,
   &_swigt__p_memcached_result_st,
@@ -8711,9 +8988,15 @@ static swig_type_info *swig_type_initial[] = {
 
 static swig_cast_info _swigc__p_addrinfo[] = {  {&_swigt__p_addrinfo, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_f_p_struct_memcached_st__memcached_return[] = {  {&_swigt__p_f_p_struct_memcached_st__memcached_return, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_f_p_struct_memcached_st_p_struct_memcached_st__memcached_return[] = {  {&_swigt__p_f_p_struct_memcached_st_p_struct_memcached_st__memcached_return, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_f_p_struct_memcached_st_p_void__void[] = {  {&_swigt__p_f_p_struct_memcached_st_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_f_p_struct_memcached_st_p_void_q_const__size_t__p_void[] = {  {&_swigt__p_f_p_struct_memcached_st_p_void_q_const__size_t__p_void, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_f_p_struct_memcached_st_q_const__size_t__p_void[] = {  {&_swigt__p_f_p_struct_memcached_st_q_const__size_t__p_void, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_int32_t[] = {  {&_swigt__p_int32_t, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_memcached_allocated[] = {  {&_swigt__p_memcached_allocated, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_memcached_behavior[] = {  {&_swigt__p_memcached_behavior, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_memcached_callback[] = {  {&_swigt__p_memcached_callback, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_memcached_connection[] = {  {&_swigt__p_memcached_connection, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_memcached_hash[] = {  {&_swigt__p_memcached_hash, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_memcached_result_st[] = {  {&_swigt__p_memcached_result_st, 0, 0, 0},{0, 0, 0, 0}};
@@ -8735,9 +9018,15 @@ static swig_cast_info _swigc__p_void[] = {  {&_swigt__p_void, 0, 0, 0},{0, 0, 0,
 static swig_cast_info *swig_cast_initial[] = {
   _swigc__p_addrinfo,
   _swigc__p_char,
+  _swigc__p_f_p_struct_memcached_st__memcached_return,
+  _swigc__p_f_p_struct_memcached_st_p_struct_memcached_st__memcached_return,
+  _swigc__p_f_p_struct_memcached_st_p_void__void,
+  _swigc__p_f_p_struct_memcached_st_p_void_q_const__size_t__p_void,
+  _swigc__p_f_p_struct_memcached_st_q_const__size_t__p_void,
   _swigc__p_int32_t,
   _swigc__p_memcached_allocated,
   _swigc__p_memcached_behavior,
+  _swigc__p_memcached_callback,
   _swigc__p_memcached_connection,
   _swigc__p_memcached_hash,
   _swigc__p_memcached_result_st,
@@ -8975,11 +9264,11 @@ SWIG_PropagateClientData(void) {
 #ifdef __cplusplus
 extern "C"
 #endif
-SWIGEXPORT void Init_libmemcached(void) {
+SWIGEXPORT void Init_rlibmemcached(void) {
   size_t i;
   
   SWIG_InitRuntime();
-  mLibmemcached = rb_define_module("Libmemcached");
+  mRlibmemcached = rb_define_module("Rlibmemcached");
   
   SWIG_InitializeModule(0);
   for (i = 0; i < swig_module.size; i++) {
@@ -8987,81 +9276,85 @@ SWIGEXPORT void Init_libmemcached(void) {
   }
   
   SWIG_RubyInitializeTrackings();
-  rb_define_const(mLibmemcached, "MEMCACHED_VERSION_STRING", SWIG_From_int((int)(12)));
-  rb_define_const(mLibmemcached, "MEMCACHED_DEFAULT_PORT", SWIG_From_int((int)(11211)));
-  rb_define_const(mLibmemcached, "MEMCACHED_DEFAULT_COMMAND_SIZE", SWIG_From_int((int)(350)));
-  rb_define_const(mLibmemcached, "SMALL_STRING_LEN", SWIG_From_int((int)(1024)));
-  rb_define_const(mLibmemcached, "HUGE_STRING_LEN", SWIG_From_int((int)(8196)));
-  rb_define_const(mLibmemcached, "MEMCACHED_MAX_KEY", SWIG_From_int((int)(251)));
-  rb_define_const(mLibmemcached, "MEMCACHED_MAX_BUFFER", SWIG_From_int((int)(8196)));
-  rb_define_const(mLibmemcached, "MEMCACHED_MAX_HOST_LENGTH", SWIG_From_int((int)(64)));
-  rb_define_const(mLibmemcached, "MEMCACHED_WHEEL_SIZE", SWIG_From_int((int)(1024)));
-  rb_define_const(mLibmemcached, "MEMCACHED_STRIDE", SWIG_From_int((int)(4)));
-  rb_define_const(mLibmemcached, "MEMCACHED_SUCCESS", SWIG_From_int((int)(MEMCACHED_SUCCESS)));
-  rb_define_const(mLibmemcached, "MEMCACHED_FAILURE", SWIG_From_int((int)(MEMCACHED_FAILURE)));
-  rb_define_const(mLibmemcached, "MEMCACHED_HOST_LOOKUP_FAILURE", SWIG_From_int((int)(MEMCACHED_HOST_LOOKUP_FAILURE)));
-  rb_define_const(mLibmemcached, "MEMCACHED_CONNECTION_FAILURE", SWIG_From_int((int)(MEMCACHED_CONNECTION_FAILURE)));
-  rb_define_const(mLibmemcached, "MEMCACHED_CONNECTION_BIND_FAILURE", SWIG_From_int((int)(MEMCACHED_CONNECTION_BIND_FAILURE)));
-  rb_define_const(mLibmemcached, "MEMCACHED_WRITE_FAILURE", SWIG_From_int((int)(MEMCACHED_WRITE_FAILURE)));
-  rb_define_const(mLibmemcached, "MEMCACHED_READ_FAILURE", SWIG_From_int((int)(MEMCACHED_READ_FAILURE)));
-  rb_define_const(mLibmemcached, "MEMCACHED_UNKNOWN_READ_FAILURE", SWIG_From_int((int)(MEMCACHED_UNKNOWN_READ_FAILURE)));
-  rb_define_const(mLibmemcached, "MEMCACHED_PROTOCOL_ERROR", SWIG_From_int((int)(MEMCACHED_PROTOCOL_ERROR)));
-  rb_define_const(mLibmemcached, "MEMCACHED_CLIENT_ERROR", SWIG_From_int((int)(MEMCACHED_CLIENT_ERROR)));
-  rb_define_const(mLibmemcached, "MEMCACHED_SERVER_ERROR", SWIG_From_int((int)(MEMCACHED_SERVER_ERROR)));
-  rb_define_const(mLibmemcached, "MEMCACHED_CONNECTION_SOCKET_CREATE_FAILURE", SWIG_From_int((int)(MEMCACHED_CONNECTION_SOCKET_CREATE_FAILURE)));
-  rb_define_const(mLibmemcached, "MEMCACHED_DATA_EXISTS", SWIG_From_int((int)(MEMCACHED_DATA_EXISTS)));
-  rb_define_const(mLibmemcached, "MEMCACHED_DATA_DOES_NOT_EXIST", SWIG_From_int((int)(MEMCACHED_DATA_DOES_NOT_EXIST)));
-  rb_define_const(mLibmemcached, "MEMCACHED_NOTSTORED", SWIG_From_int((int)(MEMCACHED_NOTSTORED)));
-  rb_define_const(mLibmemcached, "MEMCACHED_STORED", SWIG_From_int((int)(MEMCACHED_STORED)));
-  rb_define_const(mLibmemcached, "MEMCACHED_NOTFOUND", SWIG_From_int((int)(MEMCACHED_NOTFOUND)));
-  rb_define_const(mLibmemcached, "MEMCACHED_MEMORY_ALLOCATION_FAILURE", SWIG_From_int((int)(MEMCACHED_MEMORY_ALLOCATION_FAILURE)));
-  rb_define_const(mLibmemcached, "MEMCACHED_PARTIAL_READ", SWIG_From_int((int)(MEMCACHED_PARTIAL_READ)));
-  rb_define_const(mLibmemcached, "MEMCACHED_SOME_ERRORS", SWIG_From_int((int)(MEMCACHED_SOME_ERRORS)));
-  rb_define_const(mLibmemcached, "MEMCACHED_NO_SERVERS", SWIG_From_int((int)(MEMCACHED_NO_SERVERS)));
-  rb_define_const(mLibmemcached, "MEMCACHED_END", SWIG_From_int((int)(MEMCACHED_END)));
-  rb_define_const(mLibmemcached, "MEMCACHED_DELETED", SWIG_From_int((int)(MEMCACHED_DELETED)));
-  rb_define_const(mLibmemcached, "MEMCACHED_VALUE", SWIG_From_int((int)(MEMCACHED_VALUE)));
-  rb_define_const(mLibmemcached, "MEMCACHED_STAT", SWIG_From_int((int)(MEMCACHED_STAT)));
-  rb_define_const(mLibmemcached, "MEMCACHED_ERRNO", SWIG_From_int((int)(MEMCACHED_ERRNO)));
-  rb_define_const(mLibmemcached, "MEMCACHED_FAIL_UNIX_SOCKET", SWIG_From_int((int)(MEMCACHED_FAIL_UNIX_SOCKET)));
-  rb_define_const(mLibmemcached, "MEMCACHED_NOT_SUPPORTED", SWIG_From_int((int)(MEMCACHED_NOT_SUPPORTED)));
-  rb_define_const(mLibmemcached, "MEMCACHED_NO_KEY_PROVIDED", SWIG_From_int((int)(MEMCACHED_NO_KEY_PROVIDED)));
-  rb_define_const(mLibmemcached, "MEMCACHED_FETCH_NOTFINISHED", SWIG_From_int((int)(MEMCACHED_FETCH_NOTFINISHED)));
-  rb_define_const(mLibmemcached, "MEMCACHED_TIMEOUT", SWIG_From_int((int)(MEMCACHED_TIMEOUT)));
-  rb_define_const(mLibmemcached, "MEMCACHED_BUFFERED", SWIG_From_int((int)(MEMCACHED_BUFFERED)));
-  rb_define_const(mLibmemcached, "MEMCACHED_MAXIMUM_RETURN", SWIG_From_int((int)(MEMCACHED_MAXIMUM_RETURN)));
-  rb_define_const(mLibmemcached, "MEMCACHED_DISTRIBUTION_MODULA", SWIG_From_int((int)(MEMCACHED_DISTRIBUTION_MODULA)));
-  rb_define_const(mLibmemcached, "MEMCACHED_DISTRIBUTION_CONSISTENT", SWIG_From_int((int)(MEMCACHED_DISTRIBUTION_CONSISTENT)));
-  rb_define_const(mLibmemcached, "MEMCACHED_BEHAVIOR_NO_BLOCK", SWIG_From_int((int)(MEMCACHED_BEHAVIOR_NO_BLOCK)));
-  rb_define_const(mLibmemcached, "MEMCACHED_BEHAVIOR_TCP_NODELAY", SWIG_From_int((int)(MEMCACHED_BEHAVIOR_TCP_NODELAY)));
-  rb_define_const(mLibmemcached, "MEMCACHED_BEHAVIOR_HASH", SWIG_From_int((int)(MEMCACHED_BEHAVIOR_HASH)));
-  rb_define_const(mLibmemcached, "MEMCACHED_BEHAVIOR_KETAMA", SWIG_From_int((int)(MEMCACHED_BEHAVIOR_KETAMA)));
-  rb_define_const(mLibmemcached, "MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE", SWIG_From_int((int)(MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE)));
-  rb_define_const(mLibmemcached, "MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE", SWIG_From_int((int)(MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE)));
-  rb_define_const(mLibmemcached, "MEMCACHED_BEHAVIOR_CACHE_LOOKUPS", SWIG_From_int((int)(MEMCACHED_BEHAVIOR_CACHE_LOOKUPS)));
-  rb_define_const(mLibmemcached, "MEMCACHED_BEHAVIOR_SUPPORT_CAS", SWIG_From_int((int)(MEMCACHED_BEHAVIOR_SUPPORT_CAS)));
-  rb_define_const(mLibmemcached, "MEMCACHED_BEHAVIOR_POLL_TIMEOUT", SWIG_From_int((int)(MEMCACHED_BEHAVIOR_POLL_TIMEOUT)));
-  rb_define_const(mLibmemcached, "MEMCACHED_BEHAVIOR_DISTRIBUTION", SWIG_From_int((int)(MEMCACHED_BEHAVIOR_DISTRIBUTION)));
-  rb_define_const(mLibmemcached, "MEMCACHED_BEHAVIOR_BUFFER_REQUESTS", SWIG_From_int((int)(MEMCACHED_BEHAVIOR_BUFFER_REQUESTS)));
-  rb_define_const(mLibmemcached, "MEMCACHED_BEHAVIOR_USER_DATA", SWIG_From_int((int)(MEMCACHED_BEHAVIOR_USER_DATA)));
-  rb_define_const(mLibmemcached, "MEMCACHED_HASH_DEFAULT", SWIG_From_int((int)(MEMCACHED_HASH_DEFAULT)));
-  rb_define_const(mLibmemcached, "MEMCACHED_HASH_MD5", SWIG_From_int((int)(MEMCACHED_HASH_MD5)));
-  rb_define_const(mLibmemcached, "MEMCACHED_HASH_CRC", SWIG_From_int((int)(MEMCACHED_HASH_CRC)));
-  rb_define_const(mLibmemcached, "MEMCACHED_HASH_FNV1_64", SWIG_From_int((int)(MEMCACHED_HASH_FNV1_64)));
-  rb_define_const(mLibmemcached, "MEMCACHED_HASH_FNV1A_64", SWIG_From_int((int)(MEMCACHED_HASH_FNV1A_64)));
-  rb_define_const(mLibmemcached, "MEMCACHED_HASH_FNV1_32", SWIG_From_int((int)(MEMCACHED_HASH_FNV1_32)));
-  rb_define_const(mLibmemcached, "MEMCACHED_HASH_FNV1A_32", SWIG_From_int((int)(MEMCACHED_HASH_FNV1A_32)));
-  rb_define_const(mLibmemcached, "MEMCACHED_HASH_KETAMA", SWIG_From_int((int)(MEMCACHED_HASH_KETAMA)));
-  rb_define_const(mLibmemcached, "MEMCACHED_HASH_HSIEH", SWIG_From_int((int)(MEMCACHED_HASH_HSIEH)));
-  rb_define_const(mLibmemcached, "MEMCACHED_CONNECTION_UNKNOWN", SWIG_From_int((int)(MEMCACHED_CONNECTION_UNKNOWN)));
-  rb_define_const(mLibmemcached, "MEMCACHED_CONNECTION_TCP", SWIG_From_int((int)(MEMCACHED_CONNECTION_TCP)));
-  rb_define_const(mLibmemcached, "MEMCACHED_CONNECTION_UDP", SWIG_From_int((int)(MEMCACHED_CONNECTION_UDP)));
-  rb_define_const(mLibmemcached, "MEMCACHED_CONNECTION_UNIX_SOCKET", SWIG_From_int((int)(MEMCACHED_CONNECTION_UNIX_SOCKET)));
-  rb_define_const(mLibmemcached, "MEMCACHED_NOT_ALLOCATED", SWIG_From_int((int)(MEMCACHED_NOT_ALLOCATED)));
-  rb_define_const(mLibmemcached, "MEMCACHED_ALLOCATED", SWIG_From_int((int)(MEMCACHED_ALLOCATED)));
-  rb_define_const(mLibmemcached, "MEMCACHED_USED", SWIG_From_int((int)(MEMCACHED_USED)));
-  
-  cMemcachedServerSt.klass = rb_define_class_under(mLibmemcached, "MemcachedServerSt", rb_cObject);
+  rb_define_const(mRlibmemcached, "MEMCACHED_VERSION_STRING_LENGTH", SWIG_From_int((int)(12)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_DEFAULT_PORT", SWIG_From_int((int)(11211)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_MAX_KEY", SWIG_From_int((int)(251)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_MAX_BUFFER", SWIG_From_int((int)(8196)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_MAX_HOST_LENGTH", SWIG_From_int((int)(64)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_WHEEL_SIZE", SWIG_From_int((int)(1024)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_STRIDE", SWIG_From_int((int)(4)));
+  rb_define_const(mRlibmemcached, "LIBMEMCACHED_VERSION_STRING", SWIG_FromCharPtr("0.14"));
+  rb_define_const(mRlibmemcached, "MEMCACHED_SUCCESS", SWIG_From_int((int)(MEMCACHED_SUCCESS)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_FAILURE", SWIG_From_int((int)(MEMCACHED_FAILURE)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_HOST_LOOKUP_FAILURE", SWIG_From_int((int)(MEMCACHED_HOST_LOOKUP_FAILURE)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_CONNECTION_FAILURE", SWIG_From_int((int)(MEMCACHED_CONNECTION_FAILURE)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_CONNECTION_BIND_FAILURE", SWIG_From_int((int)(MEMCACHED_CONNECTION_BIND_FAILURE)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_WRITE_FAILURE", SWIG_From_int((int)(MEMCACHED_WRITE_FAILURE)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_READ_FAILURE", SWIG_From_int((int)(MEMCACHED_READ_FAILURE)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_UNKNOWN_READ_FAILURE", SWIG_From_int((int)(MEMCACHED_UNKNOWN_READ_FAILURE)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_PROTOCOL_ERROR", SWIG_From_int((int)(MEMCACHED_PROTOCOL_ERROR)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_CLIENT_ERROR", SWIG_From_int((int)(MEMCACHED_CLIENT_ERROR)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_SERVER_ERROR", SWIG_From_int((int)(MEMCACHED_SERVER_ERROR)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_CONNECTION_SOCKET_CREATE_FAILURE", SWIG_From_int((int)(MEMCACHED_CONNECTION_SOCKET_CREATE_FAILURE)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_DATA_EXISTS", SWIG_From_int((int)(MEMCACHED_DATA_EXISTS)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_DATA_DOES_NOT_EXIST", SWIG_From_int((int)(MEMCACHED_DATA_DOES_NOT_EXIST)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_NOTSTORED", SWIG_From_int((int)(MEMCACHED_NOTSTORED)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_STORED", SWIG_From_int((int)(MEMCACHED_STORED)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_NOTFOUND", SWIG_From_int((int)(MEMCACHED_NOTFOUND)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_MEMORY_ALLOCATION_FAILURE", SWIG_From_int((int)(MEMCACHED_MEMORY_ALLOCATION_FAILURE)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_PARTIAL_READ", SWIG_From_int((int)(MEMCACHED_PARTIAL_READ)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_SOME_ERRORS", SWIG_From_int((int)(MEMCACHED_SOME_ERRORS)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_NO_SERVERS", SWIG_From_int((int)(MEMCACHED_NO_SERVERS)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_END", SWIG_From_int((int)(MEMCACHED_END)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_DELETED", SWIG_From_int((int)(MEMCACHED_DELETED)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_VALUE", SWIG_From_int((int)(MEMCACHED_VALUE)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_STAT", SWIG_From_int((int)(MEMCACHED_STAT)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_ERRNO", SWIG_From_int((int)(MEMCACHED_ERRNO)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_FAIL_UNIX_SOCKET", SWIG_From_int((int)(MEMCACHED_FAIL_UNIX_SOCKET)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_NOT_SUPPORTED", SWIG_From_int((int)(MEMCACHED_NOT_SUPPORTED)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_NO_KEY_PROVIDED", SWIG_From_int((int)(MEMCACHED_NO_KEY_PROVIDED)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_FETCH_NOTFINISHED", SWIG_From_int((int)(MEMCACHED_FETCH_NOTFINISHED)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_TIMEOUT", SWIG_From_int((int)(MEMCACHED_TIMEOUT)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_BUFFERED", SWIG_From_int((int)(MEMCACHED_BUFFERED)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_MAXIMUM_RETURN", SWIG_From_int((int)(MEMCACHED_MAXIMUM_RETURN)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_DISTRIBUTION_MODULA", SWIG_From_int((int)(MEMCACHED_DISTRIBUTION_MODULA)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_DISTRIBUTION_CONSISTENT", SWIG_From_int((int)(MEMCACHED_DISTRIBUTION_CONSISTENT)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_BEHAVIOR_NO_BLOCK", SWIG_From_int((int)(MEMCACHED_BEHAVIOR_NO_BLOCK)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_BEHAVIOR_TCP_NODELAY", SWIG_From_int((int)(MEMCACHED_BEHAVIOR_TCP_NODELAY)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_BEHAVIOR_HASH", SWIG_From_int((int)(MEMCACHED_BEHAVIOR_HASH)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_BEHAVIOR_KETAMA", SWIG_From_int((int)(MEMCACHED_BEHAVIOR_KETAMA)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE", SWIG_From_int((int)(MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE", SWIG_From_int((int)(MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_BEHAVIOR_CACHE_LOOKUPS", SWIG_From_int((int)(MEMCACHED_BEHAVIOR_CACHE_LOOKUPS)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_BEHAVIOR_SUPPORT_CAS", SWIG_From_int((int)(MEMCACHED_BEHAVIOR_SUPPORT_CAS)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_BEHAVIOR_POLL_TIMEOUT", SWIG_From_int((int)(MEMCACHED_BEHAVIOR_POLL_TIMEOUT)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_BEHAVIOR_DISTRIBUTION", SWIG_From_int((int)(MEMCACHED_BEHAVIOR_DISTRIBUTION)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_BEHAVIOR_BUFFER_REQUESTS", SWIG_From_int((int)(MEMCACHED_BEHAVIOR_BUFFER_REQUESTS)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_BEHAVIOR_USER_DATA", SWIG_From_int((int)(MEMCACHED_BEHAVIOR_USER_DATA)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_CALLBACK_USER_DATA", SWIG_From_int((int)(MEMCACHED_CALLBACK_USER_DATA)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_CALLBACK_CLEANUP_FUNCTION", SWIG_From_int((int)(MEMCACHED_CALLBACK_CLEANUP_FUNCTION)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_CALLBACK_CLONE_FUNCTION", SWIG_From_int((int)(MEMCACHED_CALLBACK_CLONE_FUNCTION)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_CALLBACK_MALLOC_FUNCTION", SWIG_From_int((int)(MEMCACHED_CALLBACK_MALLOC_FUNCTION)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_CALLBACK_REALLOC_FUNCTION", SWIG_From_int((int)(MEMCACHED_CALLBACK_REALLOC_FUNCTION)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_CALLBACK_FREE_FUNCTION", SWIG_From_int((int)(MEMCACHED_CALLBACK_FREE_FUNCTION)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_HASH_DEFAULT", SWIG_From_int((int)(MEMCACHED_HASH_DEFAULT)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_HASH_MD5", SWIG_From_int((int)(MEMCACHED_HASH_MD5)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_HASH_CRC", SWIG_From_int((int)(MEMCACHED_HASH_CRC)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_HASH_FNV1_64", SWIG_From_int((int)(MEMCACHED_HASH_FNV1_64)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_HASH_FNV1A_64", SWIG_From_int((int)(MEMCACHED_HASH_FNV1A_64)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_HASH_FNV1_32", SWIG_From_int((int)(MEMCACHED_HASH_FNV1_32)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_HASH_FNV1A_32", SWIG_From_int((int)(MEMCACHED_HASH_FNV1A_32)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_HASH_KETAMA", SWIG_From_int((int)(MEMCACHED_HASH_KETAMA)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_HASH_HSIEH", SWIG_From_int((int)(MEMCACHED_HASH_HSIEH)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_CONNECTION_UNKNOWN", SWIG_From_int((int)(MEMCACHED_CONNECTION_UNKNOWN)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_CONNECTION_TCP", SWIG_From_int((int)(MEMCACHED_CONNECTION_TCP)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_CONNECTION_UDP", SWIG_From_int((int)(MEMCACHED_CONNECTION_UDP)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_CONNECTION_UNIX_SOCKET", SWIG_From_int((int)(MEMCACHED_CONNECTION_UNIX_SOCKET)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_NOT_ALLOCATED", SWIG_From_int((int)(MEMCACHED_NOT_ALLOCATED)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_ALLOCATED", SWIG_From_int((int)(MEMCACHED_ALLOCATED)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_USED", SWIG_From_int((int)(MEMCACHED_USED)));
+  
+  cMemcachedServerSt.klass = rb_define_class_under(mRlibmemcached, "MemcachedServerSt", rb_cObject);
   SWIG_TypeClientData(SWIGTYPE_p_memcached_server_st, (void *) &cMemcachedServerSt);
   rb_define_alloc_func(cMemcachedServerSt.klass, _wrap_MemcachedServerSt_allocate);
   rb_define_method(cMemcachedServerSt.klass, "initialize", _wrap_new_MemcachedServerSt, -1);
@@ -9071,14 +9364,14 @@ SWIGEXPORT void Init_libmemcached(void) {
   rb_define_method(cMemcachedServerSt.klass, "port", _wrap_MemcachedServerSt_port_get, -1);
   rb_define_method(cMemcachedServerSt.klass, "fd=", _wrap_MemcachedServerSt_fd_set, -1);
   rb_define_method(cMemcachedServerSt.klass, "fd", _wrap_MemcachedServerSt_fd_get, -1);
+  rb_define_method(cMemcachedServerSt.klass, "cached_errno=", _wrap_MemcachedServerSt_cached_errno_set, -1);
+  rb_define_method(cMemcachedServerSt.klass, "cached_errno", _wrap_MemcachedServerSt_cached_errno_get, -1);
   rb_define_method(cMemcachedServerSt.klass, "cursor_active=", _wrap_MemcachedServerSt_cursor_active_set, -1);
   rb_define_method(cMemcachedServerSt.klass, "cursor_active", _wrap_MemcachedServerSt_cursor_active_get, -1);
   rb_define_method(cMemcachedServerSt.klass, "write_buffer=", _wrap_MemcachedServerSt_write_buffer_set, -1);
   rb_define_method(cMemcachedServerSt.klass, "write_buffer", _wrap_MemcachedServerSt_write_buffer_get, -1);
   rb_define_method(cMemcachedServerSt.klass, "write_buffer_offset=", _wrap_MemcachedServerSt_write_buffer_offset_set, -1);
   rb_define_method(cMemcachedServerSt.klass, "write_buffer_offset", _wrap_MemcachedServerSt_write_buffer_offset_get, -1);
-  rb_define_method(cMemcachedServerSt.klass, "write_ptr=", _wrap_MemcachedServerSt_write_ptr_set, -1);
-  rb_define_method(cMemcachedServerSt.klass, "write_ptr", _wrap_MemcachedServerSt_write_ptr_get, -1);
   rb_define_method(cMemcachedServerSt.klass, "read_buffer=", _wrap_MemcachedServerSt_read_buffer_set, -1);
   rb_define_method(cMemcachedServerSt.klass, "read_buffer", _wrap_MemcachedServerSt_read_buffer_get, -1);
   rb_define_method(cMemcachedServerSt.klass, "read_data_length=", _wrap_MemcachedServerSt_read_data_length_set, -1);
@@ -9101,11 +9394,13 @@ SWIGEXPORT void Init_libmemcached(void) {
   rb_define_method(cMemcachedServerSt.klass, "micro_version", _wrap_MemcachedServerSt_micro_version_get, -1);
   rb_define_method(cMemcachedServerSt.klass, "count=", _wrap_MemcachedServerSt_count_set, -1);
   rb_define_method(cMemcachedServerSt.klass, "count", _wrap_MemcachedServerSt_count_get, -1);
+  rb_define_method(cMemcachedServerSt.klass, "root=", _wrap_MemcachedServerSt_root_set, -1);
+  rb_define_method(cMemcachedServerSt.klass, "root", _wrap_MemcachedServerSt_root_get, -1);
   cMemcachedServerSt.mark = 0;
   cMemcachedServerSt.destroy = (void (*)(void *)) free_memcached_server_st;
   cMemcachedServerSt.trackObjects = 0;
   
-  cMemcachedStatSt.klass = rb_define_class_under(mLibmemcached, "MemcachedStatSt", rb_cObject);
+  cMemcachedStatSt.klass = rb_define_class_under(mRlibmemcached, "MemcachedStatSt", rb_cObject);
   SWIG_TypeClientData(SWIGTYPE_p_memcached_stat_st, (void *) &cMemcachedStatSt);
   rb_define_alloc_func(cMemcachedStatSt.klass, _wrap_MemcachedStatSt_allocate);
   rb_define_method(cMemcachedStatSt.klass, "initialize", _wrap_new_MemcachedStatSt, -1);
@@ -9161,7 +9456,7 @@ SWIGEXPORT void Init_libmemcached(void) {
   cMemcachedStatSt.destroy = (void (*)(void *)) free_memcached_stat_st;
   cMemcachedStatSt.trackObjects = 0;
   
-  cMemcachedStringSt.klass = rb_define_class_under(mLibmemcached, "MemcachedStringSt", rb_cObject);
+  cMemcachedStringSt.klass = rb_define_class_under(mRlibmemcached, "MemcachedStringSt", rb_cObject);
   SWIG_TypeClientData(SWIGTYPE_p_memcached_string_st, (void *) &cMemcachedStringSt);
   rb_define_alloc_func(cMemcachedStringSt.klass, _wrap_MemcachedStringSt_allocate);
   rb_define_method(cMemcachedStringSt.klass, "initialize", _wrap_new_MemcachedStringSt, -1);
@@ -9181,7 +9476,7 @@ SWIGEXPORT void Init_libmemcached(void) {
   cMemcachedStringSt.destroy = (void (*)(void *)) free_memcached_string_st;
   cMemcachedStringSt.trackObjects = 0;
   
-  cMemcachedResultSt.klass = rb_define_class_under(mLibmemcached, "MemcachedResultSt", rb_cObject);
+  cMemcachedResultSt.klass = rb_define_class_under(mRlibmemcached, "MemcachedResultSt", rb_cObject);
   SWIG_TypeClientData(SWIGTYPE_p_memcached_result_st, (void *) &cMemcachedResultSt);
   rb_define_alloc_func(cMemcachedResultSt.klass, _wrap_MemcachedResultSt_allocate);
   rb_define_method(cMemcachedResultSt.klass, "initialize", _wrap_new_MemcachedResultSt, -1);
@@ -9203,7 +9498,7 @@ SWIGEXPORT void Init_libmemcached(void) {
   cMemcachedResultSt.destroy = (void (*)(void *)) free_memcached_result_st;
   cMemcachedResultSt.trackObjects = 0;
   
-  cMemcachedSt.klass = rb_define_class_under(mLibmemcached, "MemcachedSt", rb_cObject);
+  cMemcachedSt.klass = rb_define_class_under(mRlibmemcached, "MemcachedSt", rb_cObject);
   SWIG_TypeClientData(SWIGTYPE_p_memcached_st, (void *) &cMemcachedSt);
   rb_define_alloc_func(cMemcachedSt.klass, _wrap_MemcachedSt_allocate);
   rb_define_method(cMemcachedSt.klass, "initialize", _wrap_new_MemcachedSt, -1);
@@ -9215,8 +9510,6 @@ SWIGEXPORT void Init_libmemcached(void) {
   rb_define_method(cMemcachedSt.klass, "number_of_hosts", _wrap_MemcachedSt_number_of_hosts_get, -1);
   rb_define_method(cMemcachedSt.klass, "cursor_server=", _wrap_MemcachedSt_cursor_server_set, -1);
   rb_define_method(cMemcachedSt.klass, "cursor_server", _wrap_MemcachedSt_cursor_server_get, -1);
-  rb_define_method(cMemcachedSt.klass, "connected=", _wrap_MemcachedSt_connected_set, -1);
-  rb_define_method(cMemcachedSt.klass, "connected", _wrap_MemcachedSt_connected_get, -1);
   rb_define_method(cMemcachedSt.klass, "cached_errno=", _wrap_MemcachedSt_cached_errno_set, -1);
   rb_define_method(cMemcachedSt.klass, "cached_errno", _wrap_MemcachedSt_cached_errno_get, -1);
   rb_define_method(cMemcachedSt.klass, "flags=", _wrap_MemcachedSt_flags_set, -1);
@@ -9237,63 +9530,75 @@ SWIGEXPORT void Init_libmemcached(void) {
   rb_define_method(cMemcachedSt.klass, "user_data", _wrap_MemcachedSt_user_data_get, -1);
   rb_define_method(cMemcachedSt.klass, "wheel=", _wrap_MemcachedSt_wheel_set, -1);
   rb_define_method(cMemcachedSt.klass, "wheel", _wrap_MemcachedSt_wheel_get, -1);
+  rb_define_method(cMemcachedSt.klass, "on_clone=", _wrap_MemcachedSt_on_clone_set, -1);
+  rb_define_method(cMemcachedSt.klass, "on_clone", _wrap_MemcachedSt_on_clone_get, -1);
+  rb_define_method(cMemcachedSt.klass, "on_cleanup=", _wrap_MemcachedSt_on_cleanup_set, -1);
+  rb_define_method(cMemcachedSt.klass, "on_cleanup", _wrap_MemcachedSt_on_cleanup_get, -1);
+  rb_define_method(cMemcachedSt.klass, "call_free=", _wrap_MemcachedSt_call_free_set, -1);
+  rb_define_method(cMemcachedSt.klass, "call_free", _wrap_MemcachedSt_call_free_get, -1);
+  rb_define_method(cMemcachedSt.klass, "call_malloc=", _wrap_MemcachedSt_call_malloc_set, -1);
+  rb_define_method(cMemcachedSt.klass, "call_malloc", _wrap_MemcachedSt_call_malloc_get, -1);
+  rb_define_method(cMemcachedSt.klass, "call_realloc=", _wrap_MemcachedSt_call_realloc_set, -1);
+  rb_define_method(cMemcachedSt.klass, "call_realloc", _wrap_MemcachedSt_call_realloc_get, -1);
   cMemcachedSt.mark = 0;
   cMemcachedSt.destroy = (void (*)(void *)) free_memcached_st;
   cMemcachedSt.trackObjects = 0;
-  rb_define_module_function(mLibmemcached, "memcached_create", _wrap_memcached_create, -1);
-  rb_define_module_function(mLibmemcached, "memcached_free", _wrap_memcached_free, -1);
-  rb_define_module_function(mLibmemcached, "memcached_clone", _wrap_memcached_clone, -1);
-  rb_define_module_function(mLibmemcached, "memcached_delete", _wrap_memcached_delete, -1);
-  rb_define_module_function(mLibmemcached, "memcached_increment", _wrap_memcached_increment, -1);
-  rb_define_module_function(mLibmemcached, "memcached_decrement", _wrap_memcached_decrement, -1);
-  rb_define_module_function(mLibmemcached, "memcached_stat_free", _wrap_memcached_stat_free, -1);
-  rb_define_module_function(mLibmemcached, "memcached_stat", _wrap_memcached_stat, -1);
-  rb_define_module_function(mLibmemcached, "memcached_stat_servername", _wrap_memcached_stat_servername, -1);
-  rb_define_module_function(mLibmemcached, "memcached_flush", _wrap_memcached_flush, -1);
-  rb_define_module_function(mLibmemcached, "memcached_verbosity", _wrap_memcached_verbosity, -1);
-  rb_define_module_function(mLibmemcached, "memcached_quit", _wrap_memcached_quit, -1);
-  rb_define_module_function(mLibmemcached, "memcached_strerror", _wrap_memcached_strerror, -1);
-  rb_define_module_function(mLibmemcached, "memcached_behavior_set", _wrap_memcached_behavior_set, -1);
-  rb_define_module_function(mLibmemcached, "memcached_behavior_get", _wrap_memcached_behavior_get, -1);
-  rb_define_module_function(mLibmemcached, "memcached_set", _wrap_memcached_set, -1);
-  rb_define_module_function(mLibmemcached, "memcached_add", _wrap_memcached_add, -1);
-  rb_define_module_function(mLibmemcached, "memcached_replace", _wrap_memcached_replace, -1);
-  rb_define_module_function(mLibmemcached, "memcached_append", _wrap_memcached_append, -1);
-  rb_define_module_function(mLibmemcached, "memcached_prepend", _wrap_memcached_prepend, -1);
-  rb_define_module_function(mLibmemcached, "memcached_cas", _wrap_memcached_cas, -1);
-  rb_define_module_function(mLibmemcached, "memcached_get", _wrap_memcached_get, -1);
-  rb_define_module_function(mLibmemcached, "memcached_mget", _wrap_memcached_mget, -1);
-  rb_define_module_function(mLibmemcached, "memcached_fetch", _wrap_memcached_fetch, -1);
-  rb_define_module_function(mLibmemcached, "memcached_fetch_result", _wrap_memcached_fetch_result, -1);
-  rb_define_module_function(mLibmemcached, "memcached_server_add_udp", _wrap_memcached_server_add_udp, -1);
-  rb_define_module_function(mLibmemcached, "memcached_server_add_unix_socket", _wrap_memcached_server_add_unix_socket, -1);
-  rb_define_module_function(mLibmemcached, "memcached_server_add", _wrap_memcached_server_add, -1);
-  rb_define_module_function(mLibmemcached, "memcached_server_list_free", _wrap_memcached_server_list_free, -1);
-  rb_define_module_function(mLibmemcached, "memcached_server_push", _wrap_memcached_server_push, -1);
-  rb_define_module_function(mLibmemcached, "memcached_server_list_append", _wrap_memcached_server_list_append, -1);
-  rb_define_module_function(mLibmemcached, "memcached_server_list_count", _wrap_memcached_server_list_count, -1);
-  rb_define_module_function(mLibmemcached, "memcached_servers_parse", _wrap_memcached_servers_parse, -1);
-  rb_define_module_function(mLibmemcached, "memcached_stat_get_value", _wrap_memcached_stat_get_value, -1);
-  rb_define_module_function(mLibmemcached, "memcached_stat_get_keys", _wrap_memcached_stat_get_keys, -1);
-  rb_define_module_function(mLibmemcached, "memcached_get_by_key", _wrap_memcached_get_by_key, -1);
-  rb_define_module_function(mLibmemcached, "memcached_mget_by_key", _wrap_memcached_mget_by_key, -1);
-  rb_define_module_function(mLibmemcached, "memcached_set_by_key", _wrap_memcached_set_by_key, -1);
-  rb_define_module_function(mLibmemcached, "memcached_add_by_key", _wrap_memcached_add_by_key, -1);
-  rb_define_module_function(mLibmemcached, "memcached_replace_by_key", _wrap_memcached_replace_by_key, -1);
-  rb_define_module_function(mLibmemcached, "memcached_prepend_by_key", _wrap_memcached_prepend_by_key, -1);
-  rb_define_module_function(mLibmemcached, "memcached_append_by_key", _wrap_memcached_append_by_key, -1);
-  rb_define_module_function(mLibmemcached, "memcached_cas_by_key", _wrap_memcached_cas_by_key, -1);
-  rb_define_module_function(mLibmemcached, "memcached_delete_by_key", _wrap_memcached_delete_by_key, -1);
-  rb_define_module_function(mLibmemcached, "memcached_mdelete", _wrap_memcached_mdelete, -1);
-  rb_define_module_function(mLibmemcached, "memcached_mdelete_by_key", _wrap_memcached_mdelete_by_key, -1);
-  rb_define_module_function(mLibmemcached, "memcached_fetch_execute", _wrap_memcached_fetch_execute, -1);
-  rb_define_module_function(mLibmemcached, "memcached_result_free", _wrap_memcached_result_free, -1);
-  rb_define_module_function(mLibmemcached, "memcached_result_create", _wrap_memcached_result_create, -1);
-  rb_define_module_function(mLibmemcached, "memcached_result_value", _wrap_memcached_result_value, -1);
-  rb_define_module_function(mLibmemcached, "memcached_result_length", _wrap_memcached_result_length, -1);
-  rb_define_module_function(mLibmemcached, "memcached_get_ruby_string", _wrap_memcached_get_ruby_string, -1);
-  rb_define_module_function(mLibmemcached, "memcached_select_server_at", _wrap_memcached_select_server_at, -1);
-  rb_define_module_function(mLibmemcached, "memcached_select_stat_at", _wrap_memcached_select_stat_at, -1);
-  rb_define_module_function(mLibmemcached, "memcached_repair_server_st", _wrap_memcached_repair_server_st, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_lib_version", _wrap_memcached_lib_version, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_create", _wrap_memcached_create, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_free", _wrap_memcached_free, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_clone", _wrap_memcached_clone, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_delete", _wrap_memcached_delete, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_increment", _wrap_memcached_increment, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_decrement", _wrap_memcached_decrement, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_stat_free", _wrap_memcached_stat_free, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_stat", _wrap_memcached_stat, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_stat_servername", _wrap_memcached_stat_servername, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_flush", _wrap_memcached_flush, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_verbosity", _wrap_memcached_verbosity, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_quit", _wrap_memcached_quit, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_strerror", _wrap_memcached_strerror, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_behavior_set", _wrap_memcached_behavior_set, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_behavior_get", _wrap_memcached_behavior_get, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_set", _wrap_memcached_set, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_add", _wrap_memcached_add, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_replace", _wrap_memcached_replace, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_append", _wrap_memcached_append, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_prepend", _wrap_memcached_prepend, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_cas", _wrap_memcached_cas, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_get", _wrap_memcached_get, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_mget", _wrap_memcached_mget, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_fetch", _wrap_memcached_fetch, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_fetch_result", _wrap_memcached_fetch_result, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_server_add_udp", _wrap_memcached_server_add_udp, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_server_add_unix_socket", _wrap_memcached_server_add_unix_socket, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_server_add", _wrap_memcached_server_add, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_server_list_free", _wrap_memcached_server_list_free, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_server_push", _wrap_memcached_server_push, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_server_list_append", _wrap_memcached_server_list_append, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_server_list_count", _wrap_memcached_server_list_count, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_servers_parse", _wrap_memcached_servers_parse, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_stat_get_value", _wrap_memcached_stat_get_value, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_stat_get_keys", _wrap_memcached_stat_get_keys, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_get_by_key", _wrap_memcached_get_by_key, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_mget_by_key", _wrap_memcached_mget_by_key, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_set_by_key", _wrap_memcached_set_by_key, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_add_by_key", _wrap_memcached_add_by_key, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_replace_by_key", _wrap_memcached_replace_by_key, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_prepend_by_key", _wrap_memcached_prepend_by_key, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_append_by_key", _wrap_memcached_append_by_key, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_cas_by_key", _wrap_memcached_cas_by_key, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_delete_by_key", _wrap_memcached_delete_by_key, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_fetch_execute", _wrap_memcached_fetch_execute, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_callback_set", _wrap_memcached_callback_set, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_callback_get", _wrap_memcached_callback_get, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_result_free", _wrap_memcached_result_free, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_result_create", _wrap_memcached_result_create, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_result_value", _wrap_memcached_result_value, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_result_length", _wrap_memcached_result_length, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_get_rvalue", _wrap_memcached_get_rvalue, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_fetch_rvalue", _wrap_memcached_fetch_rvalue, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_stat_get_rvalue", _wrap_memcached_stat_get_rvalue, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_select_server_at", _wrap_memcached_select_server_at, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_select_stat_at", _wrap_memcached_select_stat_at, -1);
 }