Class: Rlibmemcached::MemcachedSt

Inherits:

Object

Object
Rlibmemcached::MemcachedSt

show all

Defined in:: ext/rlibmemcached/rlibmemcached_wrap.c

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_new_MemcachedSt(int argc, VALUE *argv, VALUE self) {
  struct memcached_st *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (struct memcached_st *)calloc(1, sizeof(struct memcached_st));
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}

Instance Method Details

#cached_errno(*args) ⇒ `Object`

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

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

#cached_errno=(*args) ⇒ `Object`

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

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

#call_calloc(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_MemcachedSt_call_calloc_get(int argc, VALUE *argv, VALUE self) {
  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  memcached_calloc_function result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","call_calloc", 1, self )); 
  }
  arg1 = (struct memcached_st *)(argp1);
  result =  ((arg1)->call_calloc);
  vresult = SWIG_NewPointerObj((memcached_calloc_function *)memcpy((memcached_calloc_function *)calloc(1,sizeof(memcached_calloc_function)),&result,sizeof(memcached_calloc_function)), SWIGTYPE_p_memcached_calloc_function, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#call_calloc=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_MemcachedSt_call_calloc_set(int argc, VALUE *argv, VALUE self) {
  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
  memcached_calloc_function arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","call_calloc", 1, self )); 
  }
  arg1 = (struct memcached_st *)(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_memcached_calloc_function,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "memcached_calloc_function","call_calloc", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "memcached_calloc_function","call_calloc", 2, argv[0]));
    } else {
      arg2 = *((memcached_calloc_function *)(argp2));
    }
  }
  if (arg1) (arg1)->call_calloc = arg2;
  return Qnil;
fail:
  return Qnil;
}

#call_free(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_MemcachedSt_call_free_get(int argc, VALUE *argv, VALUE self) {
  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  memcached_free_function result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","call_free", 1, self )); 
  }
  arg1 = (struct memcached_st *)(argp1);
  result =  ((arg1)->call_free);
  vresult = SWIG_NewPointerObj((memcached_free_function *)memcpy((memcached_free_function *)calloc(1,sizeof(memcached_free_function)),&result,sizeof(memcached_free_function)), SWIGTYPE_p_memcached_free_function, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#call_free=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_MemcachedSt_call_free_set(int argc, VALUE *argv, VALUE self) {
  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
  memcached_free_function arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","call_free", 1, self )); 
  }
  arg1 = (struct memcached_st *)(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_memcached_free_function,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "memcached_free_function","call_free", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "memcached_free_function","call_free", 2, argv[0]));
    } else {
      arg2 = *((memcached_free_function *)(argp2));
    }
  }
  if (arg1) (arg1)->call_free = arg2;
  return Qnil;
fail:
  return Qnil;
}

#call_malloc(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_MemcachedSt_call_malloc_get(int argc, VALUE *argv, VALUE self) {
  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  memcached_malloc_function result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","call_malloc", 1, self )); 
  }
  arg1 = (struct memcached_st *)(argp1);
  result =  ((arg1)->call_malloc);
  vresult = SWIG_NewPointerObj((memcached_malloc_function *)memcpy((memcached_malloc_function *)calloc(1,sizeof(memcached_malloc_function)),&result,sizeof(memcached_malloc_function)), SWIGTYPE_p_memcached_malloc_function, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#call_malloc=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_MemcachedSt_call_malloc_set(int argc, VALUE *argv, VALUE self) {
  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
  memcached_malloc_function arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","call_malloc", 1, self )); 
  }
  arg1 = (struct memcached_st *)(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_memcached_malloc_function,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "memcached_malloc_function","call_malloc", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "memcached_malloc_function","call_malloc", 2, argv[0]));
    } else {
      arg2 = *((memcached_malloc_function *)(argp2));
    }
  }
  if (arg1) (arg1)->call_malloc = arg2;
  return Qnil;
fail:
  return Qnil;
}

#call_realloc(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_MemcachedSt_call_realloc_get(int argc, VALUE *argv, VALUE self) {
  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  memcached_realloc_function result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","call_realloc", 1, self )); 
  }
  arg1 = (struct memcached_st *)(argp1);
  result =  ((arg1)->call_realloc);
  vresult = SWIG_NewPointerObj((memcached_realloc_function *)memcpy((memcached_realloc_function *)calloc(1,sizeof(memcached_realloc_function)),&result,sizeof(memcached_realloc_function)), SWIGTYPE_p_memcached_realloc_function, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#call_realloc=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_MemcachedSt_call_realloc_set(int argc, VALUE *argv, VALUE self) {
  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
  memcached_realloc_function arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","call_realloc", 1, self )); 
  }
  arg1 = (struct memcached_st *)(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_memcached_realloc_function,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "memcached_realloc_function","call_realloc", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "memcached_realloc_function","call_realloc", 2, argv[0]));
    } else {
      arg2 = *((memcached_realloc_function *)(argp2));
    }
  }
  if (arg1) (arg1)->call_realloc = arg2;
  return Qnil;
fail:
  return Qnil;
}

#connect_timeout(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_MemcachedSt_connect_timeout_get(int argc, VALUE *argv, VALUE self) {
  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int32_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","connect_timeout", 1, self )); 
  }
  arg1 = (struct memcached_st *)(argp1);
  result =  ((arg1)->connect_timeout);
  vresult = SWIG_NewPointerObj((int32_t *)memcpy((int32_t *)calloc(1,sizeof(int32_t)),&result,sizeof(int32_t)), SWIGTYPE_p_int32_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#connect_timeout=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_MemcachedSt_connect_timeout_set(int argc, VALUE *argv, VALUE self) {
  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","connect_timeout", 1, self )); 
  }
  arg1 = (struct memcached_st *)(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_int32_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "int32_t","connect_timeout", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "int32_t","connect_timeout", 2, argv[0]));
    } else {
      arg2 = *((int32_t *)(argp2));
    }
  }
  if (arg1) (arg1)->connect_timeout = arg2;
  return Qnil;
fail:
  return Qnil;
}

#continuum(*args) ⇒ `Object`

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

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

#continuum=(*args) ⇒ `Object`

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

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

#continuum_count(*args) ⇒ `Object`

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

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

#continuum_count=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_MemcachedSt_continuum_count_set(int argc, VALUE *argv, VALUE self) {
  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","continuum_count", 1, self )); 
  }
  arg1 = (struct memcached_st *)(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_uint32_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "uint32_t","continuum_count", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "uint32_t","continuum_count", 2, argv[0]));
    } else {
      arg2 = *((uint32_t *)(argp2));
    }
  }
  if (arg1) (arg1)->continuum_count = arg2;
  return Qnil;
fail:
  return Qnil;
}

#continuum_points_counter(*args) ⇒ `Object`

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

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

#continuum_points_counter=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_MemcachedSt_continuum_points_counter_set(int argc, VALUE *argv, VALUE self) {
  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","continuum_points_counter", 1, self )); 
  }
  arg1 = (struct memcached_st *)(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_uint32_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "uint32_t","continuum_points_counter", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "uint32_t","continuum_points_counter", 2, argv[0]));
    } else {
      arg2 = *((uint32_t *)(argp2));
    }
  }
  if (arg1) (arg1)->continuum_points_counter = arg2;
  return Qnil;
fail:
  return Qnil;
}

#cursor_server(*args) ⇒ `Object`

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

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

#cursor_server=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_MemcachedSt_cursor_server_set(int argc, VALUE *argv, VALUE self) {
  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","cursor_server", 1, self )); 
  }
  arg1 = (struct memcached_st *)(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_uint32_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "uint32_t","cursor_server", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "uint32_t","cursor_server", 2, argv[0]));
    } else {
      arg2 = *((uint32_t *)(argp2));
    }
  }
  if (arg1) (arg1)->cursor_server = arg2;
  return Qnil;
fail:
  return Qnil;
}

#delete_trigger(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_MemcachedSt_delete_trigger_get(int argc, VALUE *argv, VALUE self) {
  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  memcached_trigger_delete_key result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","delete_trigger", 1, self )); 
  }
  arg1 = (struct memcached_st *)(argp1);
  result =  ((arg1)->delete_trigger);
  vresult = SWIG_NewPointerObj((memcached_trigger_delete_key *)memcpy((memcached_trigger_delete_key *)calloc(1,sizeof(memcached_trigger_delete_key)),&result,sizeof(memcached_trigger_delete_key)), SWIGTYPE_p_memcached_trigger_delete_key, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#delete_trigger=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_MemcachedSt_delete_trigger_set(int argc, VALUE *argv, VALUE self) {
  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
  memcached_trigger_delete_key arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","delete_trigger", 1, self )); 
  }
  arg1 = (struct memcached_st *)(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_memcached_trigger_delete_key,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "memcached_trigger_delete_key","delete_trigger", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "memcached_trigger_delete_key","delete_trigger", 2, argv[0]));
    } else {
      arg2 = *((memcached_trigger_delete_key *)(argp2));
    }
  }
  if (arg1) (arg1)->delete_trigger = arg2;
  return Qnil;
fail:
  return Qnil;
}

#distribution(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_MemcachedSt_distribution_get(int argc, VALUE *argv, VALUE self) {
  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uint8_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","distribution", 1, self )); 
  }
  arg1 = (struct memcached_st *)(argp1);
  result =  ((arg1)->distribution);
  vresult = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return vresult;
fail:
  return Qnil;
}

#distribution=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_MemcachedSt_distribution_set(int argc, VALUE *argv, VALUE self) {
  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
  uint8_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","distribution", 1, self )); 
  }
  arg1 = (struct memcached_st *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "uint8_t","distribution", 2, argv[0] ));
  } 
  arg2 = (uint8_t)(val2);
  if (arg1) (arg1)->distribution = arg2;
  return Qnil;
fail:
  return Qnil;
}

#flags(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_MemcachedSt_flags_get(int argc, VALUE *argv, VALUE self) {
  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uint32_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","flags", 1, self )); 
  }
  arg1 = (struct memcached_st *)(argp1);
  result =  ((arg1)->flags);
  vresult = SWIG_From_unsigned_SS_long((unsigned long)(result));
  return vresult;
fail:
  return Qnil;
}

#flags=(*args) ⇒ `Object`

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

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

#get_key_failure(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_MemcachedSt_get_key_failure_get(int argc, VALUE *argv, VALUE self) {
  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  memcached_trigger_key result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","get_key_failure", 1, self )); 
  }
  arg1 = (struct memcached_st *)(argp1);
  result =  ((arg1)->get_key_failure);
  vresult = SWIG_NewPointerObj((memcached_trigger_key *)memcpy((memcached_trigger_key *)calloc(1,sizeof(memcached_trigger_key)),&result,sizeof(memcached_trigger_key)), SWIGTYPE_p_memcached_trigger_key, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#get_key_failure=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_MemcachedSt_get_key_failure_set(int argc, VALUE *argv, VALUE self) {
  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
  memcached_trigger_key arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","get_key_failure", 1, self )); 
  }
  arg1 = (struct memcached_st *)(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_memcached_trigger_key,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "memcached_trigger_key","get_key_failure", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "memcached_trigger_key","get_key_failure", 2, argv[0]));
    } else {
      arg2 = *((memcached_trigger_key *)(argp2));
    }
  }
  if (arg1) (arg1)->get_key_failure = arg2;
  return Qnil;
fail:
  return Qnil;
}

#hash(*args) ⇒ `Object`

call-seq:

hash -> uint8_t

Hashing function for class.

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

SWIGINTERN VALUE
_wrap_MemcachedSt_hash_get(int argc, VALUE *argv, VALUE self) {
  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uint8_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","hash", 1, self )); 
  }
  arg1 = (struct memcached_st *)(argp1);
  result =  ((arg1)->hash);
  vresult = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return vresult;
fail:
  return Qnil;
}

#hash=(*args) ⇒ `Object`

call-seq:

hash=(x) -> uint8_t

Hashing function for class.

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

SWIGINTERN VALUE
_wrap_MemcachedSt_hash_set(int argc, VALUE *argv, VALUE self) {
  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
  uint8_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","hash", 1, self )); 
  }
  arg1 = (struct memcached_st *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "uint8_t","hash", 2, argv[0] ));
  } 
  arg2 = (uint8_t)(val2);
  if (arg1) (arg1)->hash = arg2;
  return Qnil;
fail:
  return Qnil;
}

#hash_continuum(*args) ⇒ `Object`

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

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

#hash_continuum=(*args) ⇒ `Object`

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

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

#hosts(*args) ⇒ `Object`

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

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

#hosts=(*args) ⇒ `Object`

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

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

#io_bytes_watermark(*args) ⇒ `Object`

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

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

#io_bytes_watermark=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_MemcachedSt_io_bytes_watermark_set(int argc, VALUE *argv, VALUE self) {
  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","io_bytes_watermark", 1, self )); 
  }
  arg1 = (struct memcached_st *)(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_uint32_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "uint32_t","io_bytes_watermark", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "uint32_t","io_bytes_watermark", 2, argv[0]));
    } else {
      arg2 = *((uint32_t *)(argp2));
    }
  }
  if (arg1) (arg1)->io_bytes_watermark = arg2;
  return Qnil;
fail:
  return Qnil;
}

#io_key_prefetch(*args) ⇒ `Object`

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

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

#io_key_prefetch=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_MemcachedSt_io_key_prefetch_set(int argc, VALUE *argv, VALUE self) {
  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","io_key_prefetch", 1, self )); 
  }
  arg1 = (struct memcached_st *)(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_uint32_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "uint32_t","io_key_prefetch", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "uint32_t","io_key_prefetch", 2, argv[0]));
    } else {
      arg2 = *((uint32_t *)(argp2));
    }
  }
  if (arg1) (arg1)->io_key_prefetch = arg2;
  return Qnil;
fail:
  return Qnil;
}

#io_msg_watermark(*args) ⇒ `Object`

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

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

#io_msg_watermark=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_MemcachedSt_io_msg_watermark_set(int argc, VALUE *argv, VALUE self) {
  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","io_msg_watermark", 1, self )); 
  }
  arg1 = (struct memcached_st *)(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_uint32_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "uint32_t","io_msg_watermark", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "uint32_t","io_msg_watermark", 2, argv[0]));
    } else {
      arg2 = *((uint32_t *)(argp2));
    }
  }
  if (arg1) (arg1)->io_msg_watermark = arg2;
  return Qnil;
fail:
  return Qnil;
}

#is_allocated(*args) ⇒ `Object`

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

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

#is_allocated=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_MemcachedSt_is_allocated_set(int argc, VALUE *argv, VALUE self) {
  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","is_allocated", 1, self )); 
  }
  arg1 = (struct memcached_st *)(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","is_allocated", 2, argv[0] ));
  } 
  arg2 = (bool)(val2);
  if (arg1) (arg1)->is_allocated = arg2;
  return Qnil;
fail:
  return Qnil;
}

#last_server_key(*args) ⇒ `Object`

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

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

#last_server_key=(*args) ⇒ `Object`

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

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

#live_host_indices(*args) ⇒ `Object`

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

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

#live_host_indices=(*args) ⇒ `Object`

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

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

#live_host_indices_size(*args) ⇒ `Object`

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

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

#live_host_indices_size=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_MemcachedSt_live_host_indices_size_set(int argc, VALUE *argv, VALUE self) {
  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","live_host_indices_size", 1, self )); 
  }
  arg1 = (struct memcached_st *)(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_uint32_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "uint32_t","live_host_indices_size", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "uint32_t","live_host_indices_size", 2, argv[0]));
    } else {
      arg2 = *((uint32_t *)(argp2));
    }
  }
  if (arg1) (arg1)->live_host_indices_size = arg2;
  return Qnil;
fail:
  return Qnil;
}

#next_distribution_rebuild(*args) ⇒ `Object`

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

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

#next_distribution_rebuild=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_MemcachedSt_next_distribution_rebuild_set(int argc, VALUE *argv, VALUE self) {
  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
  time_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","next_distribution_rebuild", 1, self )); 
  }
  arg1 = (struct memcached_st *)(argp1);
  {
    if (NIL_P(argv[0]))
    arg2 = (time_t)-1;
    else
    arg2 = NUM2LONG(rb_funcall(argv[0], rb_intern("tv_sec"), 0));
  }
  if (arg1) (arg1)->next_distribution_rebuild = arg2;
  return Qnil;
fail:
  return Qnil;
}

#number_of_hosts(*args) ⇒ `Object`

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

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

#number_of_hosts=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_MemcachedSt_number_of_hosts_set(int argc, VALUE *argv, VALUE self) {
  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","number_of_hosts", 1, self )); 
  }
  arg1 = (struct memcached_st *)(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_uint32_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "uint32_t","number_of_hosts", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "uint32_t","number_of_hosts", 2, argv[0]));
    } else {
      arg2 = *((uint32_t *)(argp2));
    }
  }
  if (arg1) (arg1)->number_of_hosts = arg2;
  return Qnil;
fail:
  return Qnil;
}

#number_of_live_hosts(*args) ⇒ `Object`

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

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

#number_of_live_hosts=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_MemcachedSt_number_of_live_hosts_set(int argc, VALUE *argv, VALUE self) {
  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","number_of_live_hosts", 1, self )); 
  }
  arg1 = (struct memcached_st *)(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_uint32_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "uint32_t","number_of_live_hosts", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "uint32_t","number_of_live_hosts", 2, argv[0]));
    } else {
      arg2 = *((uint32_t *)(argp2));
    }
  }
  if (arg1) (arg1)->number_of_live_hosts = arg2;
  return Qnil;
fail:
  return Qnil;
}

#on_cleanup(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_MemcachedSt_on_cleanup_get(int argc, VALUE *argv, VALUE self) {
  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  memcached_cleanup_func result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","on_cleanup", 1, self )); 
  }
  arg1 = (struct memcached_st *)(argp1);
  result =  ((arg1)->on_cleanup);
  vresult = SWIG_NewPointerObj((memcached_cleanup_func *)memcpy((memcached_cleanup_func *)calloc(1,sizeof(memcached_cleanup_func)),&result,sizeof(memcached_cleanup_func)), SWIGTYPE_p_memcached_cleanup_func, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#on_cleanup=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_MemcachedSt_on_cleanup_set(int argc, VALUE *argv, VALUE self) {
  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
  memcached_cleanup_func arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","on_cleanup", 1, self )); 
  }
  arg1 = (struct memcached_st *)(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_memcached_cleanup_func,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "memcached_cleanup_func","on_cleanup", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "memcached_cleanup_func","on_cleanup", 2, argv[0]));
    } else {
      arg2 = *((memcached_cleanup_func *)(argp2));
    }
  }
  if (arg1) (arg1)->on_cleanup = arg2;
  return Qnil;
fail:
  return Qnil;
}

#on_clone(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_MemcachedSt_on_clone_get(int argc, VALUE *argv, VALUE self) {
  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  memcached_clone_func result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","on_clone", 1, self )); 
  }
  arg1 = (struct memcached_st *)(argp1);
  result =  ((arg1)->on_clone);
  vresult = SWIG_NewPointerObj((memcached_clone_func *)memcpy((memcached_clone_func *)calloc(1,sizeof(memcached_clone_func)),&result,sizeof(memcached_clone_func)), SWIGTYPE_p_memcached_clone_func, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#on_clone=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_MemcachedSt_on_clone_set(int argc, VALUE *argv, VALUE self) {
  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
  memcached_clone_func arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","on_clone", 1, self )); 
  }
  arg1 = (struct memcached_st *)(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_memcached_clone_func,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "memcached_clone_func","on_clone", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "memcached_clone_func","on_clone", 2, argv[0]));
    } else {
      arg2 = *((memcached_clone_func *)(argp2));
    }
  }
  if (arg1) (arg1)->on_clone = arg2;
  return Qnil;
fail:
  return Qnil;
}

#poll_max_retries(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_MemcachedSt_poll_max_retries_get(int argc, VALUE *argv, VALUE self) {
  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int32_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","poll_max_retries", 1, self )); 
  }
  arg1 = (struct memcached_st *)(argp1);
  result =  ((arg1)->poll_max_retries);
  vresult = SWIG_NewPointerObj((int32_t *)memcpy((int32_t *)calloc(1,sizeof(int32_t)),&result,sizeof(int32_t)), SWIGTYPE_p_int32_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#poll_max_retries=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_MemcachedSt_poll_max_retries_set(int argc, VALUE *argv, VALUE self) {
  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","poll_max_retries", 1, self )); 
  }
  arg1 = (struct memcached_st *)(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_int32_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "int32_t","poll_max_retries", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "int32_t","poll_max_retries", 2, argv[0]));
    } else {
      arg2 = *((int32_t *)(argp2));
    }
  }
  if (arg1) (arg1)->poll_max_retries = arg2;
  return Qnil;
fail:
  return Qnil;
}

#poll_timeout(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_MemcachedSt_poll_timeout_get(int argc, VALUE *argv, VALUE self) {
  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int32_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","poll_timeout", 1, self )); 
  }
  arg1 = (struct memcached_st *)(argp1);
  result =  ((arg1)->poll_timeout);
  vresult = SWIG_NewPointerObj((int32_t *)memcpy((int32_t *)calloc(1,sizeof(int32_t)),&result,sizeof(int32_t)), SWIGTYPE_p_int32_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#poll_timeout=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_MemcachedSt_poll_timeout_set(int argc, VALUE *argv, VALUE self) {
  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","poll_timeout", 1, self )); 
  }
  arg1 = (struct memcached_st *)(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_int32_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "int32_t","poll_timeout", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "int32_t","poll_timeout", 2, argv[0]));
    } else {
      arg2 = *((int32_t *)(argp2));
    }
  }
  if (arg1) (arg1)->poll_timeout = arg2;
  return Qnil;
fail:
  return Qnil;
}

#prefix_key(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_MemcachedSt_prefix_key_get(int argc, VALUE *argv, VALUE self) {
  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","prefix_key", 1, self )); 
  }
  arg1 = (struct memcached_st *)(argp1);
  result = (char *)(char *) ((arg1)->prefix_key);
  {
    size_t size = SWIG_strnlen(result, MEMCACHED_PREFIX_KEY_MAX_SIZE);
    
    
    
    vresult = SWIG_FromCharPtrAndSize(result, size);
  }
  return vresult;
fail:
  return Qnil;
}

#prefix_key=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_MemcachedSt_prefix_key_set(int argc, VALUE *argv, VALUE self) {
  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
  char *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char temp2[MEMCACHED_PREFIX_KEY_MAX_SIZE] ;
  int res2 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","prefix_key", 1, self )); 
  }
  arg1 = (struct memcached_st *)(argp1);
  res2 = SWIG_AsCharArray(argv[0], temp2, MEMCACHED_PREFIX_KEY_MAX_SIZE);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char [MEMCACHED_PREFIX_KEY_MAX_SIZE]","prefix_key", 2, argv[0] ));
  }
  arg2 = (char *)(temp2);
  if (arg2) memcpy(arg1->prefix_key,arg2,MEMCACHED_PREFIX_KEY_MAX_SIZE*sizeof(char));
  else memset(arg1->prefix_key,0,MEMCACHED_PREFIX_KEY_MAX_SIZE*sizeof(char));
  return Qnil;
fail:
  return Qnil;
}

#prefix_key_length(*args) ⇒ `Object`

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

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

#prefix_key_length=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_MemcachedSt_prefix_key_length_set(int argc, VALUE *argv, VALUE self) {
  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","prefix_key_length", 1, self )); 
  }
  arg1 = (struct memcached_st *)(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","prefix_key_length", 2, argv[0] ));
  } 
  arg2 = (size_t)(val2);
  if (arg1) (arg1)->prefix_key_length = arg2;
  return Qnil;
fail:
  return Qnil;
}

#purging(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_MemcachedSt_purging_get(int argc, VALUE *argv, VALUE self) {
  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uint8_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","purging", 1, self )); 
  }
  arg1 = (struct memcached_st *)(argp1);
  result =  ((arg1)->purging);
  vresult = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return vresult;
fail:
  return Qnil;
}

#purging=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_MemcachedSt_purging_set(int argc, VALUE *argv, VALUE self) {
  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
  uint8_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","purging", 1, self )); 
  }
  arg1 = (struct memcached_st *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "uint8_t","purging", 2, argv[0] ));
  } 
  arg2 = (uint8_t)(val2);
  if (arg1) (arg1)->purging = arg2;
  return Qnil;
fail:
  return Qnil;
}

#rcv_timeout(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_MemcachedSt_rcv_timeout_get(int argc, VALUE *argv, VALUE self) {
  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int32_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","rcv_timeout", 1, self )); 
  }
  arg1 = (struct memcached_st *)(argp1);
  result =  ((arg1)->rcv_timeout);
  vresult = SWIG_NewPointerObj((int32_t *)memcpy((int32_t *)calloc(1,sizeof(int32_t)),&result,sizeof(int32_t)), SWIGTYPE_p_int32_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#rcv_timeout=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_MemcachedSt_rcv_timeout_set(int argc, VALUE *argv, VALUE self) {
  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","rcv_timeout", 1, self )); 
  }
  arg1 = (struct memcached_st *)(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_int32_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "int32_t","rcv_timeout", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "int32_t","rcv_timeout", 2, argv[0]));
    } else {
      arg2 = *((int32_t *)(argp2));
    }
  }
  if (arg1) (arg1)->rcv_timeout = arg2;
  return Qnil;
fail:
  return Qnil;
}

#recv_size(*args) ⇒ `Object`

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

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

#recv_size=(*args) ⇒ `Object`

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

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

#result(*args) ⇒ `Object`

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

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

#result=(*args) ⇒ `Object`

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

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

#retry_timeout(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_MemcachedSt_retry_timeout_get(int argc, VALUE *argv, VALUE self) {
  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int32_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","retry_timeout", 1, self )); 
  }
  arg1 = (struct memcached_st *)(argp1);
  result =  ((arg1)->retry_timeout);
  vresult = SWIG_NewPointerObj((int32_t *)memcpy((int32_t *)calloc(1,sizeof(int32_t)),&result,sizeof(int32_t)), SWIGTYPE_p_int32_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#retry_timeout=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_MemcachedSt_retry_timeout_set(int argc, VALUE *argv, VALUE self) {
  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","retry_timeout", 1, self )); 
  }
  arg1 = (struct memcached_st *)(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_int32_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "int32_t","retry_timeout", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "int32_t","retry_timeout", 2, argv[0]));
    } else {
      arg2 = *((int32_t *)(argp2));
    }
  }
  if (arg1) (arg1)->retry_timeout = arg2;
  return Qnil;
fail:
  return Qnil;
}

#sasl_callbacks(*args) ⇒ `Object`

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

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

#sasl_callbacks=(*args) ⇒ `Object`

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

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

#send_size(*args) ⇒ `Object`

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

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

#send_size=(*args) ⇒ `Object`

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

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

#server_failure_limit(*args) ⇒ `Object`

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

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

#server_failure_limit=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_MemcachedSt_server_failure_limit_set(int argc, VALUE *argv, VALUE self) {
  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","server_failure_limit", 1, self )); 
  }
  arg1 = (struct memcached_st *)(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_uint32_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "uint32_t","server_failure_limit", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "uint32_t","server_failure_limit", 2, argv[0]));
    } else {
      arg2 = *((uint32_t *)(argp2));
    }
  }
  if (arg1) (arg1)->server_failure_limit = arg2;
  return Qnil;
fail:
  return Qnil;
}

#snd_timeout(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_MemcachedSt_snd_timeout_get(int argc, VALUE *argv, VALUE self) {
  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int32_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","snd_timeout", 1, self )); 
  }
  arg1 = (struct memcached_st *)(argp1);
  result =  ((arg1)->snd_timeout);
  vresult = SWIG_NewPointerObj((int32_t *)memcpy((int32_t *)calloc(1,sizeof(int32_t)),&result,sizeof(int32_t)), SWIGTYPE_p_int32_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#snd_timeout=(*args) ⇒ `Object`

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

SWIGINTERN VALUE
_wrap_MemcachedSt_snd_timeout_set(int argc, VALUE *argv, VALUE self) {
  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","snd_timeout", 1, self )); 
  }
  arg1 = (struct memcached_st *)(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_int32_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "int32_t","snd_timeout", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "int32_t","snd_timeout", 2, argv[0]));
    } else {
      arg2 = *((int32_t *)(argp2));
    }
  }
  if (arg1) (arg1)->snd_timeout = arg2;
  return Qnil;
fail:
  return Qnil;
}

#user_data(*args) ⇒ `Object`

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

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

#user_data=(*args) ⇒ `Object`

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

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

Class: Rlibmemcached::MemcachedSt

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ Object

Instance Method Details

#cached_errno(*args) ⇒ Object

#cached_errno=(*args) ⇒ Object

#call_calloc(*args) ⇒ Object

#call_calloc=(*args) ⇒ Object

#call_free(*args) ⇒ Object

#call_free=(*args) ⇒ Object

#call_malloc(*args) ⇒ Object

#call_malloc=(*args) ⇒ Object

#call_realloc(*args) ⇒ Object

#call_realloc=(*args) ⇒ Object

#connect_timeout(*args) ⇒ Object

#connect_timeout=(*args) ⇒ Object

#continuum(*args) ⇒ Object

#continuum=(*args) ⇒ Object

#continuum_count(*args) ⇒ Object

#continuum_count=(*args) ⇒ Object

#continuum_points_counter(*args) ⇒ Object

#continuum_points_counter=(*args) ⇒ Object

#cursor_server(*args) ⇒ Object

#cursor_server=(*args) ⇒ Object

#delete_trigger(*args) ⇒ Object

#delete_trigger=(*args) ⇒ Object

#distribution(*args) ⇒ Object

#distribution=(*args) ⇒ Object

#flags(*args) ⇒ Object

#flags=(*args) ⇒ Object

#get_key_failure(*args) ⇒ Object

#get_key_failure=(*args) ⇒ Object

#hash(*args) ⇒ Object

#hash=(*args) ⇒ Object

#hash_continuum(*args) ⇒ Object

#hash_continuum=(*args) ⇒ Object

#hosts(*args) ⇒ Object

#hosts=(*args) ⇒ Object

#io_bytes_watermark(*args) ⇒ Object

#io_bytes_watermark=(*args) ⇒ Object

#io_key_prefetch(*args) ⇒ Object

#io_key_prefetch=(*args) ⇒ Object

#io_msg_watermark(*args) ⇒ Object

#io_msg_watermark=(*args) ⇒ Object

#is_allocated(*args) ⇒ Object

#is_allocated=(*args) ⇒ Object

#last_server_key(*args) ⇒ Object

#last_server_key=(*args) ⇒ Object

#live_host_indices(*args) ⇒ Object

#live_host_indices=(*args) ⇒ Object

#live_host_indices_size(*args) ⇒ Object

#live_host_indices_size=(*args) ⇒ Object

#next_distribution_rebuild(*args) ⇒ Object

#next_distribution_rebuild=(*args) ⇒ Object

#number_of_hosts(*args) ⇒ Object

#number_of_hosts=(*args) ⇒ Object

#number_of_live_hosts(*args) ⇒ Object

#number_of_live_hosts=(*args) ⇒ Object

#on_cleanup(*args) ⇒ Object

#on_cleanup=(*args) ⇒ Object

#on_clone(*args) ⇒ Object

#on_clone=(*args) ⇒ Object

#poll_max_retries(*args) ⇒ Object

#poll_max_retries=(*args) ⇒ Object

#poll_timeout(*args) ⇒ Object

#poll_timeout=(*args) ⇒ Object

#prefix_key(*args) ⇒ Object

#prefix_key=(*args) ⇒ Object

#prefix_key_length(*args) ⇒ Object

#prefix_key_length=(*args) ⇒ Object

#purging(*args) ⇒ Object

#purging=(*args) ⇒ Object

#rcv_timeout(*args) ⇒ Object

#rcv_timeout=(*args) ⇒ Object

#recv_size(*args) ⇒ Object

#recv_size=(*args) ⇒ Object

#result(*args) ⇒ Object

#result=(*args) ⇒ Object

#retry_timeout(*args) ⇒ Object

#initialize(*args) ⇒ `Object`

#cached_errno(*args) ⇒ `Object`

#cached_errno=(*args) ⇒ `Object`

#call_calloc(*args) ⇒ `Object`

#call_calloc=(*args) ⇒ `Object`

#call_free(*args) ⇒ `Object`

#call_free=(*args) ⇒ `Object`

#call_malloc(*args) ⇒ `Object`

#call_malloc=(*args) ⇒ `Object`

#call_realloc(*args) ⇒ `Object`

#call_realloc=(*args) ⇒ `Object`

#connect_timeout(*args) ⇒ `Object`

#connect_timeout=(*args) ⇒ `Object`

#continuum(*args) ⇒ `Object`

#continuum=(*args) ⇒ `Object`

#continuum_count(*args) ⇒ `Object`

#continuum_count=(*args) ⇒ `Object`

#continuum_points_counter(*args) ⇒ `Object`

#continuum_points_counter=(*args) ⇒ `Object`

#cursor_server(*args) ⇒ `Object`

#cursor_server=(*args) ⇒ `Object`

#delete_trigger(*args) ⇒ `Object`

#delete_trigger=(*args) ⇒ `Object`

#distribution(*args) ⇒ `Object`

#distribution=(*args) ⇒ `Object`

#flags(*args) ⇒ `Object`

#flags=(*args) ⇒ `Object`

#get_key_failure(*args) ⇒ `Object`

#get_key_failure=(*args) ⇒ `Object`

#hash(*args) ⇒ `Object`

#hash=(*args) ⇒ `Object`

#hash_continuum(*args) ⇒ `Object`

#hash_continuum=(*args) ⇒ `Object`

#hosts(*args) ⇒ `Object`

#hosts=(*args) ⇒ `Object`

#io_bytes_watermark(*args) ⇒ `Object`

#io_bytes_watermark=(*args) ⇒ `Object`

#io_key_prefetch(*args) ⇒ `Object`

#io_key_prefetch=(*args) ⇒ `Object`

#io_msg_watermark(*args) ⇒ `Object`

#io_msg_watermark=(*args) ⇒ `Object`

#is_allocated(*args) ⇒ `Object`

#is_allocated=(*args) ⇒ `Object`

#last_server_key(*args) ⇒ `Object`

#last_server_key=(*args) ⇒ `Object`

#live_host_indices(*args) ⇒ `Object`

#live_host_indices=(*args) ⇒ `Object`

#live_host_indices_size(*args) ⇒ `Object`

#live_host_indices_size=(*args) ⇒ `Object`

#next_distribution_rebuild(*args) ⇒ `Object`

#next_distribution_rebuild=(*args) ⇒ `Object`

#number_of_hosts(*args) ⇒ `Object`

#number_of_hosts=(*args) ⇒ `Object`

#number_of_live_hosts(*args) ⇒ `Object`

#number_of_live_hosts=(*args) ⇒ `Object`

#on_cleanup(*args) ⇒ `Object`

#on_cleanup=(*args) ⇒ `Object`

#on_clone(*args) ⇒ `Object`

#on_clone=(*args) ⇒ `Object`

#poll_max_retries(*args) ⇒ `Object`

#poll_max_retries=(*args) ⇒ `Object`

#poll_timeout(*args) ⇒ `Object`

#poll_timeout=(*args) ⇒ `Object`

#prefix_key(*args) ⇒ `Object`

#prefix_key=(*args) ⇒ `Object`

#prefix_key_length(*args) ⇒ `Object`

#prefix_key_length=(*args) ⇒ `Object`

#purging(*args) ⇒ `Object`

#purging=(*args) ⇒ `Object`

#rcv_timeout(*args) ⇒ `Object`

#rcv_timeout=(*args) ⇒ `Object`

#recv_size(*args) ⇒ `Object`

#recv_size=(*args) ⇒ `Object`

#result(*args) ⇒ `Object`

#result=(*args) ⇒ `Object`

#retry_timeout(*args) ⇒ `Object`

#retry_timeout=(*args) ⇒ `Object`

#sasl_callbacks(*args) ⇒ `Object`

#sasl_callbacks=(*args) ⇒ `Object`

#send_size(*args) ⇒ `Object`