memcached 0.17 → 0.17.1

data/CHANGELOG

@@ -1,4 +1,6 @@
 
+v0.17.1. Ruby 1.9 compatibility.
+
 v0.17. Update to libmemcached 0.32. Update Darwin version string for Snow Leopard final. Improve benchmarks. Add Memcached::Rails#append and #prepend, alias all original Memcached methods to _orig, and add set_servers= accessor for compatibility.
 
 v0.16.3. Optimize append/prepend on miss.

data/README

@@ -22,7 +22,7 @@ The <b>memcached</b> library wraps the pure-C libmemcached client via SWIG.
 
 == Installation
 
-You need Ruby 1.8.6. Other versions are not guaranteed to work. You also need {memcached itself}[http://www.danga.com/memcached/] if you want to test against a local server.
+You need Ruby 1.8.7 or Ruby 1.9.1. Other versions may work, but are not guaranteed. You also need {memcached itself}[http://www.danga.com/memcached/] if you want to test against a local server.
 
 Install the gem:
   sudo gem install memcached --no-rdoc --no-ri

data/ext/rlibmemcached_wrap.c

@@ -1,6 +1,6 @@
 /* ----------------------------------------------------------------------------
  * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 1.3.36
+ * Version 1.3.40
  * 
  * This file is not intended to be easily readable and contains a number of 
  * coding conventions designed to improve portability and efficiency. Do not make
@@ -9,6 +9,7 @@
  * ----------------------------------------------------------------------------- */
 
 #define SWIGRUBY
+
 /* -----------------------------------------------------------------------------
  *  This section contains generic SWIG labels for method/variable
  *  declarations/attributes, and other compiler dependent labels.
@@ -230,7 +231,7 @@
 /* -----------------------------------------------------------------------------
  * swigrun.swg
  *
- * This file contains generic CAPI SWIG runtime support for pointer
+ * This file contains generic C API SWIG runtime support for pointer
  * type checking.
  * ----------------------------------------------------------------------------- */
 
@@ -249,11 +250,11 @@
 
 /*
   You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
-  creating a static or dynamic library from the swig runtime code.
-  In 99.9% of the cases, swig just needs to declare them as 'static'.
+  creating a static or dynamic library from the SWIG runtime code.
+  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
   
-  But only do this if is strictly necessary, ie, if you have problems
-  with your compiler or so.
+  But only do this if strictly necessary, ie, if you have problems
+  with your compiler or suchlike.
 */
 
 #ifndef SWIGRUNTIME
@@ -280,14 +281,14 @@
 /* 
    Flags/methods for returning states.
    
-   The swig conversion methods, as ConvertPtr, return and integer 
+   The SWIG conversion methods, as ConvertPtr, return and integer 
    that tells if the conversion was successful or not. And if not,
    an error code can be returned (see swigerrors.swg for the codes).
    
    Use the following macros/flags to set or process the returning
    states.
    
-   In old swig versions, you usually write code as:
+   In old versions of SWIG, code such as the following was usually written:
 
      if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
        // success code
@@ -295,7 +296,7 @@
        //fail code
      }
 
-   Now you can be more explicit as:
+   Now you can be more explicit:
 
     int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
     if (SWIG_IsOK(res)) {
@@ -304,7 +305,7 @@
       // fail code
     }
 
-   that seems to be the same, but now you can also do
+   which is the same really, but now you can also do
 
     Type *ptr;
     int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
@@ -322,7 +323,7 @@
     
    I.e., now SWIG_ConvertPtr can return new objects and you can
    identify the case and take care of the deallocation. Of course that
-   requires also to SWIG_ConvertPtr to return new result values, as
+   also requires SWIG_ConvertPtr to return new result values, such as
 
       int SWIG_ConvertPtr(obj, ptr,...) {         
         if (<obj is ok>) {			       
@@ -340,7 +341,7 @@
 
    Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
    more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
-   swig errors code.
+   SWIG errors code.
 
    Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
    allows to return the 'cast rank', for example, if you have this
@@ -354,9 +355,8 @@
       fooi(1)   // cast rank '0'
 
    just use the SWIG_AddCast()/SWIG_CheckState()
+*/
 
-
- */
 #define SWIG_OK                    (0) 
 #define SWIG_ERROR                 (-1)
 #define SWIG_IsOK(r)               (r >= 0)
@@ -381,7 +381,6 @@
 #define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
 #define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
 
-
 /* Cast-Rank Mode */
 #if defined(SWIG_CASTRANK_MODE)
 #  ifndef SWIG_TypeRank
@@ -404,8 +403,6 @@ SWIGINTERNINLINE int SWIG_CheckState(int r) {
 #endif
 
 
-
-
 #include <string.h>
 
 #ifdef __cplusplus
@@ -502,40 +499,58 @@ SWIG_TypeCompare(const char *nb, const char *tb) {
 }
 
 
-/* think of this as a c++ template<> or a scheme macro */
-#define SWIG_TypeCheck_Template(comparison, ty)         \
-  if (ty) {                                             \
-    swig_cast_info *iter = ty->cast;                    \
-    while (iter) {                                      \
-      if (comparison) {                                 \
-        if (iter == ty->cast) return iter;              \
-        /* Move iter to the top of the linked list */   \
-        iter->prev->next = iter->next;                  \
-        if (iter->next)                                 \
-          iter->next->prev = iter->prev;                \
-        iter->next = ty->cast;                          \
-        iter->prev = 0;                                 \
-        if (ty->cast) ty->cast->prev = iter;            \
-        ty->cast = iter;                                \
-        return iter;                                    \
-      }                                                 \
-      iter = iter->next;                                \
-    }                                                   \
-  }                                                     \
-  return 0
-
 /*
   Check the typename
 */
 SWIGRUNTIME swig_cast_info *
 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
-  SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if (strcmp(iter->type->name, c) == 0) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
 }
 
-/* Same as previous function, except strcmp is replaced with a pointer comparison */
+/* 
+  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
+*/
 SWIGRUNTIME swig_cast_info *
-SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
-  SWIG_TypeCheck_Template(iter->type == from, into);
+SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if (iter->type == from) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
 }
 
 /*
@@ -823,6 +838,15 @@ SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
 #ifdef read
 # undef read
 #endif
+#ifdef bind
+# undef bind
+#endif
+#ifdef close
+# undef close
+#endif
+#ifdef connect
+# undef connect
+#endif
 
 
 /* Ruby 1.7 defines NUM2LL(), LL2NUM() and ULL2NUM() macros */
@@ -1811,7 +1835,7 @@ static VALUE mRlibmemcached;
 #define SWIG_RUBY_THREAD_END_BLOCK
 
 
-#define SWIGVERSION 0x010336 
+#define SWIGVERSION 0x010340 
 #define SWIG_VERSION SWIGVERSION
 
 
@@ -1826,7 +1850,14 @@ static VALUE mRlibmemcached;
 #ifdef __cplusplus
 extern "C" {
 #endif
+
+// Ruby 1.9 changed the file name of this header
+#ifdef HAVE_RUBY_IO_H
+#include "ruby/io.h"
+#else
 #include "rubyio.h"
+#endif
+
 #ifdef __cplusplus
 }
 #endif
@@ -1908,13 +1939,13 @@ SWIG_ruby_failed(void)
 } 
 
 
-/*@SWIG:/opt/local/share/swig/1.3.36/ruby/rubyprimtypes.swg,23,%ruby_aux_method@*/
+/*@SWIG:/opt/local/share/swig/1.3.40/ruby/rubyprimtypes.swg,23,%ruby_aux_method@*/
 SWIGINTERN VALUE SWIG_AUX_NUM2DBL(VALUE *args)
 {
   VALUE obj = args[0];
   VALUE type = TYPE(obj);
   double *res = (double *)(args[1]);
-  *res = (type == T_FLOAT ? NUM2DBL(obj) : (type == T_FIXNUM ? (double) FIX2INT(obj) : rb_big2dbl(obj)));
+  *res = NUM2DBL(obj);
   return obj;
 }
 /*@SWIG@*/
@@ -2002,7 +2033,7 @@ SWIG_AsCharArray(VALUE obj, char *val, size_t size)
 }
 
 
-/*@SWIG:/opt/local/share/swig/1.3.36/ruby/rubyprimtypes.swg,23,%ruby_aux_method@*/
+/*@SWIG:/opt/local/share/swig/1.3.40/ruby/rubyprimtypes.swg,23,%ruby_aux_method@*/
 SWIGINTERN VALUE SWIG_AUX_NUM2ULONG(VALUE *args)
 {
   VALUE obj = args[0];
@@ -2061,7 +2092,7 @@ SWIG_From_unsigned_SS_short  (unsigned short value)
 }
 
 
-/*@SWIG:/opt/local/share/swig/1.3.36/ruby/rubyprimtypes.swg,23,%ruby_aux_method@*/
+/*@SWIG:/opt/local/share/swig/1.3.40/ruby/rubyprimtypes.swg,23,%ruby_aux_method@*/
 SWIGINTERN VALUE SWIG_AUX_NUM2LONG(VALUE *args)
 {
   VALUE obj = args[0];
@@ -2183,7 +2214,7 @@ SWIG_AsVal_unsigned_SS_int (VALUE obj, unsigned int *val)
 }
 
 
-/*@SWIG:/opt/local/share/swig/1.3.36/ruby/rubyprimtypes.swg,23,%ruby_aux_method@*/
+/*@SWIG:/opt/local/share/swig/1.3.40/ruby/rubyprimtypes.swg,23,%ruby_aux_method@*/
 SWIGINTERN VALUE SWIG_AUX_NUM2ULL(VALUE *args)
 {
   VALUE obj = args[0];
@@ -2269,7 +2300,7 @@ VALUE memcached_generate_hash_rvalue(const char *key, size_t key_length,memcache
   return UINT2NUM(memcached_generate_hash_value(key, key_length, hash_algorithm));
 };
 
-swig_class cMemcachedAnalysisSt;
+swig_class SwigClassMemcachedAnalysisSt;
 
 SWIGINTERN VALUE
 _wrap_MemcachedAnalysisSt_average_item_size_set(int argc, VALUE *argv, VALUE self) {
@@ -2788,7 +2819,7 @@ free_memcached_analysis_st(struct memcached_analysis_st *arg1) {
     free((char *) arg1);
 }
 
-swig_class cMemcachedStatSt;
+swig_class SwigClassMemcachedStatSt;
 
 SWIGINTERN VALUE
 _wrap_MemcachedStatSt_connection_structures_set(int argc, VALUE *argv, VALUE self) {
@@ -4290,7 +4321,7 @@ free_memcached_stat_st(struct memcached_stat_st *arg1) {
     free((char *) arg1);
 }
 
-swig_class cMemcachedSt;
+swig_class SwigClassMemcachedSt;
 
 SWIGINTERN VALUE
 _wrap_MemcachedSt_purging_set(int argc, VALUE *argv, VALUE self) {
@@ -6486,6 +6517,181 @@ fail:
 }
 
 
+SWIGINTERN VALUE
+_wrap_MemcachedSt_number_of_live_hosts_set(int argc, VALUE *argv, VALUE self) {
+  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
+  uint32_t arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  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_st, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","number_of_live_hosts", 1, self )); 
+  }
+  arg1 = (struct memcached_st *)(argp1);
+  {
+    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_uint32_t,  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "uint32_t","number_of_live_hosts", 2, argv[0] )); 
+    }  
+    if (!argp2) {
+      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "uint32_t","number_of_live_hosts", 2, argv[0]));
+    } else {
+      arg2 = *((uint32_t *)(argp2));
+    }
+  }
+  if (arg1) (arg1)->number_of_live_hosts = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_MemcachedSt_number_of_live_hosts_get(int argc, VALUE *argv, VALUE self) {
+  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  uint32_t result;
+  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), Ruby_Format_TypeError( "", "struct memcached_st *","number_of_live_hosts", 1, self )); 
+  }
+  arg1 = (struct memcached_st *)(argp1);
+  result =  ((arg1)->number_of_live_hosts);
+  {
+    vresult = UINT2NUM(result);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_MemcachedSt_live_host_indices_set(int argc, VALUE *argv, VALUE self) {
+  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
+  uint32_t *arg2 = (uint32_t *) 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_st, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","live_host_indices", 1, self )); 
+  }
+  arg1 = (struct memcached_st *)(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_uint32_t, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "uint32_t *","live_host_indices", 2, argv[0] )); 
+  }
+  arg2 = (uint32_t *)(argp2);
+  if (arg1) (arg1)->live_host_indices = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_MemcachedSt_live_host_indices_get(int argc, VALUE *argv, VALUE self) {
+  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  uint32_t *result = 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), Ruby_Format_TypeError( "", "struct memcached_st *","live_host_indices", 1, self )); 
+  }
+  arg1 = (struct memcached_st *)(argp1);
+  result = (uint32_t *) ((arg1)->live_host_indices);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_uint32_t, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_MemcachedSt_live_host_indices_size_set(int argc, VALUE *argv, VALUE self) {
+  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
+  uint32_t arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  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_st, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","live_host_indices_size", 1, self )); 
+  }
+  arg1 = (struct memcached_st *)(argp1);
+  {
+    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_uint32_t,  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "uint32_t","live_host_indices_size", 2, argv[0] )); 
+    }  
+    if (!argp2) {
+      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "uint32_t","live_host_indices_size", 2, argv[0]));
+    } else {
+      arg2 = *((uint32_t *)(argp2));
+    }
+  }
+  if (arg1) (arg1)->live_host_indices_size = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_MemcachedSt_live_host_indices_size_get(int argc, VALUE *argv, VALUE self) {
+  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  uint32_t result;
+  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), Ruby_Format_TypeError( "", "struct memcached_st *","live_host_indices_size", 1, self )); 
+  }
+  arg1 = (struct memcached_st *)(argp1);
+  result =  ((arg1)->live_host_indices_size);
+  {
+    vresult = UINT2NUM(result);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
 SWIGINTERN VALUE
 _wrap_MemcachedSt_allocate(VALUE self) {
@@ -9302,7 +9508,7 @@ fail:
 }
 
 
-swig_class cMemcachedResultSt;
+swig_class SwigClassMemcachedResultSt;
 
 SWIGINTERN VALUE
 _wrap_MemcachedResultSt_flags_set(int argc, VALUE *argv, VALUE self) {
@@ -9944,7 +10150,7 @@ fail:
 }
 
 
-swig_class cMemcachedServerSt;
+swig_class SwigClassMemcachedServerSt;
 
 SWIGINTERN VALUE
 _wrap_MemcachedServerSt_is_allocated_set(int argc, VALUE *argv, VALUE self) {
@@ -12434,169 +12640,175 @@ SWIGEXPORT void Init_rlibmemcached(void) {
   rb_define_const(mRlibmemcached, "MEMCACHED_VERSION_STRING_LENGTH", SWIG_From_int((int)(24)));
   rb_define_const(mRlibmemcached, "LIBMEMCACHED_VERSION_STRING", SWIG_FromCharPtr("0.32"));
   
-  cMemcachedAnalysisSt.klass = rb_define_class_under(mRlibmemcached, "MemcachedAnalysisSt", rb_cObject);
-  SWIG_TypeClientData(SWIGTYPE_p_memcached_analysis_st, (void *) &cMemcachedAnalysisSt);
-  rb_define_alloc_func(cMemcachedAnalysisSt.klass, _wrap_MemcachedAnalysisSt_allocate);
-  rb_define_method(cMemcachedAnalysisSt.klass, "initialize", _wrap_new_MemcachedAnalysisSt, -1);
-  rb_define_method(cMemcachedAnalysisSt.klass, "average_item_size=", _wrap_MemcachedAnalysisSt_average_item_size_set, -1);
-  rb_define_method(cMemcachedAnalysisSt.klass, "average_item_size", _wrap_MemcachedAnalysisSt_average_item_size_get, -1);
-  rb_define_method(cMemcachedAnalysisSt.klass, "longest_uptime=", _wrap_MemcachedAnalysisSt_longest_uptime_set, -1);
-  rb_define_method(cMemcachedAnalysisSt.klass, "longest_uptime", _wrap_MemcachedAnalysisSt_longest_uptime_get, -1);
-  rb_define_method(cMemcachedAnalysisSt.klass, "least_free_server=", _wrap_MemcachedAnalysisSt_least_free_server_set, -1);
-  rb_define_method(cMemcachedAnalysisSt.klass, "least_free_server", _wrap_MemcachedAnalysisSt_least_free_server_get, -1);
-  rb_define_method(cMemcachedAnalysisSt.klass, "most_consumed_server=", _wrap_MemcachedAnalysisSt_most_consumed_server_set, -1);
-  rb_define_method(cMemcachedAnalysisSt.klass, "most_consumed_server", _wrap_MemcachedAnalysisSt_most_consumed_server_get, -1);
-  rb_define_method(cMemcachedAnalysisSt.klass, "oldest_server=", _wrap_MemcachedAnalysisSt_oldest_server_set, -1);
-  rb_define_method(cMemcachedAnalysisSt.klass, "oldest_server", _wrap_MemcachedAnalysisSt_oldest_server_get, -1);
-  rb_define_method(cMemcachedAnalysisSt.klass, "pool_hit_ratio=", _wrap_MemcachedAnalysisSt_pool_hit_ratio_set, -1);
-  rb_define_method(cMemcachedAnalysisSt.klass, "pool_hit_ratio", _wrap_MemcachedAnalysisSt_pool_hit_ratio_get, -1);
-  rb_define_method(cMemcachedAnalysisSt.klass, "most_used_bytes=", _wrap_MemcachedAnalysisSt_most_used_bytes_set, -1);
-  rb_define_method(cMemcachedAnalysisSt.klass, "most_used_bytes", _wrap_MemcachedAnalysisSt_most_used_bytes_get, -1);
-  rb_define_method(cMemcachedAnalysisSt.klass, "least_remaining_bytes=", _wrap_MemcachedAnalysisSt_least_remaining_bytes_set, -1);
-  rb_define_method(cMemcachedAnalysisSt.klass, "least_remaining_bytes", _wrap_MemcachedAnalysisSt_least_remaining_bytes_get, -1);
-  cMemcachedAnalysisSt.mark = 0;
-  cMemcachedAnalysisSt.destroy = (void (*)(void *)) free_memcached_analysis_st;
-  cMemcachedAnalysisSt.trackObjects = 0;
-  
-  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);
-  rb_define_method(cMemcachedStatSt.klass, "connection_structures=", _wrap_MemcachedStatSt_connection_structures_set, -1);
-  rb_define_method(cMemcachedStatSt.klass, "connection_structures", _wrap_MemcachedStatSt_connection_structures_get, -1);
-  rb_define_method(cMemcachedStatSt.klass, "curr_connections=", _wrap_MemcachedStatSt_curr_connections_set, -1);
-  rb_define_method(cMemcachedStatSt.klass, "curr_connections", _wrap_MemcachedStatSt_curr_connections_get, -1);
-  rb_define_method(cMemcachedStatSt.klass, "curr_items=", _wrap_MemcachedStatSt_curr_items_set, -1);
-  rb_define_method(cMemcachedStatSt.klass, "curr_items", _wrap_MemcachedStatSt_curr_items_get, -1);
-  rb_define_method(cMemcachedStatSt.klass, "pid=", _wrap_MemcachedStatSt_pid_set, -1);
-  rb_define_method(cMemcachedStatSt.klass, "pid", _wrap_MemcachedStatSt_pid_get, -1);
-  rb_define_method(cMemcachedStatSt.klass, "pointer_size=", _wrap_MemcachedStatSt_pointer_size_set, -1);
-  rb_define_method(cMemcachedStatSt.klass, "pointer_size", _wrap_MemcachedStatSt_pointer_size_get, -1);
-  rb_define_method(cMemcachedStatSt.klass, "rusage_system_microseconds=", _wrap_MemcachedStatSt_rusage_system_microseconds_set, -1);
-  rb_define_method(cMemcachedStatSt.klass, "rusage_system_microseconds", _wrap_MemcachedStatSt_rusage_system_microseconds_get, -1);
-  rb_define_method(cMemcachedStatSt.klass, "rusage_system_seconds=", _wrap_MemcachedStatSt_rusage_system_seconds_set, -1);
-  rb_define_method(cMemcachedStatSt.klass, "rusage_system_seconds", _wrap_MemcachedStatSt_rusage_system_seconds_get, -1);
-  rb_define_method(cMemcachedStatSt.klass, "rusage_user_microseconds=", _wrap_MemcachedStatSt_rusage_user_microseconds_set, -1);
-  rb_define_method(cMemcachedStatSt.klass, "rusage_user_microseconds", _wrap_MemcachedStatSt_rusage_user_microseconds_get, -1);
-  rb_define_method(cMemcachedStatSt.klass, "rusage_user_seconds=", _wrap_MemcachedStatSt_rusage_user_seconds_set, -1);
-  rb_define_method(cMemcachedStatSt.klass, "rusage_user_seconds", _wrap_MemcachedStatSt_rusage_user_seconds_get, -1);
-  rb_define_method(cMemcachedStatSt.klass, "threads=", _wrap_MemcachedStatSt_threads_set, -1);
-  rb_define_method(cMemcachedStatSt.klass, "threads", _wrap_MemcachedStatSt_threads_get, -1);
-  rb_define_method(cMemcachedStatSt.klass, "time=", _wrap_MemcachedStatSt_time_set, -1);
-  rb_define_method(cMemcachedStatSt.klass, "time", _wrap_MemcachedStatSt_time_get, -1);
-  rb_define_method(cMemcachedStatSt.klass, "total_connections=", _wrap_MemcachedStatSt_total_connections_set, -1);
-  rb_define_method(cMemcachedStatSt.klass, "total_connections", _wrap_MemcachedStatSt_total_connections_get, -1);
-  rb_define_method(cMemcachedStatSt.klass, "total_items=", _wrap_MemcachedStatSt_total_items_set, -1);
-  rb_define_method(cMemcachedStatSt.klass, "total_items", _wrap_MemcachedStatSt_total_items_get, -1);
-  rb_define_method(cMemcachedStatSt.klass, "uptime=", _wrap_MemcachedStatSt_uptime_set, -1);
-  rb_define_method(cMemcachedStatSt.klass, "uptime", _wrap_MemcachedStatSt_uptime_get, -1);
-  rb_define_method(cMemcachedStatSt.klass, "bytes=", _wrap_MemcachedStatSt_bytes_set, -1);
-  rb_define_method(cMemcachedStatSt.klass, "bytes", _wrap_MemcachedStatSt_bytes_get, -1);
-  rb_define_method(cMemcachedStatSt.klass, "bytes_read=", _wrap_MemcachedStatSt_bytes_read_set, -1);
-  rb_define_method(cMemcachedStatSt.klass, "bytes_read", _wrap_MemcachedStatSt_bytes_read_get, -1);
-  rb_define_method(cMemcachedStatSt.klass, "bytes_written=", _wrap_MemcachedStatSt_bytes_written_set, -1);
-  rb_define_method(cMemcachedStatSt.klass, "bytes_written", _wrap_MemcachedStatSt_bytes_written_get, -1);
-  rb_define_method(cMemcachedStatSt.klass, "cmd_get=", _wrap_MemcachedStatSt_cmd_get_set, -1);
-  rb_define_method(cMemcachedStatSt.klass, "cmd_get", _wrap_MemcachedStatSt_cmd_get_get, -1);
-  rb_define_method(cMemcachedStatSt.klass, "cmd_set=", _wrap_MemcachedStatSt_cmd_set_set, -1);
-  rb_define_method(cMemcachedStatSt.klass, "cmd_set", _wrap_MemcachedStatSt_cmd_set_get, -1);
-  rb_define_method(cMemcachedStatSt.klass, "evictions=", _wrap_MemcachedStatSt_evictions_set, -1);
-  rb_define_method(cMemcachedStatSt.klass, "evictions", _wrap_MemcachedStatSt_evictions_get, -1);
-  rb_define_method(cMemcachedStatSt.klass, "get_hits=", _wrap_MemcachedStatSt_get_hits_set, -1);
-  rb_define_method(cMemcachedStatSt.klass, "get_hits", _wrap_MemcachedStatSt_get_hits_get, -1);
-  rb_define_method(cMemcachedStatSt.klass, "get_misses=", _wrap_MemcachedStatSt_get_misses_set, -1);
-  rb_define_method(cMemcachedStatSt.klass, "get_misses", _wrap_MemcachedStatSt_get_misses_get, -1);
-  rb_define_method(cMemcachedStatSt.klass, "limit_maxbytes=", _wrap_MemcachedStatSt_limit_maxbytes_set, -1);
-  rb_define_method(cMemcachedStatSt.klass, "limit_maxbytes", _wrap_MemcachedStatSt_limit_maxbytes_get, -1);
-  rb_define_method(cMemcachedStatSt.klass, "version=", _wrap_MemcachedStatSt_version_set, -1);
-  rb_define_method(cMemcachedStatSt.klass, "version", _wrap_MemcachedStatSt_version_get, -1);
-  cMemcachedStatSt.mark = 0;
-  cMemcachedStatSt.destroy = (void (*)(void *)) free_memcached_stat_st;
-  cMemcachedStatSt.trackObjects = 0;
-  
-  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);
-  rb_define_method(cMemcachedSt.klass, "purging=", _wrap_MemcachedSt_purging_set, -1);
-  rb_define_method(cMemcachedSt.klass, "purging", _wrap_MemcachedSt_purging_get, -1);
-  rb_define_method(cMemcachedSt.klass, "is_allocated=", _wrap_MemcachedSt_is_allocated_set, -1);
-  rb_define_method(cMemcachedSt.klass, "is_allocated", _wrap_MemcachedSt_is_allocated_get, -1);
-  rb_define_method(cMemcachedSt.klass, "distribution=", _wrap_MemcachedSt_distribution_set, -1);
-  rb_define_method(cMemcachedSt.klass, "distribution", _wrap_MemcachedSt_distribution_get, -1);
-  rb_define_method(cMemcachedSt.klass, "hash=", _wrap_MemcachedSt_hash_set, -1);
-  rb_define_method(cMemcachedSt.klass, "hash", _wrap_MemcachedSt_hash_get, -1);
-  rb_define_method(cMemcachedSt.klass, "continuum_points_counter=", _wrap_MemcachedSt_continuum_points_counter_set, -1);
-  rb_define_method(cMemcachedSt.klass, "continuum_points_counter", _wrap_MemcachedSt_continuum_points_counter_get, -1);
-  rb_define_method(cMemcachedSt.klass, "hosts=", _wrap_MemcachedSt_hosts_set, -1);
-  rb_define_method(cMemcachedSt.klass, "hosts", _wrap_MemcachedSt_hosts_get, -1);
-  rb_define_method(cMemcachedSt.klass, "snd_timeout=", _wrap_MemcachedSt_snd_timeout_set, -1);
-  rb_define_method(cMemcachedSt.klass, "snd_timeout", _wrap_MemcachedSt_snd_timeout_get, -1);
-  rb_define_method(cMemcachedSt.klass, "rcv_timeout=", _wrap_MemcachedSt_rcv_timeout_set, -1);
-  rb_define_method(cMemcachedSt.klass, "rcv_timeout", _wrap_MemcachedSt_rcv_timeout_get, -1);
-  rb_define_method(cMemcachedSt.klass, "server_failure_limit=", _wrap_MemcachedSt_server_failure_limit_set, -1);
-  rb_define_method(cMemcachedSt.klass, "server_failure_limit", _wrap_MemcachedSt_server_failure_limit_get, -1);
-  rb_define_method(cMemcachedSt.klass, "io_msg_watermark=", _wrap_MemcachedSt_io_msg_watermark_set, -1);
-  rb_define_method(cMemcachedSt.klass, "io_msg_watermark", _wrap_MemcachedSt_io_msg_watermark_get, -1);
-  rb_define_method(cMemcachedSt.klass, "io_bytes_watermark=", _wrap_MemcachedSt_io_bytes_watermark_set, -1);
-  rb_define_method(cMemcachedSt.klass, "io_bytes_watermark", _wrap_MemcachedSt_io_bytes_watermark_get, -1);
-  rb_define_method(cMemcachedSt.klass, "io_key_prefetch=", _wrap_MemcachedSt_io_key_prefetch_set, -1);
-  rb_define_method(cMemcachedSt.klass, "io_key_prefetch", _wrap_MemcachedSt_io_key_prefetch_get, -1);
-  rb_define_method(cMemcachedSt.klass, "number_of_hosts=", _wrap_MemcachedSt_number_of_hosts_set, -1);
-  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, "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);
-  rb_define_method(cMemcachedSt.klass, "flags", _wrap_MemcachedSt_flags_get, -1);
-  rb_define_method(cMemcachedSt.klass, "poll_timeout=", _wrap_MemcachedSt_poll_timeout_set, -1);
-  rb_define_method(cMemcachedSt.klass, "poll_timeout", _wrap_MemcachedSt_poll_timeout_get, -1);
-  rb_define_method(cMemcachedSt.klass, "connect_timeout=", _wrap_MemcachedSt_connect_timeout_set, -1);
-  rb_define_method(cMemcachedSt.klass, "connect_timeout", _wrap_MemcachedSt_connect_timeout_get, -1);
-  rb_define_method(cMemcachedSt.klass, "retry_timeout=", _wrap_MemcachedSt_retry_timeout_set, -1);
-  rb_define_method(cMemcachedSt.klass, "retry_timeout", _wrap_MemcachedSt_retry_timeout_get, -1);
-  rb_define_method(cMemcachedSt.klass, "continuum_count=", _wrap_MemcachedSt_continuum_count_set, -1);
-  rb_define_method(cMemcachedSt.klass, "continuum_count", _wrap_MemcachedSt_continuum_count_get, -1);
-  rb_define_method(cMemcachedSt.klass, "send_size=", _wrap_MemcachedSt_send_size_set, -1);
-  rb_define_method(cMemcachedSt.klass, "send_size", _wrap_MemcachedSt_send_size_get, -1);
-  rb_define_method(cMemcachedSt.klass, "recv_size=", _wrap_MemcachedSt_recv_size_set, -1);
-  rb_define_method(cMemcachedSt.klass, "recv_size", _wrap_MemcachedSt_recv_size_get, -1);
-  rb_define_method(cMemcachedSt.klass, "user_data=", _wrap_MemcachedSt_user_data_set, -1);
-  rb_define_method(cMemcachedSt.klass, "user_data", _wrap_MemcachedSt_user_data_get, -1);
-  rb_define_method(cMemcachedSt.klass, "next_distribution_rebuild=", _wrap_MemcachedSt_next_distribution_rebuild_set, -1);
-  rb_define_method(cMemcachedSt.klass, "next_distribution_rebuild", _wrap_MemcachedSt_next_distribution_rebuild_get, -1);
-  rb_define_method(cMemcachedSt.klass, "prefix_key_length=", _wrap_MemcachedSt_prefix_key_length_set, -1);
-  rb_define_method(cMemcachedSt.klass, "prefix_key_length", _wrap_MemcachedSt_prefix_key_length_get, -1);
-  rb_define_method(cMemcachedSt.klass, "hash_continuum=", _wrap_MemcachedSt_hash_continuum_set, -1);
-  rb_define_method(cMemcachedSt.klass, "hash_continuum", _wrap_MemcachedSt_hash_continuum_get, -1);
-  rb_define_method(cMemcachedSt.klass, "result=", _wrap_MemcachedSt_result_set, -1);
-  rb_define_method(cMemcachedSt.klass, "result", _wrap_MemcachedSt_result_get, -1);
-  rb_define_method(cMemcachedSt.klass, "continuum=", _wrap_MemcachedSt_continuum_set, -1);
-  rb_define_method(cMemcachedSt.klass, "continuum", _wrap_MemcachedSt_continuum_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);
-  rb_define_method(cMemcachedSt.klass, "call_calloc=", _wrap_MemcachedSt_call_calloc_set, -1);
-  rb_define_method(cMemcachedSt.klass, "call_calloc", _wrap_MemcachedSt_call_calloc_get, -1);
-  rb_define_method(cMemcachedSt.klass, "get_key_failure=", _wrap_MemcachedSt_get_key_failure_set, -1);
-  rb_define_method(cMemcachedSt.klass, "get_key_failure", _wrap_MemcachedSt_get_key_failure_get, -1);
-  rb_define_method(cMemcachedSt.klass, "delete_trigger=", _wrap_MemcachedSt_delete_trigger_set, -1);
-  rb_define_method(cMemcachedSt.klass, "delete_trigger", _wrap_MemcachedSt_delete_trigger_get, -1);
-  rb_define_method(cMemcachedSt.klass, "prefix_key=", _wrap_MemcachedSt_prefix_key_set, -1);
-  rb_define_method(cMemcachedSt.klass, "prefix_key", _wrap_MemcachedSt_prefix_key_get, -1);
-  rb_define_method(cMemcachedSt.klass, "number_of_replicas=", _wrap_MemcachedSt_number_of_replicas_set, -1);
-  rb_define_method(cMemcachedSt.klass, "number_of_replicas", _wrap_MemcachedSt_number_of_replicas_get, -1);
-  cMemcachedSt.mark = 0;
-  cMemcachedSt.destroy = (void (*)(void *)) memcached_free;
-  cMemcachedSt.trackObjects = 0;
+  SwigClassMemcachedAnalysisSt.klass = rb_define_class_under(mRlibmemcached, "MemcachedAnalysisSt", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_memcached_analysis_st, (void *) &SwigClassMemcachedAnalysisSt);
+  rb_define_alloc_func(SwigClassMemcachedAnalysisSt.klass, _wrap_MemcachedAnalysisSt_allocate);
+  rb_define_method(SwigClassMemcachedAnalysisSt.klass, "initialize", _wrap_new_MemcachedAnalysisSt, -1);
+  rb_define_method(SwigClassMemcachedAnalysisSt.klass, "average_item_size=", _wrap_MemcachedAnalysisSt_average_item_size_set, -1);
+  rb_define_method(SwigClassMemcachedAnalysisSt.klass, "average_item_size", _wrap_MemcachedAnalysisSt_average_item_size_get, -1);
+  rb_define_method(SwigClassMemcachedAnalysisSt.klass, "longest_uptime=", _wrap_MemcachedAnalysisSt_longest_uptime_set, -1);
+  rb_define_method(SwigClassMemcachedAnalysisSt.klass, "longest_uptime", _wrap_MemcachedAnalysisSt_longest_uptime_get, -1);
+  rb_define_method(SwigClassMemcachedAnalysisSt.klass, "least_free_server=", _wrap_MemcachedAnalysisSt_least_free_server_set, -1);
+  rb_define_method(SwigClassMemcachedAnalysisSt.klass, "least_free_server", _wrap_MemcachedAnalysisSt_least_free_server_get, -1);
+  rb_define_method(SwigClassMemcachedAnalysisSt.klass, "most_consumed_server=", _wrap_MemcachedAnalysisSt_most_consumed_server_set, -1);
+  rb_define_method(SwigClassMemcachedAnalysisSt.klass, "most_consumed_server", _wrap_MemcachedAnalysisSt_most_consumed_server_get, -1);
+  rb_define_method(SwigClassMemcachedAnalysisSt.klass, "oldest_server=", _wrap_MemcachedAnalysisSt_oldest_server_set, -1);
+  rb_define_method(SwigClassMemcachedAnalysisSt.klass, "oldest_server", _wrap_MemcachedAnalysisSt_oldest_server_get, -1);
+  rb_define_method(SwigClassMemcachedAnalysisSt.klass, "pool_hit_ratio=", _wrap_MemcachedAnalysisSt_pool_hit_ratio_set, -1);
+  rb_define_method(SwigClassMemcachedAnalysisSt.klass, "pool_hit_ratio", _wrap_MemcachedAnalysisSt_pool_hit_ratio_get, -1);
+  rb_define_method(SwigClassMemcachedAnalysisSt.klass, "most_used_bytes=", _wrap_MemcachedAnalysisSt_most_used_bytes_set, -1);
+  rb_define_method(SwigClassMemcachedAnalysisSt.klass, "most_used_bytes", _wrap_MemcachedAnalysisSt_most_used_bytes_get, -1);
+  rb_define_method(SwigClassMemcachedAnalysisSt.klass, "least_remaining_bytes=", _wrap_MemcachedAnalysisSt_least_remaining_bytes_set, -1);
+  rb_define_method(SwigClassMemcachedAnalysisSt.klass, "least_remaining_bytes", _wrap_MemcachedAnalysisSt_least_remaining_bytes_get, -1);
+  SwigClassMemcachedAnalysisSt.mark = 0;
+  SwigClassMemcachedAnalysisSt.destroy = (void (*)(void *)) free_memcached_analysis_st;
+  SwigClassMemcachedAnalysisSt.trackObjects = 0;
+  
+  SwigClassMemcachedStatSt.klass = rb_define_class_under(mRlibmemcached, "MemcachedStatSt", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_memcached_stat_st, (void *) &SwigClassMemcachedStatSt);
+  rb_define_alloc_func(SwigClassMemcachedStatSt.klass, _wrap_MemcachedStatSt_allocate);
+  rb_define_method(SwigClassMemcachedStatSt.klass, "initialize", _wrap_new_MemcachedStatSt, -1);
+  rb_define_method(SwigClassMemcachedStatSt.klass, "connection_structures=", _wrap_MemcachedStatSt_connection_structures_set, -1);
+  rb_define_method(SwigClassMemcachedStatSt.klass, "connection_structures", _wrap_MemcachedStatSt_connection_structures_get, -1);
+  rb_define_method(SwigClassMemcachedStatSt.klass, "curr_connections=", _wrap_MemcachedStatSt_curr_connections_set, -1);
+  rb_define_method(SwigClassMemcachedStatSt.klass, "curr_connections", _wrap_MemcachedStatSt_curr_connections_get, -1);
+  rb_define_method(SwigClassMemcachedStatSt.klass, "curr_items=", _wrap_MemcachedStatSt_curr_items_set, -1);
+  rb_define_method(SwigClassMemcachedStatSt.klass, "curr_items", _wrap_MemcachedStatSt_curr_items_get, -1);
+  rb_define_method(SwigClassMemcachedStatSt.klass, "pid=", _wrap_MemcachedStatSt_pid_set, -1);
+  rb_define_method(SwigClassMemcachedStatSt.klass, "pid", _wrap_MemcachedStatSt_pid_get, -1);
+  rb_define_method(SwigClassMemcachedStatSt.klass, "pointer_size=", _wrap_MemcachedStatSt_pointer_size_set, -1);
+  rb_define_method(SwigClassMemcachedStatSt.klass, "pointer_size", _wrap_MemcachedStatSt_pointer_size_get, -1);
+  rb_define_method(SwigClassMemcachedStatSt.klass, "rusage_system_microseconds=", _wrap_MemcachedStatSt_rusage_system_microseconds_set, -1);
+  rb_define_method(SwigClassMemcachedStatSt.klass, "rusage_system_microseconds", _wrap_MemcachedStatSt_rusage_system_microseconds_get, -1);
+  rb_define_method(SwigClassMemcachedStatSt.klass, "rusage_system_seconds=", _wrap_MemcachedStatSt_rusage_system_seconds_set, -1);
+  rb_define_method(SwigClassMemcachedStatSt.klass, "rusage_system_seconds", _wrap_MemcachedStatSt_rusage_system_seconds_get, -1);
+  rb_define_method(SwigClassMemcachedStatSt.klass, "rusage_user_microseconds=", _wrap_MemcachedStatSt_rusage_user_microseconds_set, -1);
+  rb_define_method(SwigClassMemcachedStatSt.klass, "rusage_user_microseconds", _wrap_MemcachedStatSt_rusage_user_microseconds_get, -1);
+  rb_define_method(SwigClassMemcachedStatSt.klass, "rusage_user_seconds=", _wrap_MemcachedStatSt_rusage_user_seconds_set, -1);
+  rb_define_method(SwigClassMemcachedStatSt.klass, "rusage_user_seconds", _wrap_MemcachedStatSt_rusage_user_seconds_get, -1);
+  rb_define_method(SwigClassMemcachedStatSt.klass, "threads=", _wrap_MemcachedStatSt_threads_set, -1);
+  rb_define_method(SwigClassMemcachedStatSt.klass, "threads", _wrap_MemcachedStatSt_threads_get, -1);
+  rb_define_method(SwigClassMemcachedStatSt.klass, "time=", _wrap_MemcachedStatSt_time_set, -1);
+  rb_define_method(SwigClassMemcachedStatSt.klass, "time", _wrap_MemcachedStatSt_time_get, -1);
+  rb_define_method(SwigClassMemcachedStatSt.klass, "total_connections=", _wrap_MemcachedStatSt_total_connections_set, -1);
+  rb_define_method(SwigClassMemcachedStatSt.klass, "total_connections", _wrap_MemcachedStatSt_total_connections_get, -1);
+  rb_define_method(SwigClassMemcachedStatSt.klass, "total_items=", _wrap_MemcachedStatSt_total_items_set, -1);
+  rb_define_method(SwigClassMemcachedStatSt.klass, "total_items", _wrap_MemcachedStatSt_total_items_get, -1);
+  rb_define_method(SwigClassMemcachedStatSt.klass, "uptime=", _wrap_MemcachedStatSt_uptime_set, -1);
+  rb_define_method(SwigClassMemcachedStatSt.klass, "uptime", _wrap_MemcachedStatSt_uptime_get, -1);
+  rb_define_method(SwigClassMemcachedStatSt.klass, "bytes=", _wrap_MemcachedStatSt_bytes_set, -1);
+  rb_define_method(SwigClassMemcachedStatSt.klass, "bytes", _wrap_MemcachedStatSt_bytes_get, -1);
+  rb_define_method(SwigClassMemcachedStatSt.klass, "bytes_read=", _wrap_MemcachedStatSt_bytes_read_set, -1);
+  rb_define_method(SwigClassMemcachedStatSt.klass, "bytes_read", _wrap_MemcachedStatSt_bytes_read_get, -1);
+  rb_define_method(SwigClassMemcachedStatSt.klass, "bytes_written=", _wrap_MemcachedStatSt_bytes_written_set, -1);
+  rb_define_method(SwigClassMemcachedStatSt.klass, "bytes_written", _wrap_MemcachedStatSt_bytes_written_get, -1);
+  rb_define_method(SwigClassMemcachedStatSt.klass, "cmd_get=", _wrap_MemcachedStatSt_cmd_get_set, -1);
+  rb_define_method(SwigClassMemcachedStatSt.klass, "cmd_get", _wrap_MemcachedStatSt_cmd_get_get, -1);
+  rb_define_method(SwigClassMemcachedStatSt.klass, "cmd_set=", _wrap_MemcachedStatSt_cmd_set_set, -1);
+  rb_define_method(SwigClassMemcachedStatSt.klass, "cmd_set", _wrap_MemcachedStatSt_cmd_set_get, -1);
+  rb_define_method(SwigClassMemcachedStatSt.klass, "evictions=", _wrap_MemcachedStatSt_evictions_set, -1);
+  rb_define_method(SwigClassMemcachedStatSt.klass, "evictions", _wrap_MemcachedStatSt_evictions_get, -1);
+  rb_define_method(SwigClassMemcachedStatSt.klass, "get_hits=", _wrap_MemcachedStatSt_get_hits_set, -1);
+  rb_define_method(SwigClassMemcachedStatSt.klass, "get_hits", _wrap_MemcachedStatSt_get_hits_get, -1);
+  rb_define_method(SwigClassMemcachedStatSt.klass, "get_misses=", _wrap_MemcachedStatSt_get_misses_set, -1);
+  rb_define_method(SwigClassMemcachedStatSt.klass, "get_misses", _wrap_MemcachedStatSt_get_misses_get, -1);
+  rb_define_method(SwigClassMemcachedStatSt.klass, "limit_maxbytes=", _wrap_MemcachedStatSt_limit_maxbytes_set, -1);
+  rb_define_method(SwigClassMemcachedStatSt.klass, "limit_maxbytes", _wrap_MemcachedStatSt_limit_maxbytes_get, -1);
+  rb_define_method(SwigClassMemcachedStatSt.klass, "version=", _wrap_MemcachedStatSt_version_set, -1);
+  rb_define_method(SwigClassMemcachedStatSt.klass, "version", _wrap_MemcachedStatSt_version_get, -1);
+  SwigClassMemcachedStatSt.mark = 0;
+  SwigClassMemcachedStatSt.destroy = (void (*)(void *)) free_memcached_stat_st;
+  SwigClassMemcachedStatSt.trackObjects = 0;
+  
+  SwigClassMemcachedSt.klass = rb_define_class_under(mRlibmemcached, "MemcachedSt", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_memcached_st, (void *) &SwigClassMemcachedSt);
+  rb_define_alloc_func(SwigClassMemcachedSt.klass, _wrap_MemcachedSt_allocate);
+  rb_define_method(SwigClassMemcachedSt.klass, "initialize", _wrap_new_MemcachedSt, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "purging=", _wrap_MemcachedSt_purging_set, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "purging", _wrap_MemcachedSt_purging_get, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "is_allocated=", _wrap_MemcachedSt_is_allocated_set, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "is_allocated", _wrap_MemcachedSt_is_allocated_get, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "distribution=", _wrap_MemcachedSt_distribution_set, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "distribution", _wrap_MemcachedSt_distribution_get, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "hash=", _wrap_MemcachedSt_hash_set, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "hash", _wrap_MemcachedSt_hash_get, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "continuum_points_counter=", _wrap_MemcachedSt_continuum_points_counter_set, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "continuum_points_counter", _wrap_MemcachedSt_continuum_points_counter_get, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "hosts=", _wrap_MemcachedSt_hosts_set, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "hosts", _wrap_MemcachedSt_hosts_get, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "snd_timeout=", _wrap_MemcachedSt_snd_timeout_set, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "snd_timeout", _wrap_MemcachedSt_snd_timeout_get, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "rcv_timeout=", _wrap_MemcachedSt_rcv_timeout_set, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "rcv_timeout", _wrap_MemcachedSt_rcv_timeout_get, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "server_failure_limit=", _wrap_MemcachedSt_server_failure_limit_set, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "server_failure_limit", _wrap_MemcachedSt_server_failure_limit_get, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "io_msg_watermark=", _wrap_MemcachedSt_io_msg_watermark_set, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "io_msg_watermark", _wrap_MemcachedSt_io_msg_watermark_get, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "io_bytes_watermark=", _wrap_MemcachedSt_io_bytes_watermark_set, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "io_bytes_watermark", _wrap_MemcachedSt_io_bytes_watermark_get, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "io_key_prefetch=", _wrap_MemcachedSt_io_key_prefetch_set, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "io_key_prefetch", _wrap_MemcachedSt_io_key_prefetch_get, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "number_of_hosts=", _wrap_MemcachedSt_number_of_hosts_set, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "number_of_hosts", _wrap_MemcachedSt_number_of_hosts_get, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "cursor_server=", _wrap_MemcachedSt_cursor_server_set, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "cursor_server", _wrap_MemcachedSt_cursor_server_get, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "cached_errno=", _wrap_MemcachedSt_cached_errno_set, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "cached_errno", _wrap_MemcachedSt_cached_errno_get, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "flags=", _wrap_MemcachedSt_flags_set, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "flags", _wrap_MemcachedSt_flags_get, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "poll_timeout=", _wrap_MemcachedSt_poll_timeout_set, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "poll_timeout", _wrap_MemcachedSt_poll_timeout_get, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "connect_timeout=", _wrap_MemcachedSt_connect_timeout_set, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "connect_timeout", _wrap_MemcachedSt_connect_timeout_get, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "retry_timeout=", _wrap_MemcachedSt_retry_timeout_set, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "retry_timeout", _wrap_MemcachedSt_retry_timeout_get, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "continuum_count=", _wrap_MemcachedSt_continuum_count_set, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "continuum_count", _wrap_MemcachedSt_continuum_count_get, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "send_size=", _wrap_MemcachedSt_send_size_set, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "send_size", _wrap_MemcachedSt_send_size_get, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "recv_size=", _wrap_MemcachedSt_recv_size_set, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "recv_size", _wrap_MemcachedSt_recv_size_get, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "user_data=", _wrap_MemcachedSt_user_data_set, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "user_data", _wrap_MemcachedSt_user_data_get, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "next_distribution_rebuild=", _wrap_MemcachedSt_next_distribution_rebuild_set, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "next_distribution_rebuild", _wrap_MemcachedSt_next_distribution_rebuild_get, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "prefix_key_length=", _wrap_MemcachedSt_prefix_key_length_set, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "prefix_key_length", _wrap_MemcachedSt_prefix_key_length_get, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "hash_continuum=", _wrap_MemcachedSt_hash_continuum_set, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "hash_continuum", _wrap_MemcachedSt_hash_continuum_get, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "result=", _wrap_MemcachedSt_result_set, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "result", _wrap_MemcachedSt_result_get, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "continuum=", _wrap_MemcachedSt_continuum_set, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "continuum", _wrap_MemcachedSt_continuum_get, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "on_clone=", _wrap_MemcachedSt_on_clone_set, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "on_clone", _wrap_MemcachedSt_on_clone_get, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "on_cleanup=", _wrap_MemcachedSt_on_cleanup_set, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "on_cleanup", _wrap_MemcachedSt_on_cleanup_get, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "call_free=", _wrap_MemcachedSt_call_free_set, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "call_free", _wrap_MemcachedSt_call_free_get, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "call_malloc=", _wrap_MemcachedSt_call_malloc_set, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "call_malloc", _wrap_MemcachedSt_call_malloc_get, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "call_realloc=", _wrap_MemcachedSt_call_realloc_set, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "call_realloc", _wrap_MemcachedSt_call_realloc_get, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "call_calloc=", _wrap_MemcachedSt_call_calloc_set, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "call_calloc", _wrap_MemcachedSt_call_calloc_get, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "get_key_failure=", _wrap_MemcachedSt_get_key_failure_set, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "get_key_failure", _wrap_MemcachedSt_get_key_failure_get, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "delete_trigger=", _wrap_MemcachedSt_delete_trigger_set, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "delete_trigger", _wrap_MemcachedSt_delete_trigger_get, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "prefix_key=", _wrap_MemcachedSt_prefix_key_set, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "prefix_key", _wrap_MemcachedSt_prefix_key_get, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "number_of_replicas=", _wrap_MemcachedSt_number_of_replicas_set, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "number_of_replicas", _wrap_MemcachedSt_number_of_replicas_get, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "number_of_live_hosts=", _wrap_MemcachedSt_number_of_live_hosts_set, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "number_of_live_hosts", _wrap_MemcachedSt_number_of_live_hosts_get, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "live_host_indices=", _wrap_MemcachedSt_live_host_indices_set, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "live_host_indices", _wrap_MemcachedSt_live_host_indices_get, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "live_host_indices_size=", _wrap_MemcachedSt_live_host_indices_size_set, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "live_host_indices_size", _wrap_MemcachedSt_live_host_indices_size_get, -1);
+  SwigClassMemcachedSt.mark = 0;
+  SwigClassMemcachedSt.destroy = (void (*)(void *)) memcached_free;
+  SwigClassMemcachedSt.trackObjects = 0;
   rb_define_module_function(mRlibmemcached, "memcached_version", _wrap_memcached_version, -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);
@@ -12767,29 +12979,29 @@ SWIGEXPORT void Init_rlibmemcached(void) {
   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);
   
-  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);
-  rb_define_method(cMemcachedResultSt.klass, "flags=", _wrap_MemcachedResultSt_flags_set, -1);
-  rb_define_method(cMemcachedResultSt.klass, "flags", _wrap_MemcachedResultSt_flags_get, -1);
-  rb_define_method(cMemcachedResultSt.klass, "is_allocated=", _wrap_MemcachedResultSt_is_allocated_set, -1);
-  rb_define_method(cMemcachedResultSt.klass, "is_allocated", _wrap_MemcachedResultSt_is_allocated_get, -1);
-  rb_define_method(cMemcachedResultSt.klass, "expiration=", _wrap_MemcachedResultSt_expiration_set, -1);
-  rb_define_method(cMemcachedResultSt.klass, "expiration", _wrap_MemcachedResultSt_expiration_get, -1);
-  rb_define_method(cMemcachedResultSt.klass, "root=", _wrap_MemcachedResultSt_root_set, -1);
-  rb_define_method(cMemcachedResultSt.klass, "root", _wrap_MemcachedResultSt_root_get, -1);
-  rb_define_method(cMemcachedResultSt.klass, "key_length=", _wrap_MemcachedResultSt_key_length_set, -1);
-  rb_define_method(cMemcachedResultSt.klass, "key_length", _wrap_MemcachedResultSt_key_length_get, -1);
-  rb_define_method(cMemcachedResultSt.klass, "cas=", _wrap_MemcachedResultSt_cas_set, -1);
-  rb_define_method(cMemcachedResultSt.klass, "cas", _wrap_MemcachedResultSt_cas_get, -1);
-  rb_define_method(cMemcachedResultSt.klass, "value=", _wrap_MemcachedResultSt_value_set, -1);
-  rb_define_method(cMemcachedResultSt.klass, "value", _wrap_MemcachedResultSt_value_get, -1);
-  rb_define_method(cMemcachedResultSt.klass, "key=", _wrap_MemcachedResultSt_key_set, -1);
-  rb_define_method(cMemcachedResultSt.klass, "key", _wrap_MemcachedResultSt_key_get, -1);
-  cMemcachedResultSt.mark = 0;
-  cMemcachedResultSt.destroy = (void (*)(void *)) free_memcached_result_st;
-  cMemcachedResultSt.trackObjects = 0;
+  SwigClassMemcachedResultSt.klass = rb_define_class_under(mRlibmemcached, "MemcachedResultSt", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_memcached_result_st, (void *) &SwigClassMemcachedResultSt);
+  rb_define_alloc_func(SwigClassMemcachedResultSt.klass, _wrap_MemcachedResultSt_allocate);
+  rb_define_method(SwigClassMemcachedResultSt.klass, "initialize", _wrap_new_MemcachedResultSt, -1);
+  rb_define_method(SwigClassMemcachedResultSt.klass, "flags=", _wrap_MemcachedResultSt_flags_set, -1);
+  rb_define_method(SwigClassMemcachedResultSt.klass, "flags", _wrap_MemcachedResultSt_flags_get, -1);
+  rb_define_method(SwigClassMemcachedResultSt.klass, "is_allocated=", _wrap_MemcachedResultSt_is_allocated_set, -1);
+  rb_define_method(SwigClassMemcachedResultSt.klass, "is_allocated", _wrap_MemcachedResultSt_is_allocated_get, -1);
+  rb_define_method(SwigClassMemcachedResultSt.klass, "expiration=", _wrap_MemcachedResultSt_expiration_set, -1);
+  rb_define_method(SwigClassMemcachedResultSt.klass, "expiration", _wrap_MemcachedResultSt_expiration_get, -1);
+  rb_define_method(SwigClassMemcachedResultSt.klass, "root=", _wrap_MemcachedResultSt_root_set, -1);
+  rb_define_method(SwigClassMemcachedResultSt.klass, "root", _wrap_MemcachedResultSt_root_get, -1);
+  rb_define_method(SwigClassMemcachedResultSt.klass, "key_length=", _wrap_MemcachedResultSt_key_length_set, -1);
+  rb_define_method(SwigClassMemcachedResultSt.klass, "key_length", _wrap_MemcachedResultSt_key_length_get, -1);
+  rb_define_method(SwigClassMemcachedResultSt.klass, "cas=", _wrap_MemcachedResultSt_cas_set, -1);
+  rb_define_method(SwigClassMemcachedResultSt.klass, "cas", _wrap_MemcachedResultSt_cas_get, -1);
+  rb_define_method(SwigClassMemcachedResultSt.klass, "value=", _wrap_MemcachedResultSt_value_set, -1);
+  rb_define_method(SwigClassMemcachedResultSt.klass, "value", _wrap_MemcachedResultSt_value_get, -1);
+  rb_define_method(SwigClassMemcachedResultSt.klass, "key=", _wrap_MemcachedResultSt_key_set, -1);
+  rb_define_method(SwigClassMemcachedResultSt.klass, "key", _wrap_MemcachedResultSt_key_get, -1);
+  SwigClassMemcachedResultSt.mark = 0;
+  SwigClassMemcachedResultSt.destroy = (void (*)(void *)) free_memcached_result_st;
+  SwigClassMemcachedResultSt.trackObjects = 0;
   rb_define_module_function(mRlibmemcached, "memcached_result_free", _wrap_memcached_result_free, -1);
   rb_define_module_function(mRlibmemcached, "memcached_result_reset", _wrap_memcached_result_reset, -1);
   rb_define_module_function(mRlibmemcached, "memcached_result_create", _wrap_memcached_result_create, -1);
@@ -12797,65 +13009,65 @@ SWIGEXPORT void Init_rlibmemcached(void) {
   rb_define_module_function(mRlibmemcached, "memcached_result_length", _wrap_memcached_result_length, -1);
   rb_define_module_function(mRlibmemcached, "memcached_result_set_value", _wrap_memcached_result_set_value, -1);
   
-  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);
-  rb_define_method(cMemcachedServerSt.klass, "is_allocated=", _wrap_MemcachedServerSt_is_allocated_set, -1);
-  rb_define_method(cMemcachedServerSt.klass, "is_allocated", _wrap_MemcachedServerSt_is_allocated_get, -1);
-  rb_define_method(cMemcachedServerSt.klass, "sockaddr_inited=", _wrap_MemcachedServerSt_sockaddr_inited_set, -1);
-  rb_define_method(cMemcachedServerSt.klass, "sockaddr_inited", _wrap_MemcachedServerSt_sockaddr_inited_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, "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, "port=", _wrap_MemcachedServerSt_port_set, -1);
-  rb_define_method(cMemcachedServerSt.klass, "port", _wrap_MemcachedServerSt_port_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, "fd=", _wrap_MemcachedServerSt_fd_set, -1);
-  rb_define_method(cMemcachedServerSt.klass, "fd", _wrap_MemcachedServerSt_fd_get, -1);
-  rb_define_method(cMemcachedServerSt.klass, "io_bytes_sent=", _wrap_MemcachedServerSt_io_bytes_sent_set, -1);
-  rb_define_method(cMemcachedServerSt.klass, "io_bytes_sent", _wrap_MemcachedServerSt_io_bytes_sent_get, -1);
-  rb_define_method(cMemcachedServerSt.klass, "server_failure_counter=", _wrap_MemcachedServerSt_server_failure_counter_set, -1);
-  rb_define_method(cMemcachedServerSt.klass, "server_failure_counter", _wrap_MemcachedServerSt_server_failure_counter_get, -1);
-  rb_define_method(cMemcachedServerSt.klass, "weight=", _wrap_MemcachedServerSt_weight_set, -1);
-  rb_define_method(cMemcachedServerSt.klass, "weight", _wrap_MemcachedServerSt_weight_get, -1);
-  rb_define_method(cMemcachedServerSt.klass, "major_version=", _wrap_MemcachedServerSt_major_version_set, -1);
-  rb_define_method(cMemcachedServerSt.klass, "major_version", _wrap_MemcachedServerSt_major_version_get, -1);
-  rb_define_method(cMemcachedServerSt.klass, "micro_version=", _wrap_MemcachedServerSt_micro_version_set, -1);
-  rb_define_method(cMemcachedServerSt.klass, "micro_version", _wrap_MemcachedServerSt_micro_version_get, -1);
-  rb_define_method(cMemcachedServerSt.klass, "minor_version=", _wrap_MemcachedServerSt_minor_version_set, -1);
-  rb_define_method(cMemcachedServerSt.klass, "minor_version", _wrap_MemcachedServerSt_minor_version_get, -1);
-  rb_define_method(cMemcachedServerSt.klass, "type=", _wrap_MemcachedServerSt_type_set, -1);
-  rb_define_method(cMemcachedServerSt.klass, "type", _wrap_MemcachedServerSt_type_get, -1);
-  rb_define_method(cMemcachedServerSt.klass, "read_ptr=", _wrap_MemcachedServerSt_read_ptr_set, -1);
-  rb_define_method(cMemcachedServerSt.klass, "read_ptr", _wrap_MemcachedServerSt_read_ptr_get, -1);
-  rb_define_method(cMemcachedServerSt.klass, "cached_server_error=", _wrap_MemcachedServerSt_cached_server_error_set, -1);
-  rb_define_method(cMemcachedServerSt.klass, "cached_server_error", _wrap_MemcachedServerSt_cached_server_error_get, -1);
-  rb_define_method(cMemcachedServerSt.klass, "read_buffer_length=", _wrap_MemcachedServerSt_read_buffer_length_set, -1);
-  rb_define_method(cMemcachedServerSt.klass, "read_buffer_length", _wrap_MemcachedServerSt_read_buffer_length_get, -1);
-  rb_define_method(cMemcachedServerSt.klass, "read_data_length=", _wrap_MemcachedServerSt_read_data_length_set, -1);
-  rb_define_method(cMemcachedServerSt.klass, "read_data_length", _wrap_MemcachedServerSt_read_data_length_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, "address_info=", _wrap_MemcachedServerSt_address_info_set, -1);
-  rb_define_method(cMemcachedServerSt.klass, "address_info", _wrap_MemcachedServerSt_address_info_get, -1);
-  rb_define_method(cMemcachedServerSt.klass, "next_retry=", _wrap_MemcachedServerSt_next_retry_set, -1);
-  rb_define_method(cMemcachedServerSt.klass, "next_retry", _wrap_MemcachedServerSt_next_retry_get, -1);
-  rb_define_method(cMemcachedServerSt.klass, "root=", _wrap_MemcachedServerSt_root_set, -1);
-  rb_define_method(cMemcachedServerSt.klass, "root", _wrap_MemcachedServerSt_root_get, -1);
-  rb_define_method(cMemcachedServerSt.klass, "limit_maxbytes=", _wrap_MemcachedServerSt_limit_maxbytes_set, -1);
-  rb_define_method(cMemcachedServerSt.klass, "limit_maxbytes", _wrap_MemcachedServerSt_limit_maxbytes_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, "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, "hostname=", _wrap_MemcachedServerSt_hostname_set, -1);
-  rb_define_method(cMemcachedServerSt.klass, "hostname", _wrap_MemcachedServerSt_hostname_get, -1);
-  cMemcachedServerSt.mark = 0;
-  cMemcachedServerSt.destroy = (void (*)(void *)) memcached_server_free;
-  cMemcachedServerSt.trackObjects = 0;
+  SwigClassMemcachedServerSt.klass = rb_define_class_under(mRlibmemcached, "MemcachedServerSt", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_memcached_server_st, (void *) &SwigClassMemcachedServerSt);
+  rb_define_alloc_func(SwigClassMemcachedServerSt.klass, _wrap_MemcachedServerSt_allocate);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "initialize", _wrap_new_MemcachedServerSt, -1);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "is_allocated=", _wrap_MemcachedServerSt_is_allocated_set, -1);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "is_allocated", _wrap_MemcachedServerSt_is_allocated_get, -1);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "sockaddr_inited=", _wrap_MemcachedServerSt_sockaddr_inited_set, -1);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "sockaddr_inited", _wrap_MemcachedServerSt_sockaddr_inited_get, -1);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "count=", _wrap_MemcachedServerSt_count_set, -1);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "count", _wrap_MemcachedServerSt_count_get, -1);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "cursor_active=", _wrap_MemcachedServerSt_cursor_active_set, -1);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "cursor_active", _wrap_MemcachedServerSt_cursor_active_get, -1);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "port=", _wrap_MemcachedServerSt_port_set, -1);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "port", _wrap_MemcachedServerSt_port_get, -1);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "cached_errno=", _wrap_MemcachedServerSt_cached_errno_set, -1);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "cached_errno", _wrap_MemcachedServerSt_cached_errno_get, -1);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "fd=", _wrap_MemcachedServerSt_fd_set, -1);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "fd", _wrap_MemcachedServerSt_fd_get, -1);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "io_bytes_sent=", _wrap_MemcachedServerSt_io_bytes_sent_set, -1);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "io_bytes_sent", _wrap_MemcachedServerSt_io_bytes_sent_get, -1);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "server_failure_counter=", _wrap_MemcachedServerSt_server_failure_counter_set, -1);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "server_failure_counter", _wrap_MemcachedServerSt_server_failure_counter_get, -1);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "weight=", _wrap_MemcachedServerSt_weight_set, -1);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "weight", _wrap_MemcachedServerSt_weight_get, -1);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "major_version=", _wrap_MemcachedServerSt_major_version_set, -1);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "major_version", _wrap_MemcachedServerSt_major_version_get, -1);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "micro_version=", _wrap_MemcachedServerSt_micro_version_set, -1);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "micro_version", _wrap_MemcachedServerSt_micro_version_get, -1);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "minor_version=", _wrap_MemcachedServerSt_minor_version_set, -1);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "minor_version", _wrap_MemcachedServerSt_minor_version_get, -1);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "type=", _wrap_MemcachedServerSt_type_set, -1);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "type", _wrap_MemcachedServerSt_type_get, -1);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "read_ptr=", _wrap_MemcachedServerSt_read_ptr_set, -1);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "read_ptr", _wrap_MemcachedServerSt_read_ptr_get, -1);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "cached_server_error=", _wrap_MemcachedServerSt_cached_server_error_set, -1);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "cached_server_error", _wrap_MemcachedServerSt_cached_server_error_get, -1);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "read_buffer_length=", _wrap_MemcachedServerSt_read_buffer_length_set, -1);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "read_buffer_length", _wrap_MemcachedServerSt_read_buffer_length_get, -1);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "read_data_length=", _wrap_MemcachedServerSt_read_data_length_set, -1);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "read_data_length", _wrap_MemcachedServerSt_read_data_length_get, -1);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "write_buffer_offset=", _wrap_MemcachedServerSt_write_buffer_offset_set, -1);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "write_buffer_offset", _wrap_MemcachedServerSt_write_buffer_offset_get, -1);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "address_info=", _wrap_MemcachedServerSt_address_info_set, -1);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "address_info", _wrap_MemcachedServerSt_address_info_get, -1);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "next_retry=", _wrap_MemcachedServerSt_next_retry_set, -1);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "next_retry", _wrap_MemcachedServerSt_next_retry_get, -1);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "root=", _wrap_MemcachedServerSt_root_set, -1);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "root", _wrap_MemcachedServerSt_root_get, -1);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "limit_maxbytes=", _wrap_MemcachedServerSt_limit_maxbytes_set, -1);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "limit_maxbytes", _wrap_MemcachedServerSt_limit_maxbytes_get, -1);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "read_buffer=", _wrap_MemcachedServerSt_read_buffer_set, -1);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "read_buffer", _wrap_MemcachedServerSt_read_buffer_get, -1);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "write_buffer=", _wrap_MemcachedServerSt_write_buffer_set, -1);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "write_buffer", _wrap_MemcachedServerSt_write_buffer_get, -1);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "hostname=", _wrap_MemcachedServerSt_hostname_set, -1);
+  rb_define_method(SwigClassMemcachedServerSt.klass, "hostname", _wrap_MemcachedServerSt_hostname_get, -1);
+  SwigClassMemcachedServerSt.mark = 0;
+  SwigClassMemcachedServerSt.destroy = (void (*)(void *)) memcached_server_free;
+  SwigClassMemcachedServerSt.trackObjects = 0;
   rb_define_module_function(mRlibmemcached, "memcached_server_cursor", _wrap_memcached_server_cursor, -1);
   rb_define_module_function(mRlibmemcached, "memcached_server_by_key", _wrap_memcached_server_by_key, -1);
   rb_define_module_function(mRlibmemcached, "memcached_server_error", _wrap_memcached_server_error, -1);

data/lib/memcached/memcached.rb

@@ -394,8 +394,8 @@ Please note that when pipelining is enabled, setter and deleter methods do not r
          check_return_code(ret, key)
 
          value = case value
-           when /^\d+\.\d+$/: value.to_f
-           when /^\d+$/: value.to_i
+           when /^\d+\.\d+$/ then value.to_f
+           when /^\d+$/ then value.to_i
            else value
          end
 

data/memcached.gemspec

@@ -2,12 +2,12 @@
 
 Gem::Specification.new do |s|
   s.name = %q{memcached}
-  s.version = "0.17"
+  s.version = "0.17.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
   s.authors = ["Evan Weaver"]
   s.cert_chain = ["/Users/eweaver/p/configuration/gem_certificates/evan_weaver-original-public_cert.pem"]
-  s.date = %q{2009-09-21}
+  s.date = %q{2009-09-22}
   s.description = %q{An interface to the libmemcached C client.}
   s.email = %q{}
   s.extensions = ["ext/extconf.rb"]

data/test/unit/memcached_test.rb

@@ -98,7 +98,7 @@ class MemcachedTest < Test::Unit::TestCase
   end
 
   def test_options_are_frozen
-    assert_raise(TypeError) do
+    assert_raise(TypeError, RuntimeError) do
       @cache.options[:no_block] = true
     end
   end
@@ -995,7 +995,7 @@ class MemcachedTest < Test::Unit::TestCase
   private
 
   def key
-    caller.first[/`(.*)'/, 1] # '
+    caller.first[/.*[` ](.*)'/, 1] # '
   end
 
   def stub_server(port)

data/test/unit/rails_test.rb

@@ -96,7 +96,7 @@ class RailsTest < Test::Unit::TestCase
   private
   
   def key
-    caller.first[/`(.*)'/, 1]
+    caller.first[/.*[` ](.*)'/, 1] # '
   end
   
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: memcached
 version: !ruby/object:Gem::Version 
-  version: "0.17"
+  version: 0.17.1
 platform: ruby
 authors: 
 - Evan Weaver
@@ -30,7 +30,7 @@ cert_chain:
   yZ0=
   -----END CERTIFICATE-----
 
-date: 2009-09-21 00:00:00 -07:00
+date: 2009-09-22 00:00:00 -07:00
 default_executable: 
 dependencies: []
 

metadata.gz.sig

@@ -1 +1,2 @@
-����4ɫ��A;�����h�W,2�	��)�W�k�Q��-�����̨]�	zA9:f$��OH�̛.�3
+հ�?����,�ڳ]hM_w��-a~Ќ��2�W�":�F��F2ۼЄ�[s*(�ɝ�E5�Y(�H�zq�z���MBAfA�)ZD�q<�S �Dwu��GbrYn����Ϣ\�||ppUw�<z�V���}{�Z�-��v���9��Z�f0@�/���b"k�z�W��~��e�
+ȮQR��^�p��(w���O?fB����V����!�c䖀���p����cZ��8��Q:SK��!���,#a�����nh�