Module: Rlibmemcached

Defined in:: lib/memcached.rb,
ext/rlibmemcached/rlibmemcached_wrap.c

Overview

The generated SWIG module for accessing libmemcached’s C API.

Includes the full set of libmemcached static methods (as defined in $INCLUDE_PATH/libmemcached/memcached.h), and classes for the available structs:

Rlibmemcached::MemcachedResultSt
Rlibmemcached::MemcachedServerSt
Rlibmemcached::MemcachedSt
Rlibmemcached::MemcachedStatSt
Rlibmemcached::MemcachedStringSt

A number of SWIG typemaps and C helper methods are also defined in ext/libmemcached.i.

Defined Under Namespace

Classes: MemcachedAnalysisSt, MemcachedResultSt, MemcachedServerSt, MemcachedSt, MemcachedStatSt

Constant Summary collapse

MEMCACHED_VERSION_STRING_LENGTH =

SWIG_From_int((int)(24))

LIBMEMCACHED_VERSION_STRING =

SWIG_FromCharPtr("0.32")

MEMCACHED_DEFAULT_PORT =

SWIG_From_int((int)(11211))

MEMCACHED_MAX_KEY =

SWIG_From_int((int)(251))

MEMCACHED_MAX_BUFFER =

SWIG_From_int((int)(8196))

MEMCACHED_MAX_HOST_LENGTH =

SWIG_From_int((int)(64))

MEMCACHED_MAX_HOST_SORT_LENGTH =

SWIG_From_int((int)(86))

MEMCACHED_POINTS_PER_SERVER =

SWIG_From_int((int)(100))

MEMCACHED_POINTS_PER_SERVER_KETAMA =

SWIG_From_int((int)(160))

MEMCACHED_CONTINUUM_SIZE =

SWIG_From_int((int)(100*100))

MEMCACHED_STRIDE =

SWIG_From_int((int)(4))

MEMCACHED_DEFAULT_TIMEOUT =

SWIG_From_int((int)(1000))

MEMCACHED_CONTINUUM_ADDITION =

SWIG_From_int((int)(10))

MEMCACHED_PREFIX_KEY_MAX_SIZE =

SWIG_From_int((int)(128))

MEMCACHED_EXPIRATION_NOT_ADD =

SWIG_From_unsigned_SS_int((unsigned int)(0xffffffffU))

MEMCACHED_SUCCESS =

SWIG_From_int((int)(MEMCACHED_SUCCESS))

MEMCACHED_FAILURE =

SWIG_From_int((int)(MEMCACHED_FAILURE))

MEMCACHED_HOST_LOOKUP_FAILURE =

SWIG_From_int((int)(MEMCACHED_HOST_LOOKUP_FAILURE))

MEMCACHED_CONNECTION_FAILURE =

SWIG_From_int((int)(MEMCACHED_CONNECTION_FAILURE))

MEMCACHED_CONNECTION_BIND_FAILURE =

SWIG_From_int((int)(MEMCACHED_CONNECTION_BIND_FAILURE))

MEMCACHED_WRITE_FAILURE =

SWIG_From_int((int)(MEMCACHED_WRITE_FAILURE))

MEMCACHED_READ_FAILURE =

SWIG_From_int((int)(MEMCACHED_READ_FAILURE))

MEMCACHED_UNKNOWN_READ_FAILURE =

SWIG_From_int((int)(MEMCACHED_UNKNOWN_READ_FAILURE))

MEMCACHED_PROTOCOL_ERROR =

SWIG_From_int((int)(MEMCACHED_PROTOCOL_ERROR))

MEMCACHED_CLIENT_ERROR =

SWIG_From_int((int)(MEMCACHED_CLIENT_ERROR))

MEMCACHED_SERVER_ERROR =

SWIG_From_int((int)(MEMCACHED_SERVER_ERROR))

MEMCACHED_CONNECTION_SOCKET_CREATE_FAILURE =

SWIG_From_int((int)(MEMCACHED_CONNECTION_SOCKET_CREATE_FAILURE))

MEMCACHED_DATA_EXISTS =

SWIG_From_int((int)(MEMCACHED_DATA_EXISTS))

MEMCACHED_DATA_DOES_NOT_EXIST =

SWIG_From_int((int)(MEMCACHED_DATA_DOES_NOT_EXIST))

MEMCACHED_NOTSTORED =

SWIG_From_int((int)(MEMCACHED_NOTSTORED))

MEMCACHED_STORED =

SWIG_From_int((int)(MEMCACHED_STORED))

MEMCACHED_NOTFOUND =

SWIG_From_int((int)(MEMCACHED_NOTFOUND))

MEMCACHED_MEMORY_ALLOCATION_FAILURE =

SWIG_From_int((int)(MEMCACHED_MEMORY_ALLOCATION_FAILURE))

MEMCACHED_PARTIAL_READ =

SWIG_From_int((int)(MEMCACHED_PARTIAL_READ))

MEMCACHED_SOME_ERRORS =

SWIG_From_int((int)(MEMCACHED_SOME_ERRORS))

MEMCACHED_NO_SERVERS =

SWIG_From_int((int)(MEMCACHED_NO_SERVERS))

MEMCACHED_END =

SWIG_From_int((int)(MEMCACHED_END))

MEMCACHED_DELETED =

SWIG_From_int((int)(MEMCACHED_DELETED))

MEMCACHED_VALUE =

SWIG_From_int((int)(MEMCACHED_VALUE))

MEMCACHED_STAT =

SWIG_From_int((int)(MEMCACHED_STAT))

MEMCACHED_ITEM =

SWIG_From_int((int)(MEMCACHED_ITEM))

MEMCACHED_ERRNO =

SWIG_From_int((int)(MEMCACHED_ERRNO))

MEMCACHED_FAIL_UNIX_SOCKET =

SWIG_From_int((int)(MEMCACHED_FAIL_UNIX_SOCKET))

MEMCACHED_NOT_SUPPORTED =

SWIG_From_int((int)(MEMCACHED_NOT_SUPPORTED))

MEMCACHED_NO_KEY_PROVIDED =

SWIG_From_int((int)(MEMCACHED_NO_KEY_PROVIDED))

MEMCACHED_FETCH_NOTFINISHED =

SWIG_From_int((int)(MEMCACHED_FETCH_NOTFINISHED))

MEMCACHED_TIMEOUT =

SWIG_From_int((int)(MEMCACHED_TIMEOUT))

MEMCACHED_BUFFERED =

SWIG_From_int((int)(MEMCACHED_BUFFERED))

MEMCACHED_BAD_KEY_PROVIDED =

SWIG_From_int((int)(MEMCACHED_BAD_KEY_PROVIDED))

MEMCACHED_INVALID_HOST_PROTOCOL =

SWIG_From_int((int)(MEMCACHED_INVALID_HOST_PROTOCOL))

MEMCACHED_SERVER_MARKED_DEAD =

SWIG_From_int((int)(MEMCACHED_SERVER_MARKED_DEAD))

MEMCACHED_UNKNOWN_STAT_KEY =

SWIG_From_int((int)(MEMCACHED_UNKNOWN_STAT_KEY))

MEMCACHED_AUTH_PROBLEM =

SWIG_From_int((int)(MEMCACHED_AUTH_PROBLEM))

MEMCACHED_AUTH_FAILURE =

SWIG_From_int((int)(MEMCACHED_AUTH_FAILURE))

MEMCACHED_AUTH_CONTINUE =

SWIG_From_int((int)(MEMCACHED_AUTH_CONTINUE))

MEMCACHED_MAXIMUM_RETURN =

SWIG_From_int((int)(MEMCACHED_MAXIMUM_RETURN))

MEMCACHED_DISTRIBUTION_MODULA =

SWIG_From_int((int)(MEMCACHED_DISTRIBUTION_MODULA))

MEMCACHED_DISTRIBUTION_CONSISTENT =

SWIG_From_int((int)(MEMCACHED_DISTRIBUTION_CONSISTENT))

MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA =

SWIG_From_int((int)(MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA))

MEMCACHED_DISTRIBUTION_RANDOM =

SWIG_From_int((int)(MEMCACHED_DISTRIBUTION_RANDOM))

MEMCACHED_BEHAVIOR_NO_BLOCK =

SWIG_From_int((int)(MEMCACHED_BEHAVIOR_NO_BLOCK))

MEMCACHED_BEHAVIOR_TCP_NODELAY =

SWIG_From_int((int)(MEMCACHED_BEHAVIOR_TCP_NODELAY))

MEMCACHED_BEHAVIOR_HASH =

SWIG_From_int((int)(MEMCACHED_BEHAVIOR_HASH))

MEMCACHED_BEHAVIOR_KETAMA =

SWIG_From_int((int)(MEMCACHED_BEHAVIOR_KETAMA))

MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE =

SWIG_From_int((int)(MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE))

MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE =

SWIG_From_int((int)(MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE))

MEMCACHED_BEHAVIOR_CACHE_LOOKUPS =

SWIG_From_int((int)(MEMCACHED_BEHAVIOR_CACHE_LOOKUPS))

MEMCACHED_BEHAVIOR_SUPPORT_CAS =

SWIG_From_int((int)(MEMCACHED_BEHAVIOR_SUPPORT_CAS))

MEMCACHED_BEHAVIOR_POLL_TIMEOUT =

SWIG_From_int((int)(MEMCACHED_BEHAVIOR_POLL_TIMEOUT))

MEMCACHED_BEHAVIOR_POLL_MAX_RETRIES =

SWIG_From_int((int)(MEMCACHED_BEHAVIOR_POLL_MAX_RETRIES))

MEMCACHED_BEHAVIOR_DISTRIBUTION =

SWIG_From_int((int)(MEMCACHED_BEHAVIOR_DISTRIBUTION))

MEMCACHED_BEHAVIOR_BUFFER_REQUESTS =

SWIG_From_int((int)(MEMCACHED_BEHAVIOR_BUFFER_REQUESTS))

MEMCACHED_BEHAVIOR_USER_DATA =

SWIG_From_int((int)(MEMCACHED_BEHAVIOR_USER_DATA))

MEMCACHED_BEHAVIOR_SORT_HOSTS =

SWIG_From_int((int)(MEMCACHED_BEHAVIOR_SORT_HOSTS))

MEMCACHED_BEHAVIOR_VERIFY_KEY =

SWIG_From_int((int)(MEMCACHED_BEHAVIOR_VERIFY_KEY))

MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT =

SWIG_From_int((int)(MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT))

MEMCACHED_BEHAVIOR_RETRY_TIMEOUT =

SWIG_From_int((int)(MEMCACHED_BEHAVIOR_RETRY_TIMEOUT))

MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED =

SWIG_From_int((int)(MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED))

MEMCACHED_BEHAVIOR_KETAMA_HASH =

SWIG_From_int((int)(MEMCACHED_BEHAVIOR_KETAMA_HASH))

MEMCACHED_BEHAVIOR_BINARY_PROTOCOL =

SWIG_From_int((int)(MEMCACHED_BEHAVIOR_BINARY_PROTOCOL))

MEMCACHED_BEHAVIOR_SND_TIMEOUT =

SWIG_From_int((int)(MEMCACHED_BEHAVIOR_SND_TIMEOUT))

MEMCACHED_BEHAVIOR_RCV_TIMEOUT =

SWIG_From_int((int)(MEMCACHED_BEHAVIOR_RCV_TIMEOUT))

MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT =

SWIG_From_int((int)(MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT))

MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK =

SWIG_From_int((int)(MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK))

MEMCACHED_BEHAVIOR_IO_BYTES_WATERMARK =

SWIG_From_int((int)(MEMCACHED_BEHAVIOR_IO_BYTES_WATERMARK))

MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH =

SWIG_From_int((int)(MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH))

MEMCACHED_BEHAVIOR_HASH_WITH_PREFIX_KEY =

SWIG_From_int((int)(MEMCACHED_BEHAVIOR_HASH_WITH_PREFIX_KEY))

MEMCACHED_BEHAVIOR_NOREPLY =

SWIG_From_int((int)(MEMCACHED_BEHAVIOR_NOREPLY))

MEMCACHED_BEHAVIOR_USE_UDP =

SWIG_From_int((int)(MEMCACHED_BEHAVIOR_USE_UDP))

MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS =

SWIG_From_int((int)(MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS))

MEMCACHED_CALLBACK_PREFIX_KEY =

SWIG_From_int((int)(MEMCACHED_CALLBACK_PREFIX_KEY))

MEMCACHED_CALLBACK_USER_DATA =

SWIG_From_int((int)(MEMCACHED_CALLBACK_USER_DATA))

MEMCACHED_CALLBACK_CLEANUP_FUNCTION =

SWIG_From_int((int)(MEMCACHED_CALLBACK_CLEANUP_FUNCTION))

MEMCACHED_CALLBACK_CLONE_FUNCTION =

SWIG_From_int((int)(MEMCACHED_CALLBACK_CLONE_FUNCTION))

MEMCACHED_CALLBACK_GET_FAILURE =

SWIG_From_int((int)(MEMCACHED_CALLBACK_GET_FAILURE))

MEMCACHED_CALLBACK_DELETE_TRIGGER =

SWIG_From_int((int)(MEMCACHED_CALLBACK_DELETE_TRIGGER))

MEMCACHED_HASH_DEFAULT =

SWIG_From_int((int)(MEMCACHED_HASH_DEFAULT))

MEMCACHED_HASH_MD5 =

SWIG_From_int((int)(MEMCACHED_HASH_MD5))

MEMCACHED_HASH_CRC =

SWIG_From_int((int)(MEMCACHED_HASH_CRC))

MEMCACHED_HASH_FNV1_64 =

SWIG_From_int((int)(MEMCACHED_HASH_FNV1_64))

MEMCACHED_HASH_FNV1A_64 =

SWIG_From_int((int)(MEMCACHED_HASH_FNV1A_64))

MEMCACHED_HASH_FNV1_32 =

SWIG_From_int((int)(MEMCACHED_HASH_FNV1_32))

MEMCACHED_HASH_FNV1A_32 =

SWIG_From_int((int)(MEMCACHED_HASH_FNV1A_32))

MEMCACHED_HASH_HSIEH =

SWIG_From_int((int)(MEMCACHED_HASH_HSIEH))

MEMCACHED_HASH_MURMUR =

SWIG_From_int((int)(MEMCACHED_HASH_MURMUR))

MEMCACHED_HASH_JENKINS =

SWIG_From_int((int)(MEMCACHED_HASH_JENKINS))

MEMCACHED_HASH_NONE =

SWIG_From_int((int)(MEMCACHED_HASH_NONE))

MEMCACHED_CONNECTION_UNKNOWN =

SWIG_From_int((int)(MEMCACHED_CONNECTION_UNKNOWN))

MEMCACHED_CONNECTION_TCP =

SWIG_From_int((int)(MEMCACHED_CONNECTION_TCP))

MEMCACHED_CONNECTION_UDP =

SWIG_From_int((int)(MEMCACHED_CONNECTION_UDP))

MEMCACHED_CONNECTION_UNIX_SOCKET =

SWIG_From_int((int)(MEMCACHED_CONNECTION_UNIX_SOCKET))

GET_LEN_ARG_UNSPECIFIED =

SWIG_From_unsigned_SS_int((unsigned int)(-1U))

GET_LEN_BUFSZ =

SWIG_From_int((int)(32))

Class Method Summary collapse

Class Method Details

.memcached_add(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 9371

SWIGINTERN VALUE
_wrap_memcached_add(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  char *arg4 = (char *) 0 ;
  size_t arg5 ;
  time_t arg6 ;
  uint32_t arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val6 ;
  int ecode6 = 0 ;
  unsigned long val7 ;
  int ecode7 = 0 ;
  memcached_return result;
  VALUE vresult = Qnil;
  
  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)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_add", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  {
    VALUE str;
    str = rb_string_value(&argv[1]);
    arg2 = RSTRING_PTR(str);
    arg3 = RSTRING_LEN(str);
  }
  {
    VALUE str;
    str = rb_string_value(&argv[2]);
    arg4 = RSTRING_PTR(str);
    arg5 = RSTRING_LEN(str);
  }
  ecode6 = SWIG_AsVal_unsigned_SS_long(argv[3], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "time_t","memcached_add", 6, argv[3] ));
  } 
  arg6 = (time_t)(val6);
  ecode7 = SWIG_AsVal_unsigned_SS_long(argv[4], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "uint32_t","memcached_add", 7, argv[4] ));
  } 
  arg7 = (uint32_t)(val7);
  result = (memcached_return)memcached_add(arg1,(char const *)arg2,arg3,(char const *)arg4,arg5,arg6,arg7);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.memcached_add_by_key(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 9717

SWIGINTERN VALUE
_wrap_memcached_add_by_key(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  char *arg4 = (char *) 0 ;
  size_t arg5 ;
  char *arg6 = (char *) 0 ;
  size_t arg7 ;
  time_t arg8 ;
  uint32_t arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val8 ;
  int ecode8 = 0 ;
  unsigned long val9 ;
  int ecode9 = 0 ;
  memcached_return result;
  VALUE vresult = Qnil;
  
  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)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_add_by_key", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  {
    VALUE str;
    str = rb_string_value(&argv[1]);
    arg4 = arg2 = RSTRING_PTR(str);
    arg5 = arg3 = RSTRING_LEN(str);
  }
  {
    VALUE str;
    str = rb_string_value(&argv[2]);
    arg6 = RSTRING_PTR(str);
    arg7 = RSTRING_LEN(str);
  }
  ecode8 = SWIG_AsVal_unsigned_SS_long(argv[3], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "time_t","memcached_add_by_key", 8, argv[3] ));
  } 
  arg8 = (time_t)(val8);
  ecode9 = SWIG_AsVal_unsigned_SS_long(argv[4], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "uint32_t","memcached_add_by_key", 9, argv[4] ));
  } 
  arg9 = (uint32_t)(val9);
  result = (memcached_return)memcached_add_by_key(arg1,(char const *)arg2,arg3,(char const *)arg4,arg5,(char const *)arg6,arg7,arg8,arg9);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.memcached_analyze(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 12406

SWIGINTERN VALUE
_wrap_memcached_analyze(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  memcached_stat_st *arg2 = (memcached_stat_st *) 0 ;
  memcached_return *arg3 = (memcached_return *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  memcached_return temp3 ;
  int res3 = SWIG_TMPOBJ ;
  memcached_analysis_st *result = 0 ;
  VALUE vresult = Qnil;
  
  arg3 = &temp3;
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_analyze", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_memcached_stat_st, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "memcached_stat_st *","memcached_analyze", 2, argv[1] )); 
  }
  arg2 = (memcached_stat_st *)(argp2);
  result = (memcached_analysis_st *)memcached_analyze(arg1,arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_memcached_analysis_st, 0 |  0 );
  if (SWIG_IsTmpObj(res3)) {
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_short((*arg3)));
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_memcached_return, new_flags));
  }
  return vresult;
fail:
  return Qnil;
}

.memcached_append(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 9483

SWIGINTERN VALUE
_wrap_memcached_append(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  char *arg4 = (char *) 0 ;
  size_t arg5 ;
  time_t arg6 ;
  uint32_t arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val6 ;
  int ecode6 = 0 ;
  unsigned long val7 ;
  int ecode7 = 0 ;
  memcached_return result;
  VALUE vresult = Qnil;
  
  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)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_append", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  {
    VALUE str;
    str = rb_string_value(&argv[1]);
    arg2 = RSTRING_PTR(str);
    arg3 = RSTRING_LEN(str);
  }
  {
    VALUE str;
    str = rb_string_value(&argv[2]);
    arg4 = RSTRING_PTR(str);
    arg5 = RSTRING_LEN(str);
  }
  ecode6 = SWIG_AsVal_unsigned_SS_long(argv[3], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "time_t","memcached_append", 6, argv[3] ));
  } 
  arg6 = (time_t)(val6);
  ecode7 = SWIG_AsVal_unsigned_SS_long(argv[4], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "uint32_t","memcached_append", 7, argv[4] ));
  } 
  arg7 = (uint32_t)(val7);
  result = (memcached_return)memcached_append(arg1,(char const *)arg2,arg3,(char const *)arg4,arg5,arg6,arg7);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.memcached_append_by_key(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 9891

SWIGINTERN VALUE
_wrap_memcached_append_by_key(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  char *arg4 = (char *) 0 ;
  size_t arg5 ;
  char *arg6 = (char *) 0 ;
  size_t arg7 ;
  time_t arg8 ;
  uint32_t arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val8 ;
  int ecode8 = 0 ;
  unsigned long val9 ;
  int ecode9 = 0 ;
  memcached_return result;
  VALUE vresult = Qnil;
  
  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)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_append_by_key", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  {
    VALUE str;
    str = rb_string_value(&argv[1]);
    arg4 = arg2 = RSTRING_PTR(str);
    arg5 = arg3 = RSTRING_LEN(str);
  }
  {
    VALUE str;
    str = rb_string_value(&argv[2]);
    arg6 = RSTRING_PTR(str);
    arg7 = RSTRING_LEN(str);
  }
  ecode8 = SWIG_AsVal_unsigned_SS_long(argv[3], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "time_t","memcached_append_by_key", 8, argv[3] ));
  } 
  arg8 = (time_t)(val8);
  ecode9 = SWIG_AsVal_unsigned_SS_long(argv[4], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "uint32_t","memcached_append_by_key", 9, argv[4] ));
  } 
  arg9 = (uint32_t)(val9);
  result = (memcached_return)memcached_append_by_key(arg1,(char const *)arg2,arg3,(char const *)arg4,arg5,(char const *)arg6,arg7,arg8,arg9);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.memcached_behavior_get(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 7597

SWIGINTERN VALUE
_wrap_memcached_behavior_get(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  memcached_behavior arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  uint64_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_behavior_get", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "memcached_behavior","memcached_behavior_get", 2, argv[1] ));
  } 
  arg2 = (memcached_behavior)(val2);
  result = memcached_behavior_get(arg1,arg2);
  {
    vresult = ULL2NUM(result);
  }
  return vresult;
fail:
  return Qnil;
}

.memcached_behavior_set(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 7557

SWIGINTERN VALUE
_wrap_memcached_behavior_set(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  memcached_behavior arg2 ;
  uint64_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned long long val3 ;
  int ecode3 = 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_behavior_set", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "memcached_behavior","memcached_behavior_set", 2, argv[1] ));
  } 
  arg2 = (memcached_behavior)(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "uint64_t","memcached_behavior_set", 3, argv[2] ));
  } 
  arg3 = (uint64_t)(val3);
  result = (memcached_return)memcached_behavior_set(arg1,arg2,arg3);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.memcached_callback_get(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 8443

SWIGINTERN VALUE
_wrap_memcached_callback_get(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  memcached_callback arg2 ;
  memcached_return *arg3 = (memcached_return *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  memcached_return temp3 ;
  int res3 = SWIG_TMPOBJ ;
  void *result = 0 ;
  VALUE vresult = Qnil;
  
  arg3 = &temp3;
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_callback_get", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "memcached_callback","memcached_callback_get", 2, argv[1] ));
  } 
  arg2 = (memcached_callback)(val2);
  result = (void *)memcached_callback_get(arg1,arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  if (SWIG_IsTmpObj(res3)) {
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_short((*arg3)));
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_memcached_return, new_flags));
  }
  return vresult;
fail:
  return Qnil;
}

.memcached_callback_set(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 8401

SWIGINTERN VALUE
_wrap_memcached_callback_set(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  memcached_callback arg2 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 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_callback_set", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "memcached_callback","memcached_callback_set", 2, argv[1] ));
  } 
  arg2 = (memcached_callback)(val2);
  {
    VALUE str;
    str = rb_string_value(&argv[2]);
    if (RSTRING_LEN(str) == 0) {
      arg3 = NULL;
    } else {
      arg3 = RSTRING_PTR(str);
    }
  }
  result = (memcached_return)memcached_callback_set(arg1,arg2,arg3);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.memcached_cas(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 9595

SWIGINTERN VALUE
_wrap_memcached_cas(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  char *arg4 = (char *) 0 ;
  size_t arg5 ;
  time_t arg6 ;
  uint32_t arg7 ;
  uint64_t arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val6 ;
  int ecode6 = 0 ;
  unsigned long val7 ;
  int ecode7 = 0 ;
  unsigned long long val8 ;
  int ecode8 = 0 ;
  memcached_return result;
  VALUE vresult = Qnil;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",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_cas", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  {
    VALUE str;
    str = rb_string_value(&argv[1]);
    arg2 = RSTRING_PTR(str);
    arg3 = RSTRING_LEN(str);
  }
  {
    VALUE str;
    str = rb_string_value(&argv[2]);
    arg4 = RSTRING_PTR(str);
    arg5 = RSTRING_LEN(str);
  }
  ecode6 = SWIG_AsVal_unsigned_SS_long(argv[3], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "time_t","memcached_cas", 6, argv[3] ));
  } 
  arg6 = (time_t)(val6);
  ecode7 = SWIG_AsVal_unsigned_SS_long(argv[4], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "uint32_t","memcached_cas", 7, argv[4] ));
  } 
  arg7 = (uint32_t)(val7);
  ecode8 = SWIG_AsVal_unsigned_SS_long_SS_long(argv[5], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "uint64_t","memcached_cas", 8, argv[5] ));
  } 
  arg8 = (uint64_t)(val8);
  result = (memcached_return)memcached_cas(arg1,(char const *)arg2,arg3,(char const *)arg4,arg5,arg6,arg7,arg8);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.memcached_cas_by_key(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 9949

SWIGINTERN VALUE
_wrap_memcached_cas_by_key(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  char *arg4 = (char *) 0 ;
  size_t arg5 ;
  char *arg6 = (char *) 0 ;
  size_t arg7 ;
  time_t arg8 ;
  uint32_t arg9 ;
  uint64_t arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val8 ;
  int ecode8 = 0 ;
  unsigned long val9 ;
  int ecode9 = 0 ;
  unsigned long long val10 ;
  int ecode10 = 0 ;
  memcached_return result;
  VALUE vresult = Qnil;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",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_cas_by_key", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  {
    VALUE str;
    str = rb_string_value(&argv[1]);
    arg4 = arg2 = RSTRING_PTR(str);
    arg5 = arg3 = RSTRING_LEN(str);
  }
  {
    VALUE str;
    str = rb_string_value(&argv[2]);
    arg6 = RSTRING_PTR(str);
    arg7 = RSTRING_LEN(str);
  }
  ecode8 = SWIG_AsVal_unsigned_SS_long(argv[3], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "time_t","memcached_cas_by_key", 8, argv[3] ));
  } 
  arg8 = (time_t)(val8);
  ecode9 = SWIG_AsVal_unsigned_SS_long(argv[4], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "uint32_t","memcached_cas_by_key", 9, argv[4] ));
  } 
  arg9 = (uint32_t)(val9);
  ecode10 = SWIG_AsVal_unsigned_SS_long_SS_long(argv[5], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "uint64_t","memcached_cas_by_key", 10, argv[5] ));
  } 
  arg10 = (uint64_t)(val10);
  result = (memcached_return)memcached_cas_by_key(arg1,(char const *)arg2,arg3,(char const *)arg4,arg5,(char const *)arg6,arg7,arg8,arg9,arg10);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.memcached_clone(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 6984

SWIGINTERN VALUE
_wrap_memcached_clone(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  memcached_st *arg2 = (memcached_st *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  memcached_st *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_clone", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "memcached_st *","memcached_clone", 2, argv[1] )); 
  }
  arg2 = (memcached_st *)(argp2);
  result = (memcached_st *)memcached_clone(arg1,arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_memcached_st, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

.memcached_create(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 6939

SWIGINTERN VALUE
_wrap_memcached_create(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  memcached_st *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_create", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  result = (memcached_st *)memcached_create(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_memcached_st, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

.memcached_decrement(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 7106

SWIGINTERN VALUE
_wrap_memcached_decrement(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  uint32_t arg4 ;
  uint64_t *arg5 = (uint64_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val4 ;
  int ecode4 = 0 ;
  uint64_t temp5 ;
  int res5 = SWIG_TMPOBJ ;
  memcached_return result;
  VALUE vresult = Qnil;
  
  arg5 = &temp5;
  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_decrement", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  {
    VALUE str;
    str = rb_string_value(&argv[1]);
    arg2 = RSTRING_PTR(str);
    arg3 = RSTRING_LEN(str);
  }
  ecode4 = SWIG_AsVal_unsigned_SS_long(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "uint32_t","memcached_decrement", 4, argv[2] ));
  } 
  arg4 = (uint32_t)(val4);
  result = (memcached_return)memcached_decrement(arg1,(char const *)arg2,arg3,arg4,arg5);
  vresult = SWIG_From_int((int)(result));
  if (SWIG_IsTmpObj(res5)) {
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_long_SS_long((*arg5)));
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_uint64_t, new_flags));
  }
  return vresult;
fail:
  return Qnil;
}

.memcached_decrement_with_initial(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 7234

SWIGINTERN VALUE
_wrap_memcached_decrement_with_initial(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  uint64_t arg4 ;
  uint64_t arg5 ;
  time_t arg6 ;
  uint64_t *arg7 = (uint64_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  unsigned long val6 ;
  int ecode6 = 0 ;
  uint64_t temp7 ;
  int res7 = SWIG_TMPOBJ ;
  memcached_return result;
  VALUE vresult = Qnil;
  
  arg7 = &temp7;
  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)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_decrement_with_initial", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  {
    VALUE str;
    str = rb_string_value(&argv[1]);
    arg2 = RSTRING_PTR(str);
    arg3 = RSTRING_LEN(str);
  }
  {
    res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_uint64_t,  0 );
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "uint64_t","memcached_decrement_with_initial", 4, argv[2] )); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "uint64_t","memcached_decrement_with_initial", 4, argv[2]));
    } else {
      arg4 = *((uint64_t *)(argp4));
    }
  }
  {
    res5 = SWIG_ConvertPtr(argv[3], &argp5, SWIGTYPE_p_uint64_t,  0 );
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "uint64_t","memcached_decrement_with_initial", 5, argv[3] )); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "uint64_t","memcached_decrement_with_initial", 5, argv[3]));
    } else {
      arg5 = *((uint64_t *)(argp5));
    }
  }
  ecode6 = SWIG_AsVal_unsigned_SS_long(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "time_t","memcached_decrement_with_initial", 6, argv[4] ));
  } 
  arg6 = (time_t)(val6);
  result = (memcached_return)memcached_decrement_with_initial(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7);
  vresult = SWIG_From_int((int)(result));
  if (SWIG_IsTmpObj(res7)) {
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_long_SS_long((*arg7)));
  } else {
    int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_uint64_t, new_flags));
  }
  return vresult;
fail:
  return Qnil;
}

.memcached_delete(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 7016

SWIGINTERN VALUE
_wrap_memcached_delete(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  time_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val4 ;
  int ecode4 = 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_delete", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  {
    VALUE str;
    str = rb_string_value(&argv[1]);
    arg2 = RSTRING_PTR(str);
    arg3 = RSTRING_LEN(str);
  }
  ecode4 = SWIG_AsVal_unsigned_SS_long(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "time_t","memcached_delete", 4, argv[2] ));
  } 
  arg4 = (time_t)(val4);
  result = (memcached_return)memcached_delete(arg1,(char const *)arg2,arg3,arg4);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.memcached_delete_by_key(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 8313

SWIGINTERN VALUE
_wrap_memcached_delete_by_key(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  char *arg4 = (char *) 0 ;
  size_t arg5 ;
  time_t arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val6 ;
  int ecode6 = 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_delete_by_key", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  {
    VALUE str;
    str = rb_string_value(&argv[1]);
    arg4 = arg2 = RSTRING_PTR(str);
    arg5 = arg3 = RSTRING_LEN(str);
  }
  ecode6 = SWIG_AsVal_unsigned_SS_long(argv[2], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "time_t","memcached_delete_by_key", 6, argv[2] ));
  } 
  arg6 = (time_t)(val6);
  result = (memcached_return)memcached_delete_by_key(arg1,(char const *)arg2,arg3,(char const *)arg4,arg5,arg6);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.memcached_destroy_sasl_auth_data(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 12547

SWIGINTERN VALUE
_wrap_memcached_destroy_sasl_auth_data(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  memcached_return result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_destroy_sasl_auth_data", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  result = (memcached_return)memcached_destroy_sasl_auth_data(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.memcached_dump(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 8485

SWIGINTERN VALUE
_wrap_memcached_dump(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  memcached_dump_func *arg2 = (memcached_dump_func *) 0 ;
  void *arg3 = (void *) 0 ;
  uint32_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  void *argp4 ;
  int res4 = 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;
  }
  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_dump", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_memcached_dump_func, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "memcached_dump_func *","memcached_dump", 2, argv[1] )); 
  }
  arg2 = (memcached_dump_func *)(argp2);
  res3 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "void *","memcached_dump", 3, argv[2] )); 
  }
  {
    res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_uint32_t,  0 );
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "uint32_t","memcached_dump", 4, argv[3] )); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "uint32_t","memcached_dump", 4, argv[3]));
    } else {
      arg4 = *((uint32_t *)(argp4));
    }
  }
  result = (memcached_return)memcached_dump(arg1,arg2,arg3,arg4);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.memcached_exist(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 12718

SWIGINTERN VALUE
_wrap_memcached_exist(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  memcached_return result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_exist", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  {
    VALUE str;
    str = rb_string_value(&argv[1]);
    arg2 = RSTRING_PTR(str);
    arg3 = RSTRING_LEN(str);
  }
  result = (memcached_return)memcached_exist(arg1,(char const *)arg2,arg3);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.memcached_exist_by_key(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 12750

SWIGINTERN VALUE
_wrap_memcached_exist_by_key(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  char *arg4 = (char *) 0 ;
  size_t arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  size_t val3 ;
  int ecode3 = 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;
  }
  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_exist_by_key", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","memcached_exist_by_key", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","memcached_exist_by_key", 3, argv[2] ));
  } 
  arg3 = (size_t)(val3);
  {
    VALUE str;
    str = rb_string_value(&argv[3]);
    arg4 = RSTRING_PTR(str);
    arg5 = RSTRING_LEN(str);
  }
  result = (memcached_return)memcached_exist_by_key(arg1,(char const *)arg2,arg3,(char const *)arg4,arg5);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.memcached_fetch(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 9135

SWIGINTERN VALUE
_wrap_memcached_fetch(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 = (size_t *) 0 ;
  uint32_t *arg5 = (uint32_t *) 0 ;
  memcached_return *arg6 = (memcached_return *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t temp4 ;
  int res4 = SWIG_TMPOBJ ;
  uint32_t temp5 ;
  int res5 = SWIG_TMPOBJ ;
  memcached_return temp6 ;
  int res6 = SWIG_TMPOBJ ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  arg4 = &temp4;
  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_fetch", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","memcached_fetch", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_size_t, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "size_t *","memcached_fetch", 3, argv[2] )); 
  }
  arg3 = (size_t *)(argp3);
  result = (char *)memcached_fetch(arg1,arg2,arg3,arg4,arg5,arg6);
  vresult = SWIG_FromCharPtr((const char *)result);
  {
    rb_ary_push(vresult, rb_str_new(arg2, *arg3));
  }
  if (SWIG_IsTmpObj(res4)) {
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_size_t((*arg4)));
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_size_t, new_flags));
  }
  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));
  }
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.memcached_fetch_execute(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 8355

SWIGINTERN VALUE
_wrap_memcached_fetch_execute(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  memcached_execute_function *arg2 = (memcached_execute_function *) 0 ;
  void *arg3 = (void *) 0 ;
  unsigned int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  unsigned int val4 ;
  int ecode4 = 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;
  }
  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_fetch_execute", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_memcached_execute_function, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "memcached_execute_function *","memcached_fetch_execute", 2, argv[1] )); 
  }
  arg2 = (memcached_execute_function *)(argp2);
  res3 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "void *","memcached_fetch_execute", 3, argv[2] )); 
  }
  ecode4 = SWIG_AsVal_unsigned_SS_int(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "unsigned int","memcached_fetch_execute", 4, argv[3] ));
  } 
  arg4 = (unsigned int)(val4);
  result = (memcached_return)memcached_fetch_execute(arg1,arg2,arg3,arg4);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.memcached_fetch_result(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 9211

SWIGINTERN VALUE
_wrap_memcached_fetch_result(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  memcached_result_st *arg2 = (memcached_result_st *) 0 ;
  memcached_return *arg3 = (memcached_return *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  memcached_return temp3 ;
  int res3 = SWIG_TMPOBJ ;
  memcached_result_st *result = 0 ;
  VALUE vresult = Qnil;
  
  arg3 = &temp3;
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_fetch_result", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_memcached_result_st, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "memcached_result_st *","memcached_fetch_result", 2, argv[1] )); 
  }
  arg2 = (memcached_result_st *)(argp2);
  result = (memcached_result_st *)memcached_fetch_result(arg1,arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_memcached_result_st, 0 |  0 );
  if (SWIG_IsTmpObj(res3)) {
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_short((*arg3)));
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_memcached_return, new_flags));
  }
  return vresult;
fail:
  return Qnil;
}

.memcached_fetch_rvalue(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 12853

SWIGINTERN VALUE
_wrap_memcached_fetch_rvalue(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  char **arg2 = (char **) 0 ;
  size_t *arg3 = (size_t *) 0 ;
  uint32_t *arg4 = (uint32_t *) 0 ;
  memcached_return *arg5 = (memcached_return *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uint32_t temp4 ;
  int res4 = SWIG_TMPOBJ ;
  memcached_return temp5 ;
  int res5 = SWIG_TMPOBJ ;
  VALUE result;
  VALUE vresult = Qnil;
  
  {
    const char *key_ptr;
    size_t key_length_ptr;
    arg2 = &key_ptr;
    arg3 = &key_length_ptr;
  }
  arg4 = &temp4;
  arg5 = &temp5;
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_fetch_rvalue", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  result = (VALUE)memcached_fetch_rvalue(arg1,(char const **)arg2,arg3,arg4,arg5);
  vresult = result;
  {
    rb_ary_push(vresult, rb_str_new(*arg2, *arg3));
  }
  if (SWIG_IsTmpObj(res4)) {
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_int((*arg4)));
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_uint32_t, new_flags));
  }
  if (SWIG_IsTmpObj(res5)) {
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_short((*arg5)));
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_memcached_return, new_flags));
  }
  return vresult;
fail:
  return Qnil;
}

.memcached_flush(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 7440

SWIGINTERN VALUE
_wrap_memcached_flush(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  time_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  memcached_return result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_flush", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "time_t","memcached_flush", 2, argv[1] ));
  } 
  arg2 = (time_t)(val2);
  result = (memcached_return)memcached_flush(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.memcached_flush_buffers(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 7699

SWIGINTERN VALUE
_wrap_memcached_flush_buffers(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  memcached_return result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_flush_buffers", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  result = (memcached_return)memcached_flush_buffers(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.memcached_free(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 6963

SWIGINTERN VALUE
_wrap_memcached_free(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(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_free", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  memcached_free(arg1);
  return Qnil;
fail:
  return Qnil;
}

.memcached_generate_hash(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 7665

SWIGINTERN VALUE
_wrap_memcached_generate_hash(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uint32_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_generate_hash", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  {
    VALUE str;
    str = rb_string_value(&argv[1]);
    arg2 = RSTRING_PTR(str);
    arg3 = RSTRING_LEN(str);
  }
  result = memcached_generate_hash(arg1,(char const *)arg2,arg3);
  {
    vresult = UINT2NUM(result);
  }
  return vresult;
fail:
  return Qnil;
}

.memcached_generate_hash_rvalue(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 13032

SWIGINTERN VALUE
_wrap_memcached_generate_hash_rvalue(int argc, VALUE *argv, VALUE self) {
  char *arg1 = (char *) 0 ;
  size_t arg2 ;
  memcached_hash arg3 ;
  int val3 ;
  int ecode3 = 0 ;
  VALUE result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  {
    VALUE str;
    str = rb_string_value(&argv[0]);
    arg1 = RSTRING_PTR(str);
    arg2 = RSTRING_LEN(str);
  }
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "memcached_hash","memcached_generate_hash_rvalue", 3, argv[1] ));
  } 
  arg3 = (memcached_hash)(val3);
  result = (VALUE)memcached_generate_hash_rvalue((char const *)arg1,arg2,arg3);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

.memcached_generate_hash_value(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 7631

SWIGINTERN VALUE
_wrap_memcached_generate_hash_value(int argc, VALUE *argv, VALUE self) {
  char *arg1 = (char *) 0 ;
  size_t arg2 ;
  memcached_hash arg3 ;
  int val3 ;
  int ecode3 = 0 ;
  uint32_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  {
    VALUE str;
    str = rb_string_value(&argv[0]);
    arg1 = RSTRING_PTR(str);
    arg2 = RSTRING_LEN(str);
  }
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "memcached_hash","memcached_generate_hash_value", 3, argv[1] ));
  } 
  arg3 = (memcached_hash)(val3);
  result = memcached_generate_hash_value((char const *)arg1,arg2,arg3);
  {
    vresult = UINT2NUM(result);
  }
  return vresult;
fail:
  return Qnil;
}

.memcached_get(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 8752

SWIGINTERN VALUE
_wrap_memcached_get(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  size_t *arg4 = (size_t *) 0 ;
  uint32_t *arg5 = (uint32_t *) 0 ;
  memcached_return *arg6 = (memcached_return *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t temp4 ;
  int res4 = SWIG_TMPOBJ ;
  uint32_t temp5 ;
  int res5 = SWIG_TMPOBJ ;
  memcached_return temp6 ;
  int res6 = SWIG_TMPOBJ ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  arg4 = &temp4;
  arg5 = &temp5;
  arg6 = &temp6;
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_get", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  {
    VALUE str;
    str = rb_string_value(&argv[1]);
    arg2 = RSTRING_PTR(str);
    arg3 = RSTRING_LEN(str);
  }
  result = (char *)memcached_get(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
  vresult = SWIG_FromCharPtr((const char *)result);
  if (SWIG_IsTmpObj(res4)) {
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_size_t((*arg4)));
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_size_t, new_flags));
  }
  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;
}

.memcached_get_by_key(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 8988

SWIGINTERN VALUE
_wrap_memcached_get_by_key(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  char *arg4 = (char *) 0 ;
  size_t arg5 ;
  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 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  size_t temp7 ;
  int res7 = SWIG_TMPOBJ ;
  uint32_t temp8 ;
  int res8 = SWIG_TMPOBJ ;
  memcached_return temp9 ;
  int res9 = SWIG_TMPOBJ ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  arg7 = &temp7;
  arg8 = &temp8;
  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)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_get_by_key", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  {
    VALUE str;
    str = rb_string_value(&argv[1]);
    arg4 = arg2 = RSTRING_PTR(str);
    arg5 = arg3 = RSTRING_LEN(str);
  }
  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(res7)) {
    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_size_t, new_flags));
  }
  if (SWIG_IsTmpObj(res8)) {
    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_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:
  return Qnil;
}

.memcached_get_from_last(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 9253

SWIGINTERN VALUE
_wrap_memcached_get_from_last(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  size_t *arg4 = (size_t *) 0 ;
  uint32_t *arg5 = (uint32_t *) 0 ;
  memcached_return *arg6 = (memcached_return *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t temp4 ;
  int res4 = SWIG_TMPOBJ ;
  uint32_t temp5 ;
  int res5 = SWIG_TMPOBJ ;
  memcached_return temp6 ;
  int res6 = SWIG_TMPOBJ ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  arg4 = &temp4;
  arg5 = &temp5;
  arg6 = &temp6;
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_get_from_last", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  {
    VALUE str;
    str = rb_string_value(&argv[1]);
    arg2 = RSTRING_PTR(str);
    arg3 = RSTRING_LEN(str);
  }
  result = (char *)memcached_get_from_last(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
  vresult = SWIG_FromCharPtr((const char *)result);
  if (SWIG_IsTmpObj(res4)) {
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_size_t((*arg4)));
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_size_t, new_flags));
  }
  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;
}

.memcached_get_from_last_rvalue(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 12801

SWIGINTERN VALUE
_wrap_memcached_get_from_last_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 *) 0 ;
  memcached_return *arg5 = (memcached_return *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uint32_t temp4 ;
  int res4 = SWIG_TMPOBJ ;
  memcached_return temp5 ;
  int res5 = SWIG_TMPOBJ ;
  VALUE result;
  VALUE vresult = Qnil;
  
  arg4 = &temp4;
  arg5 = &temp5;
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_get_from_last_rvalue", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  {
    VALUE str;
    str = rb_string_value(&argv[1]);
    arg2 = RSTRING_PTR(str);
    arg3 = RSTRING_LEN(str);
  }
  result = (VALUE)memcached_get_from_last_rvalue(arg1,(char const *)arg2,arg3,arg4,arg5);
  vresult = result;
  if (SWIG_IsTmpObj(res4)) {
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_int((*arg4)));
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_uint32_t, new_flags));
  }
  if (SWIG_IsTmpObj(res5)) {
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_short((*arg5)));
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_memcached_return, new_flags));
  }
  return vresult;
fail:
  return Qnil;
}

.memcached_get_len(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 8814

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);
  {
    VALUE str;
    str = rb_string_value(&argv[1]);
    arg2 = RSTRING_PTR(str);
    arg3 = RSTRING_LEN(str);
  }
  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;
}

.memcached_get_memory_allocators(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 8617

SWIGINTERN VALUE
_wrap_memcached_get_memory_allocators(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  memcached_malloc_function *arg2 = (memcached_malloc_function *) 0 ;
  memcached_free_function *arg3 = (memcached_free_function *) 0 ;
  memcached_realloc_function *arg4 = (memcached_realloc_function *) 0 ;
  memcached_calloc_function *arg5 = (memcached_calloc_function *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  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)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_get_memory_allocators", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_memcached_malloc_function, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "memcached_malloc_function *","memcached_get_memory_allocators", 2, argv[1] )); 
  }
  arg2 = (memcached_malloc_function *)(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_memcached_free_function, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "memcached_free_function *","memcached_get_memory_allocators", 3, argv[2] )); 
  }
  arg3 = (memcached_free_function *)(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_memcached_realloc_function, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "memcached_realloc_function *","memcached_get_memory_allocators", 4, argv[3] )); 
  }
  arg4 = (memcached_realloc_function *)(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_memcached_calloc_function, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "memcached_calloc_function *","memcached_get_memory_allocators", 5, argv[4] )); 
  }
  arg5 = (memcached_calloc_function *)(argp5);
  memcached_get_memory_allocators(arg1,arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}

.memcached_get_rvalue(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 12908

SWIGINTERN VALUE
_wrap_memcached_get_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 *) 0 ;
  memcached_return *arg5 = (memcached_return *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uint32_t temp4 ;
  int res4 = SWIG_TMPOBJ ;
  memcached_return temp5 ;
  int res5 = SWIG_TMPOBJ ;
  VALUE result;
  VALUE vresult = Qnil;
  
  arg4 = &temp4;
  arg5 = &temp5;
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_get_rvalue", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  {
    VALUE str;
    str = rb_string_value(&argv[1]);
    arg2 = RSTRING_PTR(str);
    arg3 = RSTRING_LEN(str);
  }
  result = (VALUE)memcached_get_rvalue(arg1,(char const *)arg2,arg3,arg4,arg5);
  vresult = result;
  if (SWIG_IsTmpObj(res4)) {
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_int((*arg4)));
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_uint32_t, new_flags));
  }
  if (SWIG_IsTmpObj(res5)) {
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_short((*arg5)));
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_memcached_return, new_flags));
  }
  return vresult;
fail:
  return Qnil;
}

.memcached_get_sasl_callbacks(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 12571

SWIGINTERN VALUE
_wrap_memcached_get_sasl_callbacks(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  sasl_callback_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_get_sasl_callbacks", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  result = (sasl_callback_t *)memcached_get_sasl_callbacks(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sasl_callback_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.memcached_get_user_data(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 8670

SWIGINTERN VALUE
_wrap_memcached_get_user_data(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_get_user_data", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  result = (void *)memcached_get_user_data(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.memcached_increment(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 7056

SWIGINTERN VALUE
_wrap_memcached_increment(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  uint32_t arg4 ;
  uint64_t *arg5 = (uint64_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val4 ;
  int ecode4 = 0 ;
  uint64_t temp5 ;
  int res5 = SWIG_TMPOBJ ;
  memcached_return result;
  VALUE vresult = Qnil;
  
  arg5 = &temp5;
  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_increment", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  {
    VALUE str;
    str = rb_string_value(&argv[1]);
    arg2 = RSTRING_PTR(str);
    arg3 = RSTRING_LEN(str);
  }
  ecode4 = SWIG_AsVal_unsigned_SS_long(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "uint32_t","memcached_increment", 4, argv[2] ));
  } 
  arg4 = (uint32_t)(val4);
  result = (memcached_return)memcached_increment(arg1,(char const *)arg2,arg3,arg4,arg5);
  vresult = SWIG_From_int((int)(result));
  if (SWIG_IsTmpObj(res5)) {
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_long_SS_long((*arg5)));
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_uint64_t, new_flags));
  }
  return vresult;
fail:
  return Qnil;
}

.memcached_increment_with_initial(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 7156

SWIGINTERN VALUE
_wrap_memcached_increment_with_initial(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  uint64_t arg4 ;
  uint64_t arg5 ;
  time_t arg6 ;
  uint64_t *arg7 = (uint64_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  unsigned long val6 ;
  int ecode6 = 0 ;
  uint64_t temp7 ;
  int res7 = SWIG_TMPOBJ ;
  memcached_return result;
  VALUE vresult = Qnil;
  
  arg7 = &temp7;
  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)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_increment_with_initial", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  {
    VALUE str;
    str = rb_string_value(&argv[1]);
    arg2 = RSTRING_PTR(str);
    arg3 = RSTRING_LEN(str);
  }
  {
    res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_uint64_t,  0 );
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "uint64_t","memcached_increment_with_initial", 4, argv[2] )); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "uint64_t","memcached_increment_with_initial", 4, argv[2]));
    } else {
      arg4 = *((uint64_t *)(argp4));
    }
  }
  {
    res5 = SWIG_ConvertPtr(argv[3], &argp5, SWIGTYPE_p_uint64_t,  0 );
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "uint64_t","memcached_increment_with_initial", 5, argv[3] )); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "uint64_t","memcached_increment_with_initial", 5, argv[3]));
    } else {
      arg5 = *((uint64_t *)(argp5));
    }
  }
  ecode6 = SWIG_AsVal_unsigned_SS_long(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "time_t","memcached_increment_with_initial", 6, argv[4] ));
  } 
  arg6 = (time_t)(val6);
  result = (memcached_return)memcached_increment_with_initial(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7);
  vresult = SWIG_From_int((int)(result));
  if (SWIG_IsTmpObj(res7)) {
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_long_SS_long((*arg7)));
  } else {
    int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_uint64_t, new_flags));
  }
  return vresult;
fail:
  return Qnil;
}

.memcached_lib_version(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 6923

SWIGINTERN VALUE
_wrap_memcached_lib_version(int argc, VALUE *argv, VALUE self) {
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (char *)memcached_lib_version();
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.memcached_mget(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 8884

SWIGINTERN VALUE
_wrap_memcached_mget(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 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  memcached_return result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_mget", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  {
    unsigned int i;
    VALUE str;
    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 ++) {
      str = rb_string_value(&RARRAY_PTR(argv[1])[i]);
      arg2[i] = RSTRING_PTR(str);
      arg3[i] = RSTRING_LEN(str);
    }
  }
  result = (memcached_return)memcached_mget(arg1,(char const **)arg2,arg3,arg4);
  vresult = SWIG_From_int((int)(result));
  {
    free(arg2);
    free(arg3);
  }
  return vresult;
fail:
  {
    free(arg2);
    free(arg3);
  }
  return Qnil;
}

.memcached_mget_by_key(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 9060

SWIGINTERN VALUE
_wrap_memcached_mget_by_key(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  char **arg4 = (char **) 0 ;
  size_t *arg5 = (size_t *) 0 ;
  size_t arg6 ;
  uint32_t arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  unsigned int val7 ;
  int ecode7 = 0 ;
  memcached_return result;
  VALUE vresult = Qnil;
  
  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)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_mget_by_key", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","memcached_mget_by_key", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","memcached_mget_by_key", 3, argv[2] ));
  } 
  arg3 = (size_t)(val3);
  {
    unsigned int i;
    VALUE str;
    Check_Type(argv[3], T_ARRAY);
    arg6 = (unsigned int) RARRAY_LEN(argv[3]);
    arg5 = (size_t *) malloc((arg6+1)*sizeof(size_t));
    arg4 = (char **) malloc((arg6+1)*sizeof(char *));
    for(i = 0; i < arg6; i ++) {
      str = rb_string_value(&RARRAY_PTR(argv[3])[i]);
      arg4[i] = RSTRING_PTR(str);
      arg5[i] = RSTRING_LEN(str);
    }
  }
  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);
  {
    free(arg4);
    free(arg5);
  }
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  {
    free(arg4);
    free(arg5);
  }
  return Qnil;
}

.memcached_mget_len(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 8932

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);
  {
    unsigned int i;
    VALUE str;
    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 ++) {
      str = rb_string_value(&RARRAY_PTR(argv[1])[i]);
      arg2[i] = RSTRING_PTR(str);
      arg3[i] = RSTRING_LEN(str);
    }
  }
  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));
  {
    free(arg2);
    free(arg3);
  }
  return vresult;
fail:
  {
    free(arg2);
    free(arg3);
  }
  return Qnil;
}

.memcached_prepend(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 9539

SWIGINTERN VALUE
_wrap_memcached_prepend(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  char *arg4 = (char *) 0 ;
  size_t arg5 ;
  time_t arg6 ;
  uint32_t arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val6 ;
  int ecode6 = 0 ;
  unsigned long val7 ;
  int ecode7 = 0 ;
  memcached_return result;
  VALUE vresult = Qnil;
  
  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)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_prepend", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  {
    VALUE str;
    str = rb_string_value(&argv[1]);
    arg2 = RSTRING_PTR(str);
    arg3 = RSTRING_LEN(str);
  }
  {
    VALUE str;
    str = rb_string_value(&argv[2]);
    arg4 = RSTRING_PTR(str);
    arg5 = RSTRING_LEN(str);
  }
  ecode6 = SWIG_AsVal_unsigned_SS_long(argv[3], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "time_t","memcached_prepend", 6, argv[3] ));
  } 
  arg6 = (time_t)(val6);
  ecode7 = SWIG_AsVal_unsigned_SS_long(argv[4], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "uint32_t","memcached_prepend", 7, argv[4] ));
  } 
  arg7 = (uint32_t)(val7);
  result = (memcached_return)memcached_prepend(arg1,(char const *)arg2,arg3,(char const *)arg4,arg5,arg6,arg7);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.memcached_prepend_by_key(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 9833

SWIGINTERN VALUE
_wrap_memcached_prepend_by_key(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  char *arg4 = (char *) 0 ;
  size_t arg5 ;
  char *arg6 = (char *) 0 ;
  size_t arg7 ;
  time_t arg8 ;
  uint32_t arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val8 ;
  int ecode8 = 0 ;
  unsigned long val9 ;
  int ecode9 = 0 ;
  memcached_return result;
  VALUE vresult = Qnil;
  
  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)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_prepend_by_key", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  {
    VALUE str;
    str = rb_string_value(&argv[1]);
    arg4 = arg2 = RSTRING_PTR(str);
    arg5 = arg3 = RSTRING_LEN(str);
  }
  {
    VALUE str;
    str = rb_string_value(&argv[2]);
    arg6 = RSTRING_PTR(str);
    arg7 = RSTRING_LEN(str);
  }
  ecode8 = SWIG_AsVal_unsigned_SS_long(argv[3], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "time_t","memcached_prepend_by_key", 8, argv[3] ));
  } 
  arg8 = (time_t)(val8);
  ecode9 = SWIG_AsVal_unsigned_SS_long(argv[4], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "uint32_t","memcached_prepend_by_key", 9, argv[4] ));
  } 
  arg9 = (uint32_t)(val9);
  result = (memcached_return)memcached_prepend_by_key(arg1,(char const *)arg2,arg3,(char const *)arg4,arg5,(char const *)arg6,arg7,arg8,arg9);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.memcached_quit(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 7504

SWIGINTERN VALUE
_wrap_memcached_quit(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(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_quit", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  memcached_quit(arg1);
  return Qnil;
fail:
  return Qnil;
}

.memcached_replace(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 9427

SWIGINTERN VALUE
_wrap_memcached_replace(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  char *arg4 = (char *) 0 ;
  size_t arg5 ;
  time_t arg6 ;
  uint32_t arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val6 ;
  int ecode6 = 0 ;
  unsigned long val7 ;
  int ecode7 = 0 ;
  memcached_return result;
  VALUE vresult = Qnil;
  
  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)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_replace", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  {
    VALUE str;
    str = rb_string_value(&argv[1]);
    arg2 = RSTRING_PTR(str);
    arg3 = RSTRING_LEN(str);
  }
  {
    VALUE str;
    str = rb_string_value(&argv[2]);
    arg4 = RSTRING_PTR(str);
    arg5 = RSTRING_LEN(str);
  }
  ecode6 = SWIG_AsVal_unsigned_SS_long(argv[3], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "time_t","memcached_replace", 6, argv[3] ));
  } 
  arg6 = (time_t)(val6);
  ecode7 = SWIG_AsVal_unsigned_SS_long(argv[4], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "uint32_t","memcached_replace", 7, argv[4] ));
  } 
  arg7 = (uint32_t)(val7);
  result = (memcached_return)memcached_replace(arg1,(char const *)arg2,arg3,(char const *)arg4,arg5,arg6,arg7);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.memcached_replace_by_key(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 9775

SWIGINTERN VALUE
_wrap_memcached_replace_by_key(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  char *arg4 = (char *) 0 ;
  size_t arg5 ;
  char *arg6 = (char *) 0 ;
  size_t arg7 ;
  time_t arg8 ;
  uint32_t arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val8 ;
  int ecode8 = 0 ;
  unsigned long val9 ;
  int ecode9 = 0 ;
  memcached_return result;
  VALUE vresult = Qnil;
  
  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)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_replace_by_key", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  {
    VALUE str;
    str = rb_string_value(&argv[1]);
    arg4 = arg2 = RSTRING_PTR(str);
    arg5 = arg3 = RSTRING_LEN(str);
  }
  {
    VALUE str;
    str = rb_string_value(&argv[2]);
    arg6 = RSTRING_PTR(str);
    arg7 = RSTRING_LEN(str);
  }
  ecode8 = SWIG_AsVal_unsigned_SS_long(argv[3], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "time_t","memcached_replace_by_key", 8, argv[3] ));
  } 
  arg8 = (time_t)(val8);
  ecode9 = SWIG_AsVal_unsigned_SS_long(argv[4], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "uint32_t","memcached_replace_by_key", 9, argv[4] ));
  } 
  arg9 = (uint32_t)(val9);
  result = (memcached_return)memcached_replace_by_key(arg1,(char const *)arg2,arg3,(char const *)arg4,arg5,(char const *)arg6,arg7,arg8,arg9);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.memcached_result_create(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 10532

SWIGINTERN VALUE
_wrap_memcached_result_create(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  memcached_result_st *arg2 = (memcached_result_st *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  memcached_result_st *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_result_create", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_memcached_result_st, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "memcached_result_st *","memcached_result_create", 2, argv[1] )); 
  }
  arg2 = (memcached_result_st *)(argp2);
  result = (memcached_result_st *)memcached_result_create(arg1,arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_memcached_result_st, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.memcached_result_free(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 10490

SWIGINTERN VALUE
_wrap_memcached_result_free(int argc, VALUE *argv, VALUE self) {
  memcached_result_st *arg1 = (memcached_result_st *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_result_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_result_st *","memcached_result_free", 1, argv[0] )); 
  }
  arg1 = (memcached_result_st *)(argp1);
  memcached_result_free(arg1);
  return Qnil;
fail:
  return Qnil;
}

.memcached_result_length(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 10588

SWIGINTERN VALUE
_wrap_memcached_result_length(int argc, VALUE *argv, VALUE self) {
  memcached_result_st *arg1 = (memcached_result_st *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_result_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_result_st *","memcached_result_length", 1, argv[0] )); 
  }
  arg1 = (memcached_result_st *)(argp1);
  result = memcached_result_length(arg1);
  vresult = SWIG_From_size_t((size_t)(result));
  return vresult;
fail:
  return Qnil;
}

.memcached_result_reset(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 10511

SWIGINTERN VALUE
_wrap_memcached_result_reset(int argc, VALUE *argv, VALUE self) {
  memcached_result_st *arg1 = (memcached_result_st *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_result_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_result_st *","memcached_result_reset", 1, argv[0] )); 
  }
  arg1 = (memcached_result_st *)(argp1);
  memcached_result_reset(arg1);
  return Qnil;
fail:
  return Qnil;
}

.memcached_result_set_value(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 10612

SWIGINTERN VALUE
_wrap_memcached_result_set_value(int argc, VALUE *argv, VALUE self) {
  memcached_result_st *arg1 = (memcached_result_st *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  size_t val3 ;
  int ecode3 = 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_result_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_result_st *","memcached_result_set_value", 1, argv[0] )); 
  }
  arg1 = (memcached_result_st *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","memcached_result_set_value", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","memcached_result_set_value", 3, argv[2] ));
  } 
  arg3 = (size_t)(val3);
  result = (memcached_return)memcached_result_set_value(arg1,(char const *)arg2,arg3);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.memcached_result_value(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 10564

SWIGINTERN VALUE
_wrap_memcached_result_value(int argc, VALUE *argv, VALUE self) {
  memcached_result_st *arg1 = (memcached_result_st *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_result_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_result_st *","memcached_result_value", 1, argv[0] )); 
  }
  arg1 = (memcached_result_st *)(argp1);
  result = (char *)memcached_result_value(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.memcached_sasl_authenticate_connection(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 12595

SWIGINTERN VALUE
_wrap_memcached_sasl_authenticate_connection(int argc, VALUE *argv, VALUE self) {
  memcached_server_st *arg1 = (memcached_server_st *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  memcached_return result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_server_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_server_st *","memcached_sasl_authenticate_connection", 1, argv[0] )); 
  }
  arg1 = (memcached_server_st *)(argp1);
  result = (memcached_return)memcached_sasl_authenticate_connection(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.memcached_select_server_at(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 12960

SWIGINTERN VALUE
_wrap_memcached_select_server_at(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  memcached_server_st *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_select_server_at", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","memcached_select_server_at", 2, argv[1] ));
  } 
  arg2 = (int)(val2);
  result = (memcached_server_st *)memcached_select_server_at(arg1,arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_memcached_server_st, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.memcached_select_stat_at(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 12992

SWIGINTERN VALUE
_wrap_memcached_select_stat_at(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  memcached_stat_st *arg2 = (memcached_stat_st *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  memcached_stat_st *result = 0 ;
  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_select_stat_at", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_memcached_stat_st, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "memcached_stat_st *","memcached_select_stat_at", 2, argv[1] )); 
  }
  arg2 = (memcached_stat_st *)(argp2);
  ecode3 = SWIG_AsVal_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","memcached_select_stat_at", 3, argv[2] ));
  } 
  arg3 = (int)(val3);
  result = (memcached_stat_st *)memcached_select_stat_at(arg1,arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_memcached_stat_st, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.memcached_server_add(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 7801

SWIGINTERN VALUE
_wrap_memcached_server_add(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  char *arg2 = (char *) 0 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 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_server_add", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","memcached_server_add", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","memcached_server_add", 3, argv[2] ));
  } 
  arg3 = (unsigned int)(val3);
  result = (memcached_return)memcached_server_add(arg1,(char const *)arg2,arg3);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.memcached_server_add_udp(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 7723

SWIGINTERN VALUE
_wrap_memcached_server_add_udp(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  char *arg2 = (char *) 0 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 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_server_add_udp", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","memcached_server_add_udp", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","memcached_server_add_udp", 3, argv[2] ));
  } 
  arg3 = (unsigned int)(val3);
  result = (memcached_return)memcached_server_add_udp(arg1,(char const *)arg2,arg3);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.memcached_server_add_udp_with_weight(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 7844

SWIGINTERN VALUE
_wrap_memcached_server_add_udp_with_weight(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  char *arg2 = (char *) 0 ;
  unsigned int arg3 ;
  uint32_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned long val4 ;
  int ecode4 = 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;
  }
  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_server_add_udp_with_weight", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","memcached_server_add_udp_with_weight", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","memcached_server_add_udp_with_weight", 3, argv[2] ));
  } 
  arg3 = (unsigned int)(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_long(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "uint32_t","memcached_server_add_udp_with_weight", 4, argv[3] ));
  } 
  arg4 = (uint32_t)(val4);
  result = (memcached_return)memcached_server_add_udp_with_weight(arg1,(char const *)arg2,arg3,arg4);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.memcached_server_add_unix_socket(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 7766

SWIGINTERN VALUE
_wrap_memcached_server_add_unix_socket(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  memcached_return result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_server_add_unix_socket", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","memcached_server_add_unix_socket", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  result = (memcached_return)memcached_server_add_unix_socket(arg1,(char const *)arg2);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.memcached_server_add_unix_socket_with_weight(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 7895

SWIGINTERN VALUE
_wrap_memcached_server_add_unix_socket_with_weight(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  char *arg2 = (char *) 0 ;
  uint32_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  unsigned long val3 ;
  int ecode3 = 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_server_add_unix_socket_with_weight", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","memcached_server_add_unix_socket_with_weight", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  ecode3 = SWIG_AsVal_unsigned_SS_long(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "uint32_t","memcached_server_add_unix_socket_with_weight", 3, argv[2] ));
  } 
  arg3 = (uint32_t)(val3);
  result = (memcached_return)memcached_server_add_unix_socket_with_weight(arg1,(char const *)arg2,arg3);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.memcached_server_add_with_weight(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 7938

SWIGINTERN VALUE
_wrap_memcached_server_add_with_weight(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  char *arg2 = (char *) 0 ;
  unsigned int arg3 ;
  uint32_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned long val4 ;
  int ecode4 = 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;
  }
  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_server_add_with_weight", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","memcached_server_add_with_weight", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","memcached_server_add_with_weight", 3, argv[2] ));
  } 
  arg3 = (unsigned int)(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_long(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "uint32_t","memcached_server_add_with_weight", 4, argv[3] ));
  } 
  arg4 = (uint32_t)(val4);
  result = (memcached_return)memcached_server_add_with_weight(arg1,(char const *)arg2,arg3,arg4);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.memcached_server_by_key(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 12167

SWIGINTERN VALUE
_wrap_memcached_server_by_key(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  memcached_return *arg4 = (memcached_return *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  memcached_return temp4 ;
  int res4 = SWIG_TMPOBJ ;
  memcached_server_st *result = 0 ;
  VALUE vresult = Qnil;
  
  arg4 = &temp4;
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_server_by_key", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  {
    VALUE str;
    str = rb_string_value(&argv[1]);
    arg2 = RSTRING_PTR(str);
    arg3 = RSTRING_LEN(str);
  }
  result = (memcached_server_st *)memcached_server_by_key(arg1,(char const *)arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_memcached_server_st, 0 |  0 );
  if (SWIG_IsTmpObj(res4)) {
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_short((*arg4)));
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_memcached_return, new_flags));
  }
  return vresult;
fail:
  return Qnil;
}

.memcached_server_clone(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 12374

SWIGINTERN VALUE
_wrap_memcached_server_clone(int argc, VALUE *argv, VALUE self) {
  memcached_server_st *arg1 = (memcached_server_st *) 0 ;
  memcached_server_st *arg2 = (memcached_server_st *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  memcached_server_st *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_server_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_server_st *","memcached_server_clone", 1, argv[0] )); 
  }
  arg1 = (memcached_server_st *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_memcached_server_st, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "memcached_server_st *","memcached_server_clone", 2, argv[1] )); 
  }
  arg2 = (memcached_server_st *)(argp2);
  result = (memcached_server_st *)memcached_server_clone(arg1,arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_memcached_server_st, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.memcached_server_create(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 12254

SWIGINTERN VALUE
_wrap_memcached_server_create(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  memcached_server_st *arg2 = (memcached_server_st *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  memcached_server_st *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_server_create", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_memcached_server_st, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "memcached_server_st *","memcached_server_create", 2, argv[1] )); 
  }
  arg2 = (memcached_server_st *)(argp2);
  result = (memcached_server_st *)memcached_server_create(arg1,arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_memcached_server_st, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.memcached_server_create_with(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 12286

SWIGINTERN VALUE
_wrap_memcached_server_create_with(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  memcached_server_st *arg2 = (memcached_server_st *) 0 ;
  char *arg3 = (char *) 0 ;
  unsigned int arg4 ;
  uint32_t arg5 ;
  memcached_connection arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  unsigned long val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  memcached_server_st *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",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_server_create_with", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_memcached_server_st, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "memcached_server_st *","memcached_server_create_with", 2, argv[1] )); 
  }
  arg2 = (memcached_server_st *)(argp2);
  res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","memcached_server_create_with", 3, argv[2] ));
  }
  arg3 = (char *)(buf3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "unsigned int","memcached_server_create_with", 4, argv[3] ));
  } 
  arg4 = (unsigned int)(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_long(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "uint32_t","memcached_server_create_with", 5, argv[4] ));
  } 
  arg5 = (uint32_t)(val5);
  ecode6 = SWIG_AsVal_int(argv[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "memcached_connection","memcached_server_create_with", 6, argv[5] ));
  } 
  arg6 = (memcached_connection)(val6);
  result = (memcached_server_st *)memcached_server_create_with(arg1,arg2,(char const *)arg3,arg4,arg5,arg6);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_memcached_server_st, 0 |  0 );
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return vresult;
fail:
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return Qnil;
}

.memcached_server_cursor(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 12121

SWIGINTERN VALUE
_wrap_memcached_server_cursor(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  memcached_server_function *arg2 = (memcached_server_function *) 0 ;
  void *arg3 = (void *) 0 ;
  unsigned int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  unsigned int val4 ;
  int ecode4 = 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;
  }
  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_server_cursor", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_memcached_server_function, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "memcached_server_function *","memcached_server_cursor", 2, argv[1] )); 
  }
  arg2 = (memcached_server_function *)(argp2);
  res3 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "void *","memcached_server_cursor", 3, argv[2] )); 
  }
  ecode4 = SWIG_AsVal_unsigned_SS_int(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "unsigned int","memcached_server_cursor", 4, argv[3] ));
  } 
  arg4 = (unsigned int)(val4);
  result = (memcached_return)memcached_server_cursor(arg1,arg2,arg3,arg4);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.memcached_server_error(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 12209

SWIGINTERN VALUE
_wrap_memcached_server_error(int argc, VALUE *argv, VALUE self) {
  memcached_server_st *arg1 = (memcached_server_st *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_server_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_server_st *","memcached_server_error", 1, argv[0] )); 
  }
  arg1 = (memcached_server_st *)(argp1);
  result = (char *)memcached_server_error(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.memcached_server_error_reset(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 12233

SWIGINTERN VALUE
_wrap_memcached_server_error_reset(int argc, VALUE *argv, VALUE self) {
  memcached_server_st *arg1 = (memcached_server_st *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_server_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_server_st *","memcached_server_error_reset", 1, argv[0] )); 
  }
  arg1 = (memcached_server_st *)(argp1);
  memcached_server_error_reset(arg1);
  return Qnil;
fail:
  return Qnil;
}

.memcached_server_free(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 12353

SWIGINTERN VALUE
_wrap_memcached_server_free(int argc, VALUE *argv, VALUE self) {
  memcached_server_st *arg1 = (memcached_server_st *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_server_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_server_st *","memcached_server_free", 1, argv[0] )); 
  }
  arg1 = (memcached_server_st *)(argp1);
  memcached_server_free(arg1);
  return Qnil;
fail:
  return Qnil;
}

.memcached_server_list_append(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 8042

SWIGINTERN VALUE
_wrap_memcached_server_list_append(int argc, VALUE *argv, VALUE self) {
  memcached_server_st *arg1 = (memcached_server_st *) 0 ;
  char *arg2 = (char *) 0 ;
  unsigned int arg3 ;
  memcached_return *arg4 = (memcached_return *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  memcached_return temp4 ;
  int res4 = SWIG_TMPOBJ ;
  memcached_server_st *result = 0 ;
  VALUE vresult = Qnil;
  
  arg4 = &temp4;
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_server_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_server_st *","memcached_server_list_append", 1, argv[0] )); 
  }
  arg1 = (memcached_server_st *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","memcached_server_list_append", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","memcached_server_list_append", 3, argv[2] ));
  } 
  arg3 = (unsigned int)(val3);
  result = (memcached_server_st *)memcached_server_list_append(arg1,(char const *)arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_memcached_server_st, 0 |  0 );
  if (SWIG_IsTmpObj(res4)) {
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_short((*arg4)));
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_memcached_return, new_flags));
  }
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.memcached_server_list_append_with_weight(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 8095

SWIGINTERN VALUE
_wrap_memcached_server_list_append_with_weight(int argc, VALUE *argv, VALUE self) {
  memcached_server_st *arg1 = (memcached_server_st *) 0 ;
  char *arg2 = (char *) 0 ;
  unsigned int arg3 ;
  uint32_t arg4 ;
  memcached_return *arg5 = (memcached_return *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned long val4 ;
  int ecode4 = 0 ;
  memcached_return temp5 ;
  int res5 = SWIG_TMPOBJ ;
  memcached_server_st *result = 0 ;
  VALUE vresult = Qnil;
  
  arg5 = &temp5;
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_server_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_server_st *","memcached_server_list_append_with_weight", 1, argv[0] )); 
  }
  arg1 = (memcached_server_st *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","memcached_server_list_append_with_weight", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","memcached_server_list_append_with_weight", 3, argv[2] ));
  } 
  arg3 = (unsigned int)(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_long(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "uint32_t","memcached_server_list_append_with_weight", 4, argv[3] ));
  } 
  arg4 = (uint32_t)(val4);
  result = (memcached_server_st *)memcached_server_list_append_with_weight(arg1,(char const *)arg2,arg3,arg4,arg5);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_memcached_server_st, 0 |  0 );
  if (SWIG_IsTmpObj(res5)) {
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_short((*arg5)));
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_memcached_return, new_flags));
  }
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.memcached_server_list_count(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 8156

SWIGINTERN VALUE
_wrap_memcached_server_list_count(int argc, VALUE *argv, VALUE self) {
  memcached_server_st *arg1 = (memcached_server_st *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_server_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_server_st *","memcached_server_list_count", 1, argv[0] )); 
  }
  arg1 = (memcached_server_st *)(argp1);
  result = (unsigned int)memcached_server_list_count(arg1);
  vresult = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return vresult;
fail:
  return Qnil;
}

.memcached_server_list_free(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 7989

SWIGINTERN VALUE
_wrap_memcached_server_list_free(int argc, VALUE *argv, VALUE self) {
  memcached_server_st *arg1 = (memcached_server_st *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_server_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_server_st *","memcached_server_list_free", 1, argv[0] )); 
  }
  arg1 = (memcached_server_st *)(argp1);
  memcached_server_list_free(arg1);
  return Qnil;
fail:
  return Qnil;
}

.memcached_server_push(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 8010

SWIGINTERN VALUE
_wrap_memcached_server_push(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  memcached_server_st *arg2 = (memcached_server_st *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  memcached_return result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_server_push", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_memcached_server_st, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "memcached_server_st *","memcached_server_push", 2, argv[1] )); 
  }
  arg2 = (memcached_server_st *)(argp2);
  result = (memcached_return)memcached_server_push(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.memcached_server_remove(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 12448

SWIGINTERN VALUE
_wrap_memcached_server_remove(int argc, VALUE *argv, VALUE self) {
  memcached_server_st *arg1 = (memcached_server_st *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  memcached_return result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_server_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_server_st *","memcached_server_remove", 1, argv[0] )); 
  }
  arg1 = (memcached_server_st *)(argp1);
  result = (memcached_return)memcached_server_remove(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.memcached_servers_parse(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 8180

SWIGINTERN VALUE
_wrap_memcached_servers_parse(int argc, VALUE *argv, VALUE self) {
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  memcached_server_st *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","memcached_servers_parse", 1, argv[0] ));
  }
  arg1 = (char *)(buf1);
  result = (memcached_server_st *)memcached_servers_parse((char const *)arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_memcached_server_st, 0 |  0 );
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return vresult;
fail:
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return Qnil;
}

.memcached_set(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 9315

SWIGINTERN VALUE
_wrap_memcached_set(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  char *arg4 = (char *) 0 ;
  size_t arg5 ;
  time_t arg6 ;
  uint32_t arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val6 ;
  int ecode6 = 0 ;
  unsigned long val7 ;
  int ecode7 = 0 ;
  memcached_return result;
  VALUE vresult = Qnil;
  
  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)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_set", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  {
    VALUE str;
    str = rb_string_value(&argv[1]);
    arg2 = RSTRING_PTR(str);
    arg3 = RSTRING_LEN(str);
  }
  {
    VALUE str;
    str = rb_string_value(&argv[2]);
    arg4 = RSTRING_PTR(str);
    arg5 = RSTRING_LEN(str);
  }
  ecode6 = SWIG_AsVal_unsigned_SS_long(argv[3], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "time_t","memcached_set", 6, argv[3] ));
  } 
  arg6 = (time_t)(val6);
  ecode7 = SWIG_AsVal_unsigned_SS_long(argv[4], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "uint32_t","memcached_set", 7, argv[4] ));
  } 
  arg7 = (uint32_t)(val7);
  result = (memcached_return)memcached_set(arg1,(char const *)arg2,arg3,(char const *)arg4,arg5,arg6,arg7);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.memcached_set_by_key(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 9659

SWIGINTERN VALUE
_wrap_memcached_set_by_key(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  char *arg4 = (char *) 0 ;
  size_t arg5 ;
  char *arg6 = (char *) 0 ;
  size_t arg7 ;
  time_t arg8 ;
  uint32_t arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val8 ;
  int ecode8 = 0 ;
  unsigned long val9 ;
  int ecode9 = 0 ;
  memcached_return result;
  VALUE vresult = Qnil;
  
  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)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_set_by_key", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  {
    VALUE str;
    str = rb_string_value(&argv[1]);
    arg4 = arg2 = RSTRING_PTR(str);
    arg5 = arg3 = RSTRING_LEN(str);
  }
  {
    VALUE str;
    str = rb_string_value(&argv[2]);
    arg6 = RSTRING_PTR(str);
    arg7 = RSTRING_LEN(str);
  }
  ecode8 = SWIG_AsVal_unsigned_SS_long(argv[3], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "time_t","memcached_set_by_key", 8, argv[3] ));
  } 
  arg8 = (time_t)(val8);
  ecode9 = SWIG_AsVal_unsigned_SS_long(argv[4], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "uint32_t","memcached_set_by_key", 9, argv[4] ));
  } 
  arg9 = (uint32_t)(val9);
  result = (memcached_return)memcached_set_by_key(arg1,(char const *)arg2,arg3,(char const *)arg4,arg5,(char const *)arg6,arg7,arg8,arg9);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.memcached_set_memory_allocators(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 8537

SWIGINTERN VALUE
_wrap_memcached_set_memory_allocators(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  memcached_malloc_function arg2 ;
  memcached_free_function arg3 ;
  memcached_realloc_function arg4 ;
  memcached_calloc_function arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  memcached_return result;
  VALUE vresult = Qnil;
  
  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)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_set_memory_allocators", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_memcached_malloc_function,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "memcached_malloc_function","memcached_set_memory_allocators", 2, argv[1] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "memcached_malloc_function","memcached_set_memory_allocators", 2, argv[1]));
    } else {
      arg2 = *((memcached_malloc_function *)(argp2));
    }
  }
  {
    res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_memcached_free_function,  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "memcached_free_function","memcached_set_memory_allocators", 3, argv[2] )); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "memcached_free_function","memcached_set_memory_allocators", 3, argv[2]));
    } else {
      arg3 = *((memcached_free_function *)(argp3));
    }
  }
  {
    res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_memcached_realloc_function,  0 );
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "memcached_realloc_function","memcached_set_memory_allocators", 4, argv[3] )); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "memcached_realloc_function","memcached_set_memory_allocators", 4, argv[3]));
    } else {
      arg4 = *((memcached_realloc_function *)(argp4));
    }
  }
  {
    res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_memcached_calloc_function,  0 );
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "memcached_calloc_function","memcached_set_memory_allocators", 5, argv[4] )); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "memcached_calloc_function","memcached_set_memory_allocators", 5, argv[4]));
    } else {
      arg5 = *((memcached_calloc_function *)(argp5));
    }
  }
  result = (memcached_return)memcached_set_memory_allocators(arg1,arg2,arg3,arg4,arg5);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.memcached_set_sasl_auth_data(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 12501

SWIGINTERN VALUE
_wrap_memcached_set_sasl_auth_data(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 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_set_sasl_auth_data", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","memcached_set_sasl_auth_data", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","memcached_set_sasl_auth_data", 3, argv[2] ));
  }
  arg3 = (char *)(buf3);
  result = (memcached_return)memcached_set_sasl_auth_data(arg1,(char const *)arg2,(char const *)arg3);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return Qnil;
}

.memcached_set_sasl_callbacks(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 12472

SWIGINTERN VALUE
_wrap_memcached_set_sasl_callbacks(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  sasl_callback_t *arg2 = (sasl_callback_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_set_sasl_callbacks", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_sasl_callback_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "sasl_callback_t const *","memcached_set_sasl_callbacks", 2, argv[1] )); 
  }
  arg2 = (sasl_callback_t *)(argp2);
  memcached_set_sasl_callbacks(arg1,(sasl_callback_t const *)arg2);
  return Qnil;
fail:
  return Qnil;
}

.memcached_set_user_data(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 8694

SWIGINTERN VALUE
_wrap_memcached_set_user_data(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_set_user_data", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  {
    VALUE str;
    str = rb_string_value(&argv[1]);
    if (RSTRING_LEN(str) == 0) {
      arg2 = NULL;
    } else {
      arg2 = RSTRING_PTR(str);
    }
  }
  result = (void *)memcached_set_user_data(arg1,arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.memcached_stat(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 7341

SWIGINTERN VALUE
_wrap_memcached_stat(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  char *arg2 = (char *) 0 ;
  memcached_return *arg3 = (memcached_return *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  memcached_return temp3 ;
  int res3 = SWIG_TMPOBJ ;
  memcached_stat_st *result = 0 ;
  VALUE vresult = Qnil;
  
  arg3 = &temp3;
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_stat", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","memcached_stat", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  result = (memcached_stat_st *)memcached_stat(arg1,arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_memcached_stat_st, 0 |  0 );
  if (SWIG_IsTmpObj(res3)) {
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_short((*arg3)));
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_memcached_return, new_flags));
  }
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.memcached_stat_free(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 7312

SWIGINTERN VALUE
_wrap_memcached_stat_free(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  memcached_stat_st *arg2 = (memcached_stat_st *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_stat_free", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_memcached_stat_st, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "memcached_stat_st *","memcached_stat_free", 2, argv[1] )); 
  }
  arg2 = (memcached_stat_st *)(argp2);
  memcached_stat_free(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.memcached_stat_get_keys(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 8261

SWIGINTERN VALUE
_wrap_memcached_stat_get_keys(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  memcached_stat_st *arg2 = (memcached_stat_st *) 0 ;
  memcached_return *arg3 = (memcached_return *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  memcached_return temp3 ;
  int res3 = SWIG_TMPOBJ ;
  char **result = 0 ;
  VALUE vresult = Qnil;
  
  arg3 = &temp3;
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_stat_get_keys", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_memcached_stat_st, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "memcached_stat_st *","memcached_stat_get_keys", 2, argv[1] )); 
  }
  arg2 = (memcached_stat_st *)(argp2);
  result = (char **)memcached_stat_get_keys(arg1,arg2,arg3);
  {
    int i;
    VALUE ary = rb_ary_new();
    vresult = rb_ary_new();
    
    for(i=0; result[i] != NULL; i++) {
      rb_ary_store(ary, i, rb_str_new2(result[i]));
    }
    rb_ary_push(vresult, ary);
    free(result);
  }
  if (SWIG_IsTmpObj(res3)) {
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_short((*arg3)));
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_memcached_return, new_flags));
  }
  return vresult;
fail:
  return Qnil;
}

.memcached_stat_get_value(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 8207

SWIGINTERN VALUE
_wrap_memcached_stat_get_value(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  memcached_stat_st *arg2 = (memcached_stat_st *) 0 ;
  char *arg3 = (char *) 0 ;
  memcached_return *arg4 = (memcached_return *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  memcached_return temp4 ;
  int res4 = SWIG_TMPOBJ ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  arg4 = &temp4;
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_stat_get_value", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_memcached_stat_st, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "memcached_stat_st *","memcached_stat_get_value", 2, argv[1] )); 
  }
  arg2 = (memcached_stat_st *)(argp2);
  res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","memcached_stat_get_value", 3, argv[2] ));
  }
  arg3 = (char *)(buf3);
  result = (char *)memcached_stat_get_value(arg1,arg2,(char const *)arg3,arg4);
  vresult = SWIG_FromCharPtr((const char *)result);
  if (SWIG_IsTmpObj(res4)) {
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_short((*arg4)));
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_memcached_return, new_flags));
  }
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  free((char*)result);
  return vresult;
fail:
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return Qnil;
}

.memcached_stat_servername(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 7386

SWIGINTERN VALUE
_wrap_memcached_stat_servername(int argc, VALUE *argv, VALUE self) {
  memcached_stat_st *arg1 = (memcached_stat_st *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  unsigned int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 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;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_stat_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_stat_st *","memcached_stat_servername", 1, argv[0] )); 
  }
  arg1 = (memcached_stat_st *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","memcached_stat_servername", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char *","memcached_stat_servername", 3, argv[2] ));
  }
  arg3 = (char *)(buf3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "unsigned int","memcached_stat_servername", 4, argv[3] ));
  } 
  arg4 = (unsigned int)(val4);
  result = (memcached_return)memcached_stat_servername(arg1,arg2,arg3,arg4);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return Qnil;
}

.memcached_strerror(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 7525

SWIGINTERN VALUE
_wrap_memcached_strerror(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  memcached_return arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_strerror", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "memcached_return","memcached_strerror", 2, argv[1] ));
  } 
  arg2 = (memcached_return)(val2);
  result = (char *)memcached_strerror(arg1,arg2);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.memcached_touch(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 12619

SWIGINTERN VALUE
_wrap_memcached_touch(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  time_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val4 ;
  int ecode4 = 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_touch", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  {
    VALUE str;
    str = rb_string_value(&argv[1]);
    arg2 = RSTRING_PTR(str);
    arg3 = RSTRING_LEN(str);
  }
  ecode4 = SWIG_AsVal_unsigned_SS_long(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "time_t","memcached_touch", 4, argv[2] ));
  } 
  arg4 = (time_t)(val4);
  result = (memcached_return)memcached_touch(arg1,(char const *)arg2,arg3,arg4);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.memcached_touch_by_key(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 12659

SWIGINTERN VALUE
_wrap_memcached_touch_by_key(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  char *arg4 = (char *) 0 ;
  size_t arg5 ;
  time_t arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  unsigned long val6 ;
  int ecode6 = 0 ;
  memcached_return result;
  VALUE vresult = Qnil;
  
  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)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_touch_by_key", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","memcached_touch_by_key", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","memcached_touch_by_key", 3, argv[2] ));
  } 
  arg3 = (size_t)(val3);
  {
    VALUE str;
    str = rb_string_value(&argv[3]);
    arg4 = RSTRING_PTR(str);
    arg5 = RSTRING_LEN(str);
  }
  ecode6 = SWIG_AsVal_unsigned_SS_long(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "time_t","memcached_touch_by_key", 6, argv[4] ));
  } 
  arg6 = (time_t)(val6);
  result = (memcached_return)memcached_touch_by_key(arg1,(char const *)arg2,arg3,(char const *)arg4,arg5,arg6);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.memcached_verbosity(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 7472

SWIGINTERN VALUE
_wrap_memcached_verbosity(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  memcached_return result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_verbosity", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","memcached_verbosity", 2, argv[1] ));
  } 
  arg2 = (unsigned int)(val2);
  result = (memcached_return)memcached_verbosity(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.memcached_version(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 6899

SWIGINTERN VALUE
_wrap_memcached_version(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  memcached_return result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_version", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  result = (memcached_return)memcached_version(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.run_distribution(*args) ⇒ `Object`

# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 8728

SWIGINTERN VALUE
_wrap_run_distribution(int argc, VALUE *argv, VALUE self) {
  memcached_st *arg1 = (memcached_st *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  memcached_return result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","run_distribution", 1, argv[0] )); 
  }
  arg1 = (memcached_st *)(argp1);
  result = (memcached_return)run_distribution(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

Module: Rlibmemcached

Overview

Defined Under Namespace

Constant Summary collapse

Class Method Summary collapse

Class Method Details

.memcached_add(*args) ⇒ Object

.memcached_add_by_key(*args) ⇒ Object

.memcached_analyze(*args) ⇒ Object

.memcached_append(*args) ⇒ Object

.memcached_append_by_key(*args) ⇒ Object

.memcached_behavior_get(*args) ⇒ Object

.memcached_behavior_set(*args) ⇒ Object

.memcached_callback_get(*args) ⇒ Object

.memcached_callback_set(*args) ⇒ Object

.memcached_cas(*args) ⇒ Object

.memcached_cas_by_key(*args) ⇒ Object

.memcached_clone(*args) ⇒ Object

.memcached_create(*args) ⇒ Object

.memcached_decrement(*args) ⇒ Object

.memcached_decrement_with_initial(*args) ⇒ Object

.memcached_delete(*args) ⇒ Object

.memcached_delete_by_key(*args) ⇒ Object

.memcached_destroy_sasl_auth_data(*args) ⇒ Object

.memcached_dump(*args) ⇒ Object

.memcached_exist(*args) ⇒ Object

.memcached_exist_by_key(*args) ⇒ Object

.memcached_fetch(*args) ⇒ Object

.memcached_fetch_execute(*args) ⇒ Object

.memcached_fetch_result(*args) ⇒ Object

.memcached_fetch_rvalue(*args) ⇒ Object

.memcached_flush(*args) ⇒ Object

.memcached_flush_buffers(*args) ⇒ Object

.memcached_free(*args) ⇒ Object

.memcached_generate_hash(*args) ⇒ Object

.memcached_generate_hash_rvalue(*args) ⇒ Object

.memcached_generate_hash_value(*args) ⇒ Object

.memcached_get(*args) ⇒ Object

.memcached_get_by_key(*args) ⇒ Object

.memcached_get_from_last(*args) ⇒ Object

.memcached_get_from_last_rvalue(*args) ⇒ Object

.memcached_get_len(*args) ⇒ Object

.memcached_get_memory_allocators(*args) ⇒ Object

.memcached_get_rvalue(*args) ⇒ Object

.memcached_get_sasl_callbacks(*args) ⇒ Object

.memcached_get_user_data(*args) ⇒ Object

.memcached_increment(*args) ⇒ Object

.memcached_increment_with_initial(*args) ⇒ Object

.memcached_lib_version(*args) ⇒ Object

.memcached_mget(*args) ⇒ Object

.memcached_mget_by_key(*args) ⇒ Object

.memcached_mget_len(*args) ⇒ Object

.memcached_prepend(*args) ⇒ Object

.memcached_prepend_by_key(*args) ⇒ Object

.memcached_quit(*args) ⇒ Object

.memcached_replace(*args) ⇒ Object

.memcached_replace_by_key(*args) ⇒ Object

.memcached_result_create(*args) ⇒ Object

.memcached_result_free(*args) ⇒ Object

.memcached_result_length(*args) ⇒ Object

.memcached_result_reset(*args) ⇒ Object

.memcached_result_set_value(*args) ⇒ Object

.memcached_result_value(*args) ⇒ Object

.memcached_sasl_authenticate_connection(*args) ⇒ Object

.memcached_select_server_at(*args) ⇒ Object

.memcached_select_stat_at(*args) ⇒ Object

.memcached_server_add(*args) ⇒ Object

.memcached_server_add_udp(*args) ⇒ Object

.memcached_server_add_udp_with_weight(*args) ⇒ Object

.memcached_server_add_unix_socket(*args) ⇒ Object

.memcached_server_add_unix_socket_with_weight(*args) ⇒ Object

.memcached_server_add_with_weight(*args) ⇒ Object

.memcached_server_by_key(*args) ⇒ Object

.memcached_server_clone(*args) ⇒ Object

.memcached_server_create(*args) ⇒ Object

.memcached_server_create_with(*args) ⇒ Object

.memcached_server_cursor(*args) ⇒ Object

.memcached_server_error(*args) ⇒ Object

.memcached_server_error_reset(*args) ⇒ Object

.memcached_server_free(*args) ⇒ Object