memcached 0.19.10 → 0.20.0

data/ext/rlibmemcached.i

@@ -23,6 +23,7 @@
 
 %apply unsigned short { uint8_t };
 %apply unsigned int { uint16_t };
+%apply unsigned int { uint32_t user_spec_len };
 %apply unsigned long { uint32_t flags, uint32_t offset, uint32_t weight };
 %apply unsigned long long { uint64_t data, uint64_t cas };
 
@@ -149,12 +150,12 @@
 
 //// 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. 
+// 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, const char *key, size_t key_length, uint32_t *flags, memcached_return *error);
 %{
 VALUE memcached_get_rvalue(memcached_st *ptr, const char *key, size_t key_length, uint32_t *flags, memcached_return *error) {
-  VALUE ret;  
+  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);
@@ -163,10 +164,22 @@ VALUE memcached_get_rvalue(memcached_st *ptr, const char *key, size_t key_length
 };
 %}
 
+VALUE memcached_get_len_rvalue(memcached_st *ptr, const char *key, size_t key_length, uint32_t user_spec_len, uint32_t *flags, memcached_return *error);
+%{
+VALUE memcached_get_len_rvalue(memcached_st *ptr, const char *key, size_t key_length, uint32_t user_spec_len, uint32_t *flags, memcached_return *error) {
+  VALUE ret;
+  size_t value_length;
+  char *value = memcached_get_len(ptr, key, key_length, user_spec_len, &value_length, flags, error);
+  ret = rb_str_new(value, value_length);
+  free(value);
+  return ret;
+};
+%}
+
 VALUE memcached_get_from_last_rvalue(memcached_st *ptr, const char *key, size_t key_length, uint32_t *flags, memcached_return *error);
 %{
 VALUE memcached_get_from_last_rvalue(memcached_st *ptr, const char *key, size_t key_length, uint32_t *flags, memcached_return *error) {
-  VALUE ret;  
+  VALUE ret;
   size_t value_length;
   char *value = memcached_get_from_last(ptr, key, key_length, &value_length, flags, error);
   ret = rb_str_new(value, value_length);

data/ext/rlibmemcached_wrap.c

@@ -2251,7 +2251,7 @@ SWIG_From_unsigned_SS_int  (unsigned int value)
 
 
 VALUE memcached_get_rvalue(memcached_st *ptr, const char *key, size_t key_length, uint32_t *flags, memcached_return *error) {
-  VALUE ret;  
+  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);
@@ -2260,8 +2260,18 @@ VALUE memcached_get_rvalue(memcached_st *ptr, const char *key, size_t key_length
 };
 
 
+VALUE memcached_get_len_rvalue(memcached_st *ptr, const char *key, size_t key_length, uint32_t user_spec_len, uint32_t *flags, memcached_return *error) {
+  VALUE ret;
+  size_t value_length;
+  char *value = memcached_get_len(ptr, key, key_length, user_spec_len, &value_length, flags, error);
+  ret = rb_str_new(value, value_length);
+  free(value);
+  return ret;
+};
+
+
 VALUE memcached_get_from_last_rvalue(memcached_st *ptr, const char *key, size_t key_length, uint32_t *flags, memcached_return *error) {
-  VALUE ret;  
+  VALUE ret;
   size_t value_length;
   char *value = memcached_get_from_last(ptr, key, key_length, &value_length, flags, error);
   ret = rb_str_new(value, value_length);
@@ -8735,6 +8745,74 @@ fail:
 }
 
 
+SWIGINTERN VALUE
+_wrap_memcached_get_len(int argc, VALUE *argv, VALUE self) {
+  memcached_st *arg1 = (memcached_st *) 0 ;
+  char *arg2 = (char *) 0 ;
+  size_t arg3 ;
+  uint32_t arg4 ;
+  size_t *arg5 = (size_t *) 0 ;
+  uint32_t *arg6 = (uint32_t *) 0 ;
+  memcached_return *arg7 = (memcached_return *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int val4 ;
+  int ecode4 = 0 ;
+  size_t temp5 ;
+  int res5 = SWIG_TMPOBJ ;
+  uint32_t temp6 ;
+  int res6 = SWIG_TMPOBJ ;
+  memcached_return temp7 ;
+  int res7 = SWIG_TMPOBJ ;
+  char *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  arg5 = &temp5;
+  arg6 = &temp6;
+  arg7 = &temp7;
+  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), Ruby_Format_TypeError( "", "memcached_st *","memcached_get_len", 1, argv[0] )); 
+  }
+  arg1 = (memcached_st *)(argp1);
+  {
+    arg2 = StringValuePtr(argv[1]);
+    arg3 = (size_t) RSTRING_LEN(argv[1]);
+  }
+  ecode4 = SWIG_AsVal_unsigned_SS_int(argv[2], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "uint32_t","memcached_get_len", 4, argv[2] ));
+  } 
+  arg4 = (uint32_t)(val4);
+  result = (char *)memcached_get_len(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  if (SWIG_IsTmpObj(res5)) {
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_size_t((*arg5)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_size_t, new_flags));
+  }
+  if (SWIG_IsTmpObj(res6)) {
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_int((*arg6)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_uint32_t, new_flags));
+  }
+  if (SWIG_IsTmpObj(res7)) {
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_short((*arg7)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_memcached_return, new_flags));
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
 SWIGINTERN VALUE
 _wrap_memcached_mget(int argc, VALUE *argv, VALUE self) {
   memcached_st *arg1 = (memcached_st *) 0 ;
@@ -8774,6 +8852,53 @@ fail:
 }
 
 
+SWIGINTERN VALUE
+_wrap_memcached_mget_len(int argc, VALUE *argv, VALUE self) {
+  memcached_st *arg1 = (memcached_st *) 0 ;
+  char **arg2 = (char **) 0 ;
+  size_t *arg3 = (size_t *) 0 ;
+  size_t arg4 ;
+  uint32_t arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int val5 ;
+  int ecode5 = 0 ;
+  memcached_return result;
+  VALUE vresult = Qnil;
+  
+  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), Ruby_Format_TypeError( "", "memcached_st *","memcached_mget_len", 1, argv[0] )); 
+  }
+  arg1 = (memcached_st *)(argp1);
+  {
+    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 ++) {
+      Check_Type(RARRAY_PTR(argv[1])[i], T_STRING);
+      arg3[i] = RSTRING_LEN(RARRAY_PTR(argv[1])[i]);
+      arg2[i] = StringValuePtr(RARRAY_PTR(argv[1])[i]);
+    }
+  }
+  ecode5 = SWIG_AsVal_unsigned_SS_int(argv[2], &val5);
+  if (!SWIG_IsOK(ecode5)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "uint32_t","memcached_mget_len", 5, argv[2] ));
+  } 
+  arg5 = (uint32_t)(val5);
+  result = (memcached_return)memcached_mget_len(arg1,(char const **)arg2,arg3,arg4,arg5);
+  vresult = SWIG_From_int((int)(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
 SWIGINTERN VALUE
 _wrap_memcached_get_by_key(int argc, VALUE *argv, VALUE self) {
   memcached_st *arg1 = (memcached_st *) 0 ;
@@ -8781,25 +8906,28 @@ _wrap_memcached_get_by_key(int argc, VALUE *argv, VALUE self) {
   size_t arg3 ;
   char *arg4 = (char *) 0 ;
   size_t arg5 ;
-  size_t *arg6 = (size_t *) 0 ;
-  uint32_t *arg7 = (uint32_t *) 0 ;
-  memcached_return *arg8 = (memcached_return *) 0 ;
+  uint32_t arg6 ;
+  size_t *arg7 = (size_t *) 0 ;
+  uint32_t *arg8 = (uint32_t *) 0 ;
+  memcached_return *arg9 = (memcached_return *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  size_t temp6 ;
-  int res6 = SWIG_TMPOBJ ;
-  uint32_t temp7 ;
+  unsigned int val6 ;
+  int ecode6 = 0 ;
+  size_t temp7 ;
   int res7 = SWIG_TMPOBJ ;
-  memcached_return temp8 ;
+  uint32_t temp8 ;
   int res8 = SWIG_TMPOBJ ;
+  memcached_return temp9 ;
+  int res9 = SWIG_TMPOBJ ;
   char *result = 0 ;
   VALUE vresult = Qnil;
   
-  arg6 = &temp6;
   arg7 = &temp7;
   arg8 = &temp8;
-  if ((argc < 2) || (argc > 2)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  arg9 = &temp9;
+  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)) {
@@ -8810,25 +8938,30 @@ _wrap_memcached_get_by_key(int argc, VALUE *argv, VALUE self) {
     arg4 = arg2 = StringValuePtr(argv[1]);
     arg5 = arg3 = (size_t) RSTRING_LEN(argv[1]);
   }
-  result = (char *)memcached_get_by_key(arg1,(char const *)arg2,arg3,(char const *)arg4,arg5,arg6,arg7,arg8);
+  ecode6 = SWIG_AsVal_unsigned_SS_int(argv[2], &val6);
+  if (!SWIG_IsOK(ecode6)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "uint32_t","memcached_get_by_key", 6, argv[2] ));
+  } 
+  arg6 = (uint32_t)(val6);
+  result = (char *)memcached_get_by_key(arg1,(char const *)arg2,arg3,(char const *)arg4,arg5,arg6,arg7,arg8,arg9);
   vresult = SWIG_FromCharPtr((const char *)result);
-  if (SWIG_IsTmpObj(res6)) {
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_size_t((*arg6)));
-  } else {
-    int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_size_t, new_flags));
-  }
   if (SWIG_IsTmpObj(res7)) {
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_int((*arg7)));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_size_t((*arg7)));
   } else {
     int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_uint32_t, new_flags));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_size_t, new_flags));
   }
   if (SWIG_IsTmpObj(res8)) {
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_short((*arg8)));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_int((*arg8)));
   } else {
     int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_memcached_return, new_flags));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_uint32_t, new_flags));
+  }
+  if (SWIG_IsTmpObj(res9)) {
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_short((*arg9)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res9) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_memcached_return, new_flags));
   }
   return vresult;
 fail:
@@ -8844,6 +8977,7 @@ _wrap_memcached_mget_by_key(int argc, VALUE *argv, VALUE self) {
   char **arg4 = (char **) 0 ;
   size_t *arg5 = (size_t *) 0 ;
   size_t arg6 ;
+  uint32_t arg7 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   int res2 ;
@@ -8851,11 +8985,13 @@ _wrap_memcached_mget_by_key(int argc, VALUE *argv, VALUE self) {
   int alloc2 = 0 ;
   size_t val3 ;
   int ecode3 = 0 ;
+  unsigned int val7 ;
+  int ecode7 = 0 ;
   memcached_return result;
   VALUE vresult = Qnil;
   
-  if ((argc < 4) || (argc > 4)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  if ((argc < 5) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
   }
   res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
@@ -8884,7 +9020,12 @@ _wrap_memcached_mget_by_key(int argc, VALUE *argv, VALUE self) {
       arg4[i] = StringValuePtr(RARRAY_PTR(argv[3])[i]);
     }
   }
-  result = (memcached_return)memcached_mget_by_key(arg1,(char const *)arg2,arg3,(char const **)arg4,arg5,arg6);
+  ecode7 = SWIG_AsVal_unsigned_SS_int(argv[4], &val7);
+  if (!SWIG_IsOK(ecode7)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "uint32_t","memcached_mget_by_key", 7, argv[4] ));
+  } 
+  arg7 = (uint32_t)(val7);
+  result = (memcached_return)memcached_mget_by_key(arg1,(char const *)arg2,arg3,(char const **)arg4,arg5,arg6,arg7);
   vresult = SWIG_From_int((int)(result));
   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   return vresult;
@@ -12366,6 +12507,64 @@ fail:
 }
 
 
+SWIGINTERN VALUE
+_wrap_memcached_get_len_rvalue(int argc, VALUE *argv, VALUE self) {
+  memcached_st *arg1 = (memcached_st *) 0 ;
+  char *arg2 = (char *) 0 ;
+  size_t arg3 ;
+  uint32_t arg4 ;
+  uint32_t *arg5 = (uint32_t *) 0 ;
+  memcached_return *arg6 = (memcached_return *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int val4 ;
+  int ecode4 = 0 ;
+  uint32_t temp5 ;
+  int res5 = SWIG_TMPOBJ ;
+  memcached_return temp6 ;
+  int res6 = SWIG_TMPOBJ ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  arg5 = &temp5;
+  arg6 = &temp6;
+  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), Ruby_Format_TypeError( "", "memcached_st *","memcached_get_len_rvalue", 1, argv[0] )); 
+  }
+  arg1 = (memcached_st *)(argp1);
+  {
+    arg2 = StringValuePtr(argv[1]);
+    arg3 = (size_t) RSTRING_LEN(argv[1]);
+  }
+  ecode4 = SWIG_AsVal_unsigned_SS_int(argv[2], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "uint32_t","memcached_get_len_rvalue", 4, argv[2] ));
+  } 
+  arg4 = (uint32_t)(val4);
+  result = (VALUE)memcached_get_len_rvalue(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
+  vresult = result;
+  if (SWIG_IsTmpObj(res5)) {
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_int((*arg5)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_uint32_t, new_flags));
+  }
+  if (SWIG_IsTmpObj(res6)) {
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_short((*arg6)));
+  } else {
+    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));
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
 SWIGINTERN VALUE
 _wrap_memcached_get_from_last_rvalue(int argc, VALUE *argv, VALUE self) {
   memcached_st *arg1 = (memcached_st *) 0 ;
@@ -13359,8 +13558,12 @@ SWIGEXPORT void Init_rlibmemcached(void) {
   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, "GET_LEN_ARG_UNSPECIFIED", SWIG_From_unsigned_SS_int((unsigned int)(-1U)));
+  rb_define_const(mRlibmemcached, "GET_LEN_BUFSZ", SWIG_From_int((int)(32)));
   rb_define_module_function(mRlibmemcached, "memcached_get", _wrap_memcached_get, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_get_len", _wrap_memcached_get_len, -1);
   rb_define_module_function(mRlibmemcached, "memcached_mget", _wrap_memcached_mget, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_mget_len", _wrap_memcached_mget_len, -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_fetch", _wrap_memcached_fetch, -1);
@@ -13484,6 +13687,7 @@ SWIGEXPORT void Init_rlibmemcached(void) {
   rb_define_module_function(mRlibmemcached, "memcached_get_sasl_callbacks", _wrap_memcached_get_sasl_callbacks, -1);
   rb_define_module_function(mRlibmemcached, "memcached_sasl_authenticate_connection", _wrap_memcached_sasl_authenticate_connection, -1);
   rb_define_module_function(mRlibmemcached, "memcached_get_rvalue", _wrap_memcached_get_rvalue, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_get_len_rvalue", _wrap_memcached_get_len_rvalue, -1);
   rb_define_module_function(mRlibmemcached, "memcached_get_from_last_rvalue", _wrap_memcached_get_from_last_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);

data/lib/memcached.rb

@@ -30,3 +30,4 @@ require 'memcached/behaviors'
 require 'memcached/auth'
 require 'memcached/memcached'
 require 'memcached/rails'
+require 'memcached/experimental_memcached'

data/lib/memcached/experimental_memcached.rb

@@ -0,0 +1,31 @@
+module ExperimentalMemcached
+  def get_len(user_spec_len, keys)
+    if keys.is_a? ::Array
+      # Multi get
+      ret = ::Memcached::Lib.memcached_mget_len(@struct, keys, user_spec_len);
+      check_return_code(ret, keys)
+
+      hash = {}
+      keys.each do
+        value, key, flags, ret = ::Memcached::Lib.memcached_fetch_rvalue(@struct)
+        break if ret == ::Memcached::Lib::MEMCACHED_END
+        if ret != ::Memcached::Lib::MEMCACHED_NOTFOUND
+          check_return_code(ret, key)
+          # Assign the value
+          hash[key] = value
+        end
+      end
+      hash
+    else
+      # Single get_len
+      value, flags, ret = ::Memcached::Lib.memcached_get_len_rvalue(@struct, keys, user_spec_len)
+      check_return_code(ret, keys)
+      value
+    end
+  rescue => e
+    tries ||= 0
+    raise unless tries < options[:exception_retry_limit] && should_retry(e)
+    tries += 1
+    retry
+  end
+end

data/lib/memcached/memcached.rb

@@ -33,6 +33,7 @@ class Memcached
     :use_udp => false,
     :binary_protocol => false,
     :credentials => nil,
+    :experimental_features => false,
     :exception_retry_limit => 5,
     :exceptions_to_retry => [
         Memcached::ServerIsMarkedDead,
@@ -118,6 +119,10 @@ Please note that when <tt>:no_block => true</tt>, update methods do not raise on
       options[:credentials] = [ENV["MEMCACHE_USERNAME"], ENV["MEMCACHE_PASSWORD"]]
     end
 
+    if options[:experimental_features]
+       instance_eval { send(:extend, ::ExperimentalMemcached) }
+    end
+
     options[:binary_protocol] = true if options[:credentials] != nil
 
     # Force :buffer_requests to use :no_block
@@ -521,7 +526,7 @@ Please note that when <tt>:no_block => true</tt>, update methods do not raise on
     tries ||= 0
     raise unless tries < options[:exception_retry_limit] && should_retry(e)
     tries += 1
-    retry 
+    retry
   end
 
   # Gets a key's value from the previous server. Only useful with random distribution.