Class: Rlibmemcached::MemcachedResultSt

Inherits:
Object
  • Object
show all
Defined in:
ext/rlibmemcached/rlibmemcached_wrap.c

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ Object 



10469
10470
10471
10472
10473
10474
10475
10476
10477
10478
10479
10480
10481
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 10469

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

Instance Method Details

#cas(*args) ⇒ Object 



10311
10312
10313
10314
10315
10316
10317
10318
10319
10320
10321
10322
10323
10324
10325
10326
10327
10328
10329
10330
10331
10332
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 10311

SWIGINTERN VALUE
_wrap_MemcachedResultSt_cas_get(int argc, VALUE *argv, VALUE self) {
  struct memcached_result_st *arg1 = (struct memcached_result_st *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uint64_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_result_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_result_st *","cas", 1, self )); 
  }
  arg1 = (struct memcached_result_st *)(argp1);
  result =  ((arg1)->cas);
  vresult = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return vresult;
fail:
  return Qnil;
}

#cas=(*args) ⇒ Object 



10282
10283
10284
10285
10286
10287
10288
10289
10290
10291
10292
10293
10294
10295
10296
10297
10298
10299
10300
10301
10302
10303
10304
10305
10306
10307
10308
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 10282

SWIGINTERN VALUE
_wrap_MemcachedResultSt_cas_set(int argc, VALUE *argv, VALUE self) {
  struct memcached_result_st *arg1 = (struct memcached_result_st *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long 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_result_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_result_st *","cas", 1, self )); 
  }
  arg1 = (struct memcached_result_st *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "uint64_t","cas", 2, argv[0] ));
  } 
  arg2 = (uint64_t)(val2);
  if (arg1) (arg1)->cas = arg2;
  return Qnil;
fail:
  return Qnil;
}

#expiration(*args) ⇒ Object 



10152
10153
10154
10155
10156
10157
10158
10159
10160
10161
10162
10163
10164
10165
10166
10167
10168
10169
10170
10171
10172
10173
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 10152

SWIGINTERN VALUE
_wrap_MemcachedResultSt_expiration_get(int argc, VALUE *argv, VALUE self) {
  struct memcached_result_st *arg1 = (struct memcached_result_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_result_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_result_st *","expiration", 1, self )); 
  }
  arg1 = (struct memcached_result_st *)(argp1);
  result =  ((arg1)->expiration);
  vresult = SWIG_From_unsigned_SS_long((unsigned long)(result));
  return vresult;
fail:
  return Qnil;
}

#expiration=(*args) ⇒ Object 



10123
10124
10125
10126
10127
10128
10129
10130
10131
10132
10133
10134
10135
10136
10137
10138
10139
10140
10141
10142
10143
10144
10145
10146
10147
10148
10149
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 10123

SWIGINTERN VALUE
_wrap_MemcachedResultSt_expiration_set(int argc, VALUE *argv, VALUE self) {
  struct memcached_result_st *arg1 = (struct memcached_result_st *) 0 ;
  time_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_result_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_result_st *","expiration", 1, self )); 
  }
  arg1 = (struct memcached_result_st *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "time_t","expiration", 2, argv[0] ));
  } 
  arg2 = (time_t)(val2);
  if (arg1) (arg1)->expiration = arg2;
  return Qnil;
fail:
  return Qnil;
}

#flags(*args) ⇒ Object 



10046
10047
10048
10049
10050
10051
10052
10053
10054
10055
10056
10057
10058
10059
10060
10061
10062
10063
10064
10065
10066
10067
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 10046

SWIGINTERN VALUE
_wrap_MemcachedResultSt_flags_get(int argc, VALUE *argv, VALUE self) {
  struct memcached_result_st *arg1 = (struct memcached_result_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_result_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_result_st *","flags", 1, self )); 
  }
  arg1 = (struct memcached_result_st *)(argp1);
  result =  ((arg1)->flags);
  vresult = SWIG_From_unsigned_SS_long((unsigned long)(result));
  return vresult;
fail:
  return Qnil;
}

#flags=(*args) ⇒ Object 



10017
10018
10019
10020
10021
10022
10023
10024
10025
10026
10027
10028
10029
10030
10031
10032
10033
10034
10035
10036
10037
10038
10039
10040
10041
10042
10043
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 10017

SWIGINTERN VALUE
_wrap_MemcachedResultSt_flags_set(int argc, VALUE *argv, VALUE self) {
  struct memcached_result_st *arg1 = (struct memcached_result_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_result_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_result_st *","flags", 1, self )); 
  }
  arg1 = (struct memcached_result_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;
}

#is_allocated(*args) ⇒ Object 



10099
10100
10101
10102
10103
10104
10105
10106
10107
10108
10109
10110
10111
10112
10113
10114
10115
10116
10117
10118
10119
10120
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 10099

SWIGINTERN VALUE
_wrap_MemcachedResultSt_is_allocated_get(int argc, VALUE *argv, VALUE self) {
  struct memcached_result_st *arg1 = (struct memcached_result_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_result_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_result_st *","is_allocated", 1, self )); 
  }
  arg1 = (struct memcached_result_st *)(argp1);
  result = (bool) ((arg1)->is_allocated);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

#is_allocated=(*args) ⇒ Object 



10070
10071
10072
10073
10074
10075
10076
10077
10078
10079
10080
10081
10082
10083
10084
10085
10086
10087
10088
10089
10090
10091
10092
10093
10094
10095
10096
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 10070

SWIGINTERN VALUE
_wrap_MemcachedResultSt_is_allocated_set(int argc, VALUE *argv, VALUE self) {
  struct memcached_result_st *arg1 = (struct memcached_result_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_result_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_result_st *","is_allocated", 1, self )); 
  }
  arg1 = (struct memcached_result_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;
}

#key(*args) ⇒ Object 



10424
10425
10426
10427
10428
10429
10430
10431
10432
10433
10434
10435
10436
10437
10438
10439
10440
10441
10442
10443
10444
10445
10446
10447
10448
10449
10450
10451
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 10424

SWIGINTERN VALUE
_wrap_MemcachedResultSt_key_get(int argc, VALUE *argv, VALUE self) {
  struct memcached_result_st *arg1 = (struct memcached_result_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_result_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_result_st *","key", 1, self )); 
  }
  arg1 = (struct memcached_result_st *)(argp1);
  result = (char *)(char *) ((arg1)->key);
  {
    size_t size = SWIG_strnlen(result, 251);
    
    
    
    vresult = SWIG_FromCharPtrAndSize(result, size);
  }
  return vresult;
fail:
  return Qnil;
}

#key=(*args) ⇒ Object 



10394
10395
10396
10397
10398
10399
10400
10401
10402
10403
10404
10405
10406
10407
10408
10409
10410
10411
10412
10413
10414
10415
10416
10417
10418
10419
10420
10421
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 10394

SWIGINTERN VALUE
_wrap_MemcachedResultSt_key_set(int argc, VALUE *argv, VALUE self) {
  struct memcached_result_st *arg1 = (struct memcached_result_st *) 0 ;
  char *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char temp2[251] ;
  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_result_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_result_st *","key", 1, self )); 
  }
  arg1 = (struct memcached_result_st *)(argp1);
  res2 = SWIG_AsCharArray(argv[0], temp2, 251);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char [251]","key", 2, argv[0] ));
  }
  arg2 = (char *)(temp2);
  if (arg2) memcpy(arg1->key,arg2,251*sizeof(char));
  else memset(arg1->key,0,251*sizeof(char));
  return Qnil;
fail:
  return Qnil;
}

#key_length(*args) ⇒ Object 



10258
10259
10260
10261
10262
10263
10264
10265
10266
10267
10268
10269
10270
10271
10272
10273
10274
10275
10276
10277
10278
10279
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 10258

SWIGINTERN VALUE
_wrap_MemcachedResultSt_key_length_get(int argc, VALUE *argv, VALUE self) {
  struct memcached_result_st *arg1 = (struct memcached_result_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_result_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_result_st *","key_length", 1, self )); 
  }
  arg1 = (struct memcached_result_st *)(argp1);
  result =  ((arg1)->key_length);
  vresult = SWIG_From_size_t((size_t)(result));
  return vresult;
fail:
  return Qnil;
}

#key_length=(*args) ⇒ Object 



10229
10230
10231
10232
10233
10234
10235
10236
10237
10238
10239
10240
10241
10242
10243
10244
10245
10246
10247
10248
10249
10250
10251
10252
10253
10254
10255
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 10229

SWIGINTERN VALUE
_wrap_MemcachedResultSt_key_length_set(int argc, VALUE *argv, VALUE self) {
  struct memcached_result_st *arg1 = (struct memcached_result_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_result_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_result_st *","key_length", 1, self )); 
  }
  arg1 = (struct memcached_result_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","key_length", 2, argv[0] ));
  } 
  arg2 = (size_t)(val2);
  if (arg1) (arg1)->key_length = arg2;
  return Qnil;
fail:
  return Qnil;
}

#root(*args) ⇒ Object 



10205
10206
10207
10208
10209
10210
10211
10212
10213
10214
10215
10216
10217
10218
10219
10220
10221
10222
10223
10224
10225
10226
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 10205

SWIGINTERN VALUE
_wrap_MemcachedResultSt_root_get(int argc, VALUE *argv, VALUE self) {
  struct memcached_result_st *arg1 = (struct memcached_result_st *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  memcached_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_result_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_result_st *","root", 1, self )); 
  }
  arg1 = (struct memcached_result_st *)(argp1);
  result = (memcached_st *) ((arg1)->root);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_memcached_st, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

#root=(*args) ⇒ Object 



10176
10177
10178
10179
10180
10181
10182
10183
10184
10185
10186
10187
10188
10189
10190
10191
10192
10193
10194
10195
10196
10197
10198
10199
10200
10201
10202
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 10176

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

#value(*args) ⇒ Object 



10370
10371
10372
10373
10374
10375
10376
10377
10378
10379
10380
10381
10382
10383
10384
10385
10386
10387
10388
10389
10390
10391
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 10370

SWIGINTERN VALUE
_wrap_MemcachedResultSt_value_get(int argc, VALUE *argv, VALUE self) {
  struct memcached_result_st *arg1 = (struct memcached_result_st *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  memcached_string_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_result_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_result_st *","value", 1, self )); 
  }
  arg1 = (struct memcached_result_st *)(argp1);
  result =  ((arg1)->value);
  vresult = SWIG_NewPointerObj((memcached_string_st *)memcpy((memcached_string_st *)calloc(1,sizeof(memcached_string_st)),&result,sizeof(memcached_string_st)), SWIGTYPE_p_memcached_string_st, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#value=(*args) ⇒ Object 



10335
10336
10337
10338
10339
10340
10341
10342
10343
10344
10345
10346
10347
10348
10349
10350
10351
10352
10353
10354
10355
10356
10357
10358
10359
10360
10361
10362
10363
10364
10365
10366
10367
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 10335

SWIGINTERN VALUE
_wrap_MemcachedResultSt_value_set(int argc, VALUE *argv, VALUE self) {
  struct memcached_result_st *arg1 = (struct memcached_result_st *) 0 ;
  memcached_string_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_result_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_result_st *","value", 1, self )); 
  }
  arg1 = (struct memcached_result_st *)(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_memcached_string_st,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "memcached_string_st","value", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "memcached_string_st","value", 2, argv[0]));
    } else {
      arg2 = *((memcached_string_st *)(argp2));
    }
  }
  if (arg1) (arg1)->value = arg2;
  return Qnil;
fail:
  return Qnil;
}