memcached 0.19.9 → 0.19.10

Sign up to get free protection for your applications and to get access to all the features.
Files changed (11) hide show
  1. data.tar.gz.sig +0 -0
  2. data/CHANGELOG +2 -1
  3. data/Manifest +1 -0
  4. data/ext/extconf.rb +8 -4
  5. data/ext/libmemcached-4.patch +40 -0
  6. data/ext/rlibmemcached_wrap.c +457 -307
  7. data/lib/memcached/memcached.rb +1 -1
  8. data/memcached.gemspec +3 -3
  9. data/test/unit/memcached_test.rb +7 -0
  10. metadata +4 -3
  11. metadata.gz.sig +0 -0
data.tar.gz.sig CHANGED
Binary file
data/CHANGELOG CHANGED
@@ -1,4 +1,5 @@
1
- v0.19.9. Fix Memcached::Rails#add.
1
+
2
+ v0.19.10. Add no-op hash (MEMCACHED_HASH_NONE) to skip hashing when there is one server (bierbaum). Updated benchmark.
2
3
 
3
4
  v0.19.8. Support :noreply behavior.
4
5
 
data/Manifest CHANGED
@@ -9,6 +9,7 @@ ext/extconf.rb
9
9
  ext/libmemcached-0.32.tar.gz
10
10
  ext/libmemcached-2.patch
11
11
  ext/libmemcached-3.patch
12
+ ext/libmemcached-4.patch
12
13
  ext/libmemcached.patch
13
14
  ext/rlibmemcached.i
14
15
  ext/rlibmemcached_wrap.c
data/ext/extconf.rb CHANGED
@@ -10,7 +10,7 @@ SOLARIS_32 = RbConfig::CONFIG['target'] == "i386-pc-solaris2.10"
10
10
  $CFLAGS = "#{RbConfig::CONFIG['CFLAGS']} #{$CFLAGS}".gsub("$(cflags)", "").gsub("-fno-common", "")
11
11
  $CFLAGS << " -std=gnu99" if SOLARIS_32
12
12
  $EXTRA_CONF = " --disable-64bit" if SOLARIS_32
13
- $LDFLAGS = "#{RbConfig::CONFIG['LDFLAGS']} #{$LDFLAGS}".gsub("$(ldflags)", "").gsub("-fno-common", "")
13
+ $LDFLAGS = "#{RbConfig::CONFIG['LDFLAGS']} #{$LDFLAGS} -L#{RbConfig::CONFIG['libdir']}".gsub("$(ldflags)", "").gsub("-fno-common", "")
14
14
  $CXXFLAGS = " -std=gnu++98 #{$CFLAGS}"
15
15
  $CPPFLAGS = $ARCH_FLAG = $DLDFLAGS = ""
16
16
 
@@ -63,6 +63,10 @@ def check_libmemcached
63
63
  puts(cmd = "#{patch} -p1 -Z < libmemcached-3.patch")
64
64
  raise "'#{cmd}' failed" unless system(cmd) or ENV['DEV']
65
65
 
66
+ puts "Patching libmemcached for noop hash support."
67
+ puts(cmd = "#{patch} -p1 -Z < libmemcached-4.patch")
68
+ raise "'#{cmd}' failed" unless system(cmd) or ENV['DEV']
69
+
66
70
  puts "Touching aclocal.m4 in libmemcached."
67
71
  puts(cmd = "touch -r #{BUNDLE_PATH}/m4/visibility.m4 #{BUNDLE_PATH}/configure.ac #{BUNDLE_PATH}/m4/pandora_have_sasl.m4")
68
72
  raise "'#{cmd}' failed" unless system(cmd)
@@ -90,14 +94,14 @@ def check_libmemcached
90
94
  $LIBS << " -lmemcached_gem -lsasl2"
91
95
  end
92
96
 
97
+ check_libmemcached
98
+
93
99
  if ENV['SWIG']
94
100
  puts "Running SWIG."
95
101
  puts(cmd = "swig #{$defines} #{$includes} -ruby -autorename rlibmemcached.i")
96
102
  raise "'#{cmd}' failed" unless system(cmd)
97
- puts(cmd = "sed -i 's/STR2CSTR/StringValuePtr/' rlibmemcached_wrap.c")
103
+ puts(cmd = "sed -i '' 's/STR2CSTR/StringValuePtr/' rlibmemcached_wrap.c")
98
104
  raise "'#{cmd}' failed" unless system(cmd)
99
105
  end
100
106
 
101
- check_libmemcached
102
-
103
107
  create_makefile 'rlibmemcached'
data/ext/libmemcached-4.patch ADDED
@@ -0,0 +1,40 @@
1
+ diff --git a/libmemcached-0.32/clients/utilities.c b/libmemcached-0.32/clients/utilities.c
2
+ --- a/libmemcached-0.32/clients/utilities.c
3
+ +++ b/libmemcached-0.32/clients/utilities.c
4
+ @@ -99,6 +99,8 @@ void process_hash_option(memcached_st *memc, char *opt_hash)
5
+ set= MEMCACHED_HASH_FNV1_32;
6
+ else if (!strcasecmp(opt_hash, "FNV1A_32"))
7
+ set= MEMCACHED_HASH_FNV1A_32;
8
+ + else if (!strcasecmp(opt_hash, "NONE"))
9
+ + set= MEMCACHED_HASH_NONE;
10
+ else
11
+ {
12
+ fprintf(stderr, "hash: type not recognized %s\n", opt_hash);
13
+ diff --git a/libmemcached-0.32/libmemcached/memcached_constants.h b/libmemcached-0.32/libmemcached/memcached_constants.h
14
+ --- a/libmemcached-0.32/libmemcached/memcached_constants.h
15
+ +++ b/libmemcached-0.32/libmemcached/memcached_constants.h
16
+ @@ -132,7 +132,8 @@ typedef enum {
17
+ MEMCACHED_HASH_FNV1A_32,
18
+ MEMCACHED_HASH_HSIEH,
19
+ MEMCACHED_HASH_MURMUR,
20
+ - MEMCACHED_HASH_JENKINS
21
+ + MEMCACHED_HASH_JENKINS,
22
+ + MEMCACHED_HASH_NONE
23
+ } memcached_hash;
24
+
25
+ typedef enum {
26
+ diff --git a/libmemcached-0.32/libmemcached/memcached_hash.c b/libmemcached-0.32/libmemcached/memcached_hash.c
27
+ --- a/libmemcached-0.32/libmemcached/memcached_hash.c
28
+ +++ b/libmemcached-0.32/libmemcached/memcached_hash.c
29
+ @@ -96,6 +96,11 @@ uint32_t memcached_generate_hash_value(const char *key, size_t key_length, memca
30
+ hash=jenkins_hash(key, key_length, 13);
31
+ break;
32
+ }
33
+ + case MEMCACHED_HASH_NONE:
34
+ + {
35
+ + hash= 1;
36
+ + break;
37
+ + }
38
+ default:
39
+ {
40
+ WATCHPOINT_ASSERT(hash_algorithm);
data/ext/rlibmemcached_wrap.c CHANGED
@@ -1,6 +1,6 @@
1
1
  /* ----------------------------------------------------------------------------
2
2
  * This file was automatically generated by SWIG (http://www.swig.org).
3
- * Version 1.3.36
3
+ * Version 1.3.40
4
4
  *
5
5
  * This file is not intended to be easily readable and contains a number of
6
6
  * coding conventions designed to improve portability and efficiency. Do not make
@@ -9,6 +9,7 @@
9
9
  * ----------------------------------------------------------------------------- */
10
10
 
11
11
  #define SWIGRUBY
12
+
12
13
  /* -----------------------------------------------------------------------------
13
14
  * This section contains generic SWIG labels for method/variable
14
15
  * declarations/attributes, and other compiler dependent labels.
@@ -230,7 +231,7 @@
230
231
  /* -----------------------------------------------------------------------------
231
232
  * swigrun.swg
232
233
  *
233
- * This file contains generic CAPI SWIG runtime support for pointer
234
+ * This file contains generic C API SWIG runtime support for pointer
234
235
  * type checking.
235
236
  * ----------------------------------------------------------------------------- */
236
237
 
@@ -249,11 +250,11 @@
249
250
 
250
251
  /*
251
252
  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
252
- creating a static or dynamic library from the swig runtime code.
253
- In 99.9% of the cases, swig just needs to declare them as 'static'.
253
+ creating a static or dynamic library from the SWIG runtime code.
254
+ In 99.9% of the cases, SWIG just needs to declare them as 'static'.
254
255
 
255
- But only do this if is strictly necessary, ie, if you have problems
256
- with your compiler or so.
256
+ But only do this if strictly necessary, ie, if you have problems
257
+ with your compiler or suchlike.
257
258
  */
258
259
 
259
260
  #ifndef SWIGRUNTIME
@@ -280,14 +281,14 @@
280
281
  /*
281
282
  Flags/methods for returning states.
282
283
 
283
- The swig conversion methods, as ConvertPtr, return and integer
284
+ The SWIG conversion methods, as ConvertPtr, return and integer
284
285
  that tells if the conversion was successful or not. And if not,
285
286
  an error code can be returned (see swigerrors.swg for the codes).
286
287
 
287
288
  Use the following macros/flags to set or process the returning
288
289
  states.
289
290
 
290
- In old swig versions, you usually write code as:
291
+ In old versions of SWIG, code such as the following was usually written:
291
292
 
292
293
  if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
293
294
  // success code
@@ -295,7 +296,7 @@
295
296
  //fail code
296
297
  }
297
298
 
298
- Now you can be more explicit as:
299
+ Now you can be more explicit:
299
300
 
300
301
  int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
301
302
  if (SWIG_IsOK(res)) {
@@ -304,7 +305,7 @@
304
305
  // fail code
305
306
  }
306
307
 
307
- that seems to be the same, but now you can also do
308
+ which is the same really, but now you can also do
308
309
 
309
310
  Type *ptr;
310
311
  int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
@@ -322,7 +323,7 @@
322
323
 
323
324
  I.e., now SWIG_ConvertPtr can return new objects and you can
324
325
  identify the case and take care of the deallocation. Of course that
325
- requires also to SWIG_ConvertPtr to return new result values, as
326
+ also requires SWIG_ConvertPtr to return new result values, such as
326
327
 
327
328
  int SWIG_ConvertPtr(obj, ptr,...) {
328
329
  if (<obj is ok>) {
@@ -340,7 +341,7 @@
340
341
 
341
342
  Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
342
343
  more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
343
- swig errors code.
344
+ SWIG errors code.
344
345
 
345
346
  Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
346
347
  allows to return the 'cast rank', for example, if you have this
@@ -354,9 +355,8 @@
354
355
  fooi(1) // cast rank '0'
355
356
 
356
357
  just use the SWIG_AddCast()/SWIG_CheckState()
358
+ */
357
359
 
358
-
359
- */
360
360
  #define SWIG_OK (0)
361
361
  #define SWIG_ERROR (-1)
362
362
  #define SWIG_IsOK(r) (r >= 0)
@@ -381,7 +381,6 @@
381
381
  #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
382
382
  #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
383
383
 
384
-
385
384
  /* Cast-Rank Mode */
386
385
  #if defined(SWIG_CASTRANK_MODE)
387
386
  # ifndef SWIG_TypeRank
@@ -404,8 +403,6 @@ SWIGINTERNINLINE int SWIG_CheckState(int r) {
404
403
  #endif
405
404
 
406
405
 
407
-
408
-
409
406
  #include <string.h>
410
407
 
411
408
  #ifdef __cplusplus
@@ -502,40 +499,58 @@ SWIG_TypeCompare(const char *nb, const char *tb) {
502
499
  }
503
500
 
504
501
 
505
- /* think of this as a c++ template<> or a scheme macro */
506
- #define SWIG_TypeCheck_Template(comparison, ty) \
507
- if (ty) { \
508
- swig_cast_info *iter = ty->cast; \
509
- while (iter) { \
510
- if (comparison) { \
511
- if (iter == ty->cast) return iter; \
512
- /* Move iter to the top of the linked list */ \
513
- iter->prev->next = iter->next; \
514
- if (iter->next) \
515
- iter->next->prev = iter->prev; \
516
- iter->next = ty->cast; \
517
- iter->prev = 0; \
518
- if (ty->cast) ty->cast->prev = iter; \
519
- ty->cast = iter; \
520
- return iter; \
521
- } \
522
- iter = iter->next; \
523
- } \
524
- } \
525
- return 0
526
-
527
502
  /*
528
503
  Check the typename
529
504
  */
530
505
  SWIGRUNTIME swig_cast_info *
531
506
  SWIG_TypeCheck(const char *c, swig_type_info *ty) {
532
- SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
507
+ if (ty) {
508
+ swig_cast_info *iter = ty->cast;
509
+ while (iter) {
510
+ if (strcmp(iter->type->name, c) == 0) {
511
+ if (iter == ty->cast)
512
+ return iter;
513
+ /* Move iter to the top of the linked list */
514
+ iter->prev->next = iter->next;
515
+ if (iter->next)
516
+ iter->next->prev = iter->prev;
517
+ iter->next = ty->cast;
518
+ iter->prev = 0;
519
+ if (ty->cast) ty->cast->prev = iter;
520
+ ty->cast = iter;
521
+ return iter;
522
+ }
523
+ iter = iter->next;
524
+ }
525
+ }
526
+ return 0;
533
527
  }
534
528
 
535
- /* Same as previous function, except strcmp is replaced with a pointer comparison */
529
+ /*
530
+ Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
531
+ */
536
532
  SWIGRUNTIME swig_cast_info *
537
- SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
538
- SWIG_TypeCheck_Template(iter->type == from, into);
533
+ SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
534
+ if (ty) {
535
+ swig_cast_info *iter = ty->cast;
536
+ while (iter) {
537
+ if (iter->type == from) {
538
+ if (iter == ty->cast)
539
+ return iter;
540
+ /* Move iter to the top of the linked list */
541
+ iter->prev->next = iter->next;
542
+ if (iter->next)
543
+ iter->next->prev = iter->prev;
544
+ iter->next = ty->cast;
545
+ iter->prev = 0;
546
+ if (ty->cast) ty->cast->prev = iter;
547
+ ty->cast = iter;
548
+ return iter;
549
+ }
550
+ iter = iter->next;
551
+ }
552
+ }
553
+ return 0;
539
554
  }
540
555
 
541
556
  /*
@@ -823,6 +838,15 @@ SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
823
838
  #ifdef read
824
839
  # undef read
825
840
  #endif
841
+ #ifdef bind
842
+ # undef bind
843
+ #endif
844
+ #ifdef close
845
+ # undef close
846
+ #endif
847
+ #ifdef connect
848
+ # undef connect
849
+ #endif
826
850
 
827
851
 
828
852
  /* Ruby 1.7 defines NUM2LL(), LL2NUM() and ULL2NUM() macros */
@@ -1811,7 +1835,7 @@ static VALUE mRlibmemcached;
1811
1835
  #define SWIG_RUBY_THREAD_END_BLOCK
1812
1836
 
1813
1837
 
1814
- #define SWIGVERSION 0x010336
1838
+ #define SWIGVERSION 0x010340
1815
1839
  #define SWIG_VERSION SWIGVERSION
1816
1840
 
1817
1841
 
@@ -1826,7 +1850,14 @@ static VALUE mRlibmemcached;
1826
1850
  #ifdef __cplusplus
1827
1851
  extern "C" {
1828
1852
  #endif
1853
+
1854
+ // Ruby 1.9 changed the file name of this header
1855
+ #ifdef HAVE_RUBY_IO_H
1856
+ #include "ruby/io.h"
1857
+ #else
1829
1858
  #include "rubyio.h"
1859
+ #endif
1860
+
1830
1861
  #ifdef __cplusplus
1831
1862
  }
1832
1863
  #endif
@@ -1908,13 +1939,13 @@ SWIG_ruby_failed(void)
1908
1939
  }
1909
1940
 
1910
1941
 
1911
- /*@SWIG:/usr/share/swig1.3/ruby/rubyprimtypes.swg,23,%ruby_aux_method@*/
1942
+ /*@SWIG:/opt/local/share/swig/1.3.40/ruby/rubyprimtypes.swg,23,%ruby_aux_method@*/
1912
1943
  SWIGINTERN VALUE SWIG_AUX_NUM2DBL(VALUE *args)
1913
1944
  {
1914
1945
  VALUE obj = args[0];
1915
1946
  VALUE type = TYPE(obj);
1916
1947
  double *res = (double *)(args[1]);
1917
- *res = (type == T_FLOAT ? NUM2DBL(obj) : (type == T_FIXNUM ? (double) FIX2INT(obj) : rb_big2dbl(obj)));
1948
+ *res = NUM2DBL(obj);
1918
1949
  return obj;
1919
1950
  }
1920
1951
  /*@SWIG@*/
@@ -2002,7 +2033,7 @@ SWIG_AsCharArray(VALUE obj, char *val, size_t size)
2002
2033
  }
2003
2034
 
2004
2035
 
2005
- /*@SWIG:/usr/share/swig1.3/ruby/rubyprimtypes.swg,23,%ruby_aux_method@*/
2036
+ /*@SWIG:/opt/local/share/swig/1.3.40/ruby/rubyprimtypes.swg,23,%ruby_aux_method@*/
2006
2037
  SWIGINTERN VALUE SWIG_AUX_NUM2ULONG(VALUE *args)
2007
2038
  {
2008
2039
  VALUE obj = args[0];
@@ -2061,7 +2092,7 @@ SWIG_From_unsigned_SS_short (unsigned short value)
2061
2092
  }
2062
2093
 
2063
2094
 
2064
- /*@SWIG:/usr/share/swig1.3/ruby/rubyprimtypes.swg,23,%ruby_aux_method@*/
2095
+ /*@SWIG:/opt/local/share/swig/1.3.40/ruby/rubyprimtypes.swg,23,%ruby_aux_method@*/
2065
2096
  SWIGINTERN VALUE SWIG_AUX_NUM2LONG(VALUE *args)
2066
2097
  {
2067
2098
  VALUE obj = args[0];
@@ -2183,7 +2214,7 @@ SWIG_AsVal_unsigned_SS_int (VALUE obj, unsigned int *val)
2183
2214
  }
2184
2215
 
2185
2216
 
2186
- /*@SWIG:/usr/share/swig1.3/ruby/rubyprimtypes.swg,23,%ruby_aux_method@*/
2217
+ /*@SWIG:/opt/local/share/swig/1.3.40/ruby/rubyprimtypes.swg,23,%ruby_aux_method@*/
2187
2218
  SWIGINTERN VALUE SWIG_AUX_NUM2ULL(VALUE *args)
2188
2219
  {
2189
2220
  VALUE obj = args[0];
@@ -2228,6 +2259,7 @@ VALUE memcached_get_rvalue(memcached_st *ptr, const char *key, size_t key_length
2228
2259
  return ret;
2229
2260
  };
2230
2261
 
2262
+
2231
2263
  VALUE memcached_get_from_last_rvalue(memcached_st *ptr, const char *key, size_t key_length, uint32_t *flags, memcached_return *error) {
2232
2264
  VALUE ret;
2233
2265
  size_t value_length;
@@ -2278,7 +2310,7 @@ VALUE memcached_generate_hash_rvalue(const char *key, size_t key_length,memcache
2278
2310
  return UINT2NUM(memcached_generate_hash_value(key, key_length, hash_algorithm));
2279
2311
  };
2280
2312
 
2281
- swig_class cMemcachedAnalysisSt;
2313
+ swig_class SwigClassMemcachedAnalysisSt;
2282
2314
 
2283
2315
  SWIGINTERN VALUE
2284
2316
  _wrap_MemcachedAnalysisSt_average_item_size_set(int argc, VALUE *argv, VALUE self) {
@@ -2797,7 +2829,7 @@ free_memcached_analysis_st(struct memcached_analysis_st *arg1) {
2797
2829
  free((char *) arg1);
2798
2830
  }
2799
2831
 
2800
- swig_class cMemcachedStatSt;
2832
+ swig_class SwigClassMemcachedStatSt;
2801
2833
 
2802
2834
  SWIGINTERN VALUE
2803
2835
  _wrap_MemcachedStatSt_connection_structures_set(int argc, VALUE *argv, VALUE self) {
@@ -4299,7 +4331,7 @@ free_memcached_stat_st(struct memcached_stat_st *arg1) {
4299
4331
  free((char *) arg1);
4300
4332
  }
4301
4333
 
4302
- swig_class cMemcachedSt;
4334
+ swig_class SwigClassMemcachedSt;
4303
4335
 
4304
4336
  SWIGINTERN VALUE
4305
4337
  _wrap_MemcachedSt_purging_set(int argc, VALUE *argv, VALUE self) {
@@ -6725,6 +6757,59 @@ fail:
6725
6757
  }
6726
6758
 
6727
6759
 
6760
+ SWIGINTERN VALUE
6761
+ _wrap_MemcachedSt_last_server_key_set(int argc, VALUE *argv, VALUE self) {
6762
+ struct memcached_st *arg1 = (struct memcached_st *) 0 ;
6763
+ int arg2 ;
6764
+ void *argp1 = 0 ;
6765
+ int res1 = 0 ;
6766
+ int val2 ;
6767
+ int ecode2 = 0 ;
6768
+
6769
+ if ((argc < 1) || (argc > 1)) {
6770
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6771
+ }
6772
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 | 0 );
6773
+ if (!SWIG_IsOK(res1)) {
6774
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","last_server_key", 1, self ));
6775
+ }
6776
+ arg1 = (struct memcached_st *)(argp1);
6777
+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
6778
+ if (!SWIG_IsOK(ecode2)) {
6779
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","last_server_key", 2, argv[0] ));
6780
+ }
6781
+ arg2 = (int)(val2);
6782
+ if (arg1) (arg1)->last_server_key = arg2;
6783
+ return Qnil;
6784
+ fail:
6785
+ return Qnil;
6786
+ }
6787
+
6788
+
6789
+ SWIGINTERN VALUE
6790
+ _wrap_MemcachedSt_last_server_key_get(int argc, VALUE *argv, VALUE self) {
6791
+ struct memcached_st *arg1 = (struct memcached_st *) 0 ;
6792
+ void *argp1 = 0 ;
6793
+ int res1 = 0 ;
6794
+ int result;
6795
+ VALUE vresult = Qnil;
6796
+
6797
+ if ((argc < 0) || (argc > 0)) {
6798
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6799
+ }
6800
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 | 0 );
6801
+ if (!SWIG_IsOK(res1)) {
6802
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","last_server_key", 1, self ));
6803
+ }
6804
+ arg1 = (struct memcached_st *)(argp1);
6805
+ result = (int) ((arg1)->last_server_key);
6806
+ vresult = SWIG_From_int((int)(result));
6807
+ return vresult;
6808
+ fail:
6809
+ return Qnil;
6810
+ }
6811
+
6812
+
6728
6813
  #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
6729
6814
  SWIGINTERN VALUE
6730
6815
  _wrap_MemcachedSt_allocate(VALUE self) {
@@ -8917,6 +9002,66 @@ fail:
8917
9002
  }
8918
9003
 
8919
9004
 
9005
+ SWIGINTERN VALUE
9006
+ _wrap_memcached_get_from_last(int argc, VALUE *argv, VALUE self) {
9007
+ memcached_st *arg1 = (memcached_st *) 0 ;
9008
+ char *arg2 = (char *) 0 ;
9009
+ size_t arg3 ;
9010
+ size_t *arg4 = (size_t *) 0 ;
9011
+ uint32_t *arg5 = (uint32_t *) 0 ;
9012
+ memcached_return *arg6 = (memcached_return *) 0 ;
9013
+ void *argp1 = 0 ;
9014
+ int res1 = 0 ;
9015
+ size_t temp4 ;
9016
+ int res4 = SWIG_TMPOBJ ;
9017
+ uint32_t temp5 ;
9018
+ int res5 = SWIG_TMPOBJ ;
9019
+ memcached_return temp6 ;
9020
+ int res6 = SWIG_TMPOBJ ;
9021
+ char *result = 0 ;
9022
+ VALUE vresult = Qnil;
9023
+
9024
+ arg4 = &temp4;
9025
+ arg5 = &temp5;
9026
+ arg6 = &temp6;
9027
+ if ((argc < 2) || (argc > 2)) {
9028
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
9029
+ }
9030
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 | 0 );
9031
+ if (!SWIG_IsOK(res1)) {
9032
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_get_from_last", 1, argv[0] ));
9033
+ }
9034
+ arg1 = (memcached_st *)(argp1);
9035
+ {
9036
+ arg2 = StringValuePtr(argv[1]);
9037
+ arg3 = (size_t) RSTRING_LEN(argv[1]);
9038
+ }
9039
+ result = (char *)memcached_get_from_last(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
9040
+ vresult = SWIG_FromCharPtr((const char *)result);
9041
+ if (SWIG_IsTmpObj(res4)) {
9042
+ vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_size_t((*arg4)));
9043
+ } else {
9044
+ int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
9045
+ vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_size_t, new_flags));
9046
+ }
9047
+ if (SWIG_IsTmpObj(res5)) {
9048
+ vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_int((*arg5)));
9049
+ } else {
9050
+ int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
9051
+ vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_uint32_t, new_flags));
9052
+ }
9053
+ if (SWIG_IsTmpObj(res6)) {
9054
+ vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_short((*arg6)));
9055
+ } else {
9056
+ int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
9057
+ vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_memcached_return, new_flags));
9058
+ }
9059
+ return vresult;
9060
+ fail:
9061
+ return Qnil;
9062
+ }
9063
+
9064
+
8920
9065
  SWIGINTERN VALUE
8921
9066
  _wrap_memcached_set(int argc, VALUE *argv, VALUE self) {
8922
9067
  memcached_st *arg1 = (memcached_st *) 0 ;
@@ -9557,7 +9702,7 @@ fail:
9557
9702
  }
9558
9703
 
9559
9704
 
9560
- swig_class cMemcachedResultSt;
9705
+ swig_class SwigClassMemcachedResultSt;
9561
9706
 
9562
9707
  SWIGINTERN VALUE
9563
9708
  _wrap_MemcachedResultSt_flags_set(int argc, VALUE *argv, VALUE self) {
@@ -10199,7 +10344,7 @@ fail:
10199
10344
  }
10200
10345
 
10201
10346
 
10202
- swig_class cMemcachedServerSt;
10347
+ swig_class SwigClassMemcachedServerSt;
10203
10348
 
10204
10349
  SWIGINTERN VALUE
10205
10350
  _wrap_MemcachedServerSt_is_allocated_set(int argc, VALUE *argv, VALUE self) {
@@ -12220,6 +12365,7 @@ fail:
12220
12365
  return Qnil;
12221
12366
  }
12222
12367
 
12368
+
12223
12369
  SWIGINTERN VALUE
12224
12370
  _wrap_memcached_get_from_last_rvalue(int argc, VALUE *argv, VALUE self) {
12225
12371
  memcached_st *arg1 = (memcached_st *) 0 ;
@@ -12885,177 +13031,179 @@ SWIGEXPORT void Init_rlibmemcached(void) {
12885
13031
  rb_define_const(mRlibmemcached, "MEMCACHED_VERSION_STRING_LENGTH", SWIG_From_int((int)(24)));
12886
13032
  rb_define_const(mRlibmemcached, "LIBMEMCACHED_VERSION_STRING", SWIG_FromCharPtr("0.32"));
12887
13033
 
12888
- cMemcachedAnalysisSt.klass = rb_define_class_under(mRlibmemcached, "MemcachedAnalysisSt", rb_cObject);
12889
- SWIG_TypeClientData(SWIGTYPE_p_memcached_analysis_st, (void *) &cMemcachedAnalysisSt);
12890
- rb_define_alloc_func(cMemcachedAnalysisSt.klass, _wrap_MemcachedAnalysisSt_allocate);
12891
- rb_define_method(cMemcachedAnalysisSt.klass, "initialize", _wrap_new_MemcachedAnalysisSt, -1);
12892
- rb_define_method(cMemcachedAnalysisSt.klass, "average_item_size=", _wrap_MemcachedAnalysisSt_average_item_size_set, -1);
12893
- rb_define_method(cMemcachedAnalysisSt.klass, "average_item_size", _wrap_MemcachedAnalysisSt_average_item_size_get, -1);
12894
- rb_define_method(cMemcachedAnalysisSt.klass, "longest_uptime=", _wrap_MemcachedAnalysisSt_longest_uptime_set, -1);
12895
- rb_define_method(cMemcachedAnalysisSt.klass, "longest_uptime", _wrap_MemcachedAnalysisSt_longest_uptime_get, -1);
12896
- rb_define_method(cMemcachedAnalysisSt.klass, "least_free_server=", _wrap_MemcachedAnalysisSt_least_free_server_set, -1);
12897
- rb_define_method(cMemcachedAnalysisSt.klass, "least_free_server", _wrap_MemcachedAnalysisSt_least_free_server_get, -1);
12898
- rb_define_method(cMemcachedAnalysisSt.klass, "most_consumed_server=", _wrap_MemcachedAnalysisSt_most_consumed_server_set, -1);
12899
- rb_define_method(cMemcachedAnalysisSt.klass, "most_consumed_server", _wrap_MemcachedAnalysisSt_most_consumed_server_get, -1);
12900
- rb_define_method(cMemcachedAnalysisSt.klass, "oldest_server=", _wrap_MemcachedAnalysisSt_oldest_server_set, -1);
12901
- rb_define_method(cMemcachedAnalysisSt.klass, "oldest_server", _wrap_MemcachedAnalysisSt_oldest_server_get, -1);
12902
- rb_define_method(cMemcachedAnalysisSt.klass, "pool_hit_ratio=", _wrap_MemcachedAnalysisSt_pool_hit_ratio_set, -1);
12903
- rb_define_method(cMemcachedAnalysisSt.klass, "pool_hit_ratio", _wrap_MemcachedAnalysisSt_pool_hit_ratio_get, -1);
12904
- rb_define_method(cMemcachedAnalysisSt.klass, "most_used_bytes=", _wrap_MemcachedAnalysisSt_most_used_bytes_set, -1);
12905
- rb_define_method(cMemcachedAnalysisSt.klass, "most_used_bytes", _wrap_MemcachedAnalysisSt_most_used_bytes_get, -1);
12906
- rb_define_method(cMemcachedAnalysisSt.klass, "least_remaining_bytes=", _wrap_MemcachedAnalysisSt_least_remaining_bytes_set, -1);
12907
- rb_define_method(cMemcachedAnalysisSt.klass, "least_remaining_bytes", _wrap_MemcachedAnalysisSt_least_remaining_bytes_get, -1);
12908
- cMemcachedAnalysisSt.mark = 0;
12909
- cMemcachedAnalysisSt.destroy = (void (*)(void *)) free_memcached_analysis_st;
12910
- cMemcachedAnalysisSt.trackObjects = 0;
12911
-
12912
- cMemcachedStatSt.klass = rb_define_class_under(mRlibmemcached, "MemcachedStatSt", rb_cObject);
12913
- SWIG_TypeClientData(SWIGTYPE_p_memcached_stat_st, (void *) &cMemcachedStatSt);
12914
- rb_define_alloc_func(cMemcachedStatSt.klass, _wrap_MemcachedStatSt_allocate);
12915
- rb_define_method(cMemcachedStatSt.klass, "initialize", _wrap_new_MemcachedStatSt, -1);
12916
- rb_define_method(cMemcachedStatSt.klass, "connection_structures=", _wrap_MemcachedStatSt_connection_structures_set, -1);
12917
- rb_define_method(cMemcachedStatSt.klass, "connection_structures", _wrap_MemcachedStatSt_connection_structures_get, -1);
12918
- rb_define_method(cMemcachedStatSt.klass, "curr_connections=", _wrap_MemcachedStatSt_curr_connections_set, -1);
12919
- rb_define_method(cMemcachedStatSt.klass, "curr_connections", _wrap_MemcachedStatSt_curr_connections_get, -1);
12920
- rb_define_method(cMemcachedStatSt.klass, "curr_items=", _wrap_MemcachedStatSt_curr_items_set, -1);
12921
- rb_define_method(cMemcachedStatSt.klass, "curr_items", _wrap_MemcachedStatSt_curr_items_get, -1);
12922
- rb_define_method(cMemcachedStatSt.klass, "pid=", _wrap_MemcachedStatSt_pid_set, -1);
12923
- rb_define_method(cMemcachedStatSt.klass, "pid", _wrap_MemcachedStatSt_pid_get, -1);
12924
- rb_define_method(cMemcachedStatSt.klass, "pointer_size=", _wrap_MemcachedStatSt_pointer_size_set, -1);
12925
- rb_define_method(cMemcachedStatSt.klass, "pointer_size", _wrap_MemcachedStatSt_pointer_size_get, -1);
12926
- rb_define_method(cMemcachedStatSt.klass, "rusage_system_microseconds=", _wrap_MemcachedStatSt_rusage_system_microseconds_set, -1);
12927
- rb_define_method(cMemcachedStatSt.klass, "rusage_system_microseconds", _wrap_MemcachedStatSt_rusage_system_microseconds_get, -1);
12928
- rb_define_method(cMemcachedStatSt.klass, "rusage_system_seconds=", _wrap_MemcachedStatSt_rusage_system_seconds_set, -1);
12929
- rb_define_method(cMemcachedStatSt.klass, "rusage_system_seconds", _wrap_MemcachedStatSt_rusage_system_seconds_get, -1);
12930
- rb_define_method(cMemcachedStatSt.klass, "rusage_user_microseconds=", _wrap_MemcachedStatSt_rusage_user_microseconds_set, -1);
12931
- rb_define_method(cMemcachedStatSt.klass, "rusage_user_microseconds", _wrap_MemcachedStatSt_rusage_user_microseconds_get, -1);
12932
- rb_define_method(cMemcachedStatSt.klass, "rusage_user_seconds=", _wrap_MemcachedStatSt_rusage_user_seconds_set, -1);
12933
- rb_define_method(cMemcachedStatSt.klass, "rusage_user_seconds", _wrap_MemcachedStatSt_rusage_user_seconds_get, -1);
12934
- rb_define_method(cMemcachedStatSt.klass, "threads=", _wrap_MemcachedStatSt_threads_set, -1);
12935
- rb_define_method(cMemcachedStatSt.klass, "threads", _wrap_MemcachedStatSt_threads_get, -1);
12936
- rb_define_method(cMemcachedStatSt.klass, "time=", _wrap_MemcachedStatSt_time_set, -1);
12937
- rb_define_method(cMemcachedStatSt.klass, "time", _wrap_MemcachedStatSt_time_get, -1);
12938
- rb_define_method(cMemcachedStatSt.klass, "total_connections=", _wrap_MemcachedStatSt_total_connections_set, -1);
12939
- rb_define_method(cMemcachedStatSt.klass, "total_connections", _wrap_MemcachedStatSt_total_connections_get, -1);
12940
- rb_define_method(cMemcachedStatSt.klass, "total_items=", _wrap_MemcachedStatSt_total_items_set, -1);
12941
- rb_define_method(cMemcachedStatSt.klass, "total_items", _wrap_MemcachedStatSt_total_items_get, -1);
12942
- rb_define_method(cMemcachedStatSt.klass, "uptime=", _wrap_MemcachedStatSt_uptime_set, -1);
12943
- rb_define_method(cMemcachedStatSt.klass, "uptime", _wrap_MemcachedStatSt_uptime_get, -1);
12944
- rb_define_method(cMemcachedStatSt.klass, "bytes=", _wrap_MemcachedStatSt_bytes_set, -1);
12945
- rb_define_method(cMemcachedStatSt.klass, "bytes", _wrap_MemcachedStatSt_bytes_get, -1);
12946
- rb_define_method(cMemcachedStatSt.klass, "bytes_read=", _wrap_MemcachedStatSt_bytes_read_set, -1);
12947
- rb_define_method(cMemcachedStatSt.klass, "bytes_read", _wrap_MemcachedStatSt_bytes_read_get, -1);
12948
- rb_define_method(cMemcachedStatSt.klass, "bytes_written=", _wrap_MemcachedStatSt_bytes_written_set, -1);
12949
- rb_define_method(cMemcachedStatSt.klass, "bytes_written", _wrap_MemcachedStatSt_bytes_written_get, -1);
12950
- rb_define_method(cMemcachedStatSt.klass, "cmd_get=", _wrap_MemcachedStatSt_cmd_get_set, -1);
12951
- rb_define_method(cMemcachedStatSt.klass, "cmd_get", _wrap_MemcachedStatSt_cmd_get_get, -1);
12952
- rb_define_method(cMemcachedStatSt.klass, "cmd_set=", _wrap_MemcachedStatSt_cmd_set_set, -1);
12953
- rb_define_method(cMemcachedStatSt.klass, "cmd_set", _wrap_MemcachedStatSt_cmd_set_get, -1);
12954
- rb_define_method(cMemcachedStatSt.klass, "evictions=", _wrap_MemcachedStatSt_evictions_set, -1);
12955
- rb_define_method(cMemcachedStatSt.klass, "evictions", _wrap_MemcachedStatSt_evictions_get, -1);
12956
- rb_define_method(cMemcachedStatSt.klass, "get_hits=", _wrap_MemcachedStatSt_get_hits_set, -1);
12957
- rb_define_method(cMemcachedStatSt.klass, "get_hits", _wrap_MemcachedStatSt_get_hits_get, -1);
12958
- rb_define_method(cMemcachedStatSt.klass, "get_misses=", _wrap_MemcachedStatSt_get_misses_set, -1);
12959
- rb_define_method(cMemcachedStatSt.klass, "get_misses", _wrap_MemcachedStatSt_get_misses_get, -1);
12960
- rb_define_method(cMemcachedStatSt.klass, "limit_maxbytes=", _wrap_MemcachedStatSt_limit_maxbytes_set, -1);
12961
- rb_define_method(cMemcachedStatSt.klass, "limit_maxbytes", _wrap_MemcachedStatSt_limit_maxbytes_get, -1);
12962
- rb_define_method(cMemcachedStatSt.klass, "version=", _wrap_MemcachedStatSt_version_set, -1);
12963
- rb_define_method(cMemcachedStatSt.klass, "version", _wrap_MemcachedStatSt_version_get, -1);
12964
- cMemcachedStatSt.mark = 0;
12965
- cMemcachedStatSt.destroy = (void (*)(void *)) free_memcached_stat_st;
12966
- cMemcachedStatSt.trackObjects = 0;
12967
-
12968
- cMemcachedSt.klass = rb_define_class_under(mRlibmemcached, "MemcachedSt", rb_cObject);
12969
- SWIG_TypeClientData(SWIGTYPE_p_memcached_st, (void *) &cMemcachedSt);
12970
- rb_define_alloc_func(cMemcachedSt.klass, _wrap_MemcachedSt_allocate);
12971
- rb_define_method(cMemcachedSt.klass, "initialize", _wrap_new_MemcachedSt, -1);
12972
- rb_define_method(cMemcachedSt.klass, "purging=", _wrap_MemcachedSt_purging_set, -1);
12973
- rb_define_method(cMemcachedSt.klass, "purging", _wrap_MemcachedSt_purging_get, -1);
12974
- rb_define_method(cMemcachedSt.klass, "is_allocated=", _wrap_MemcachedSt_is_allocated_set, -1);
12975
- rb_define_method(cMemcachedSt.klass, "is_allocated", _wrap_MemcachedSt_is_allocated_get, -1);
12976
- rb_define_method(cMemcachedSt.klass, "distribution=", _wrap_MemcachedSt_distribution_set, -1);
12977
- rb_define_method(cMemcachedSt.klass, "distribution", _wrap_MemcachedSt_distribution_get, -1);
12978
- rb_define_method(cMemcachedSt.klass, "hash=", _wrap_MemcachedSt_hash_set, -1);
12979
- rb_define_method(cMemcachedSt.klass, "hash", _wrap_MemcachedSt_hash_get, -1);
12980
- rb_define_method(cMemcachedSt.klass, "continuum_points_counter=", _wrap_MemcachedSt_continuum_points_counter_set, -1);
12981
- rb_define_method(cMemcachedSt.klass, "continuum_points_counter", _wrap_MemcachedSt_continuum_points_counter_get, -1);
12982
- rb_define_method(cMemcachedSt.klass, "hosts=", _wrap_MemcachedSt_hosts_set, -1);
12983
- rb_define_method(cMemcachedSt.klass, "hosts", _wrap_MemcachedSt_hosts_get, -1);
12984
- rb_define_method(cMemcachedSt.klass, "snd_timeout=", _wrap_MemcachedSt_snd_timeout_set, -1);
12985
- rb_define_method(cMemcachedSt.klass, "snd_timeout", _wrap_MemcachedSt_snd_timeout_get, -1);
12986
- rb_define_method(cMemcachedSt.klass, "rcv_timeout=", _wrap_MemcachedSt_rcv_timeout_set, -1);
12987
- rb_define_method(cMemcachedSt.klass, "rcv_timeout", _wrap_MemcachedSt_rcv_timeout_get, -1);
12988
- rb_define_method(cMemcachedSt.klass, "server_failure_limit=", _wrap_MemcachedSt_server_failure_limit_set, -1);
12989
- rb_define_method(cMemcachedSt.klass, "server_failure_limit", _wrap_MemcachedSt_server_failure_limit_get, -1);
12990
- rb_define_method(cMemcachedSt.klass, "io_msg_watermark=", _wrap_MemcachedSt_io_msg_watermark_set, -1);
12991
- rb_define_method(cMemcachedSt.klass, "io_msg_watermark", _wrap_MemcachedSt_io_msg_watermark_get, -1);
12992
- rb_define_method(cMemcachedSt.klass, "io_bytes_watermark=", _wrap_MemcachedSt_io_bytes_watermark_set, -1);
12993
- rb_define_method(cMemcachedSt.klass, "io_bytes_watermark", _wrap_MemcachedSt_io_bytes_watermark_get, -1);
12994
- rb_define_method(cMemcachedSt.klass, "io_key_prefetch=", _wrap_MemcachedSt_io_key_prefetch_set, -1);
12995
- rb_define_method(cMemcachedSt.klass, "io_key_prefetch", _wrap_MemcachedSt_io_key_prefetch_get, -1);
12996
- rb_define_method(cMemcachedSt.klass, "number_of_hosts=", _wrap_MemcachedSt_number_of_hosts_set, -1);
12997
- rb_define_method(cMemcachedSt.klass, "number_of_hosts", _wrap_MemcachedSt_number_of_hosts_get, -1);
12998
- rb_define_method(cMemcachedSt.klass, "cursor_server=", _wrap_MemcachedSt_cursor_server_set, -1);
12999
- rb_define_method(cMemcachedSt.klass, "cursor_server", _wrap_MemcachedSt_cursor_server_get, -1);
13000
- rb_define_method(cMemcachedSt.klass, "cached_errno=", _wrap_MemcachedSt_cached_errno_set, -1);
13001
- rb_define_method(cMemcachedSt.klass, "cached_errno", _wrap_MemcachedSt_cached_errno_get, -1);
13002
- rb_define_method(cMemcachedSt.klass, "flags=", _wrap_MemcachedSt_flags_set, -1);
13003
- rb_define_method(cMemcachedSt.klass, "flags", _wrap_MemcachedSt_flags_get, -1);
13004
- rb_define_method(cMemcachedSt.klass, "poll_timeout=", _wrap_MemcachedSt_poll_timeout_set, -1);
13005
- rb_define_method(cMemcachedSt.klass, "poll_timeout", _wrap_MemcachedSt_poll_timeout_get, -1);
13006
- rb_define_method(cMemcachedSt.klass, "connect_timeout=", _wrap_MemcachedSt_connect_timeout_set, -1);
13007
- rb_define_method(cMemcachedSt.klass, "connect_timeout", _wrap_MemcachedSt_connect_timeout_get, -1);
13008
- rb_define_method(cMemcachedSt.klass, "retry_timeout=", _wrap_MemcachedSt_retry_timeout_set, -1);
13009
- rb_define_method(cMemcachedSt.klass, "retry_timeout", _wrap_MemcachedSt_retry_timeout_get, -1);
13010
- rb_define_method(cMemcachedSt.klass, "continuum_count=", _wrap_MemcachedSt_continuum_count_set, -1);
13011
- rb_define_method(cMemcachedSt.klass, "continuum_count", _wrap_MemcachedSt_continuum_count_get, -1);
13012
- rb_define_method(cMemcachedSt.klass, "send_size=", _wrap_MemcachedSt_send_size_set, -1);
13013
- rb_define_method(cMemcachedSt.klass, "send_size", _wrap_MemcachedSt_send_size_get, -1);
13014
- rb_define_method(cMemcachedSt.klass, "recv_size=", _wrap_MemcachedSt_recv_size_set, -1);
13015
- rb_define_method(cMemcachedSt.klass, "recv_size", _wrap_MemcachedSt_recv_size_get, -1);
13016
- rb_define_method(cMemcachedSt.klass, "user_data=", _wrap_MemcachedSt_user_data_set, -1);
13017
- rb_define_method(cMemcachedSt.klass, "user_data", _wrap_MemcachedSt_user_data_get, -1);
13018
- rb_define_method(cMemcachedSt.klass, "next_distribution_rebuild=", _wrap_MemcachedSt_next_distribution_rebuild_set, -1);
13019
- rb_define_method(cMemcachedSt.klass, "next_distribution_rebuild", _wrap_MemcachedSt_next_distribution_rebuild_get, -1);
13020
- rb_define_method(cMemcachedSt.klass, "prefix_key_length=", _wrap_MemcachedSt_prefix_key_length_set, -1);
13021
- rb_define_method(cMemcachedSt.klass, "prefix_key_length", _wrap_MemcachedSt_prefix_key_length_get, -1);
13022
- rb_define_method(cMemcachedSt.klass, "hash_continuum=", _wrap_MemcachedSt_hash_continuum_set, -1);
13023
- rb_define_method(cMemcachedSt.klass, "hash_continuum", _wrap_MemcachedSt_hash_continuum_get, -1);
13024
- rb_define_method(cMemcachedSt.klass, "result=", _wrap_MemcachedSt_result_set, -1);
13025
- rb_define_method(cMemcachedSt.klass, "result", _wrap_MemcachedSt_result_get, -1);
13026
- rb_define_method(cMemcachedSt.klass, "continuum=", _wrap_MemcachedSt_continuum_set, -1);
13027
- rb_define_method(cMemcachedSt.klass, "continuum", _wrap_MemcachedSt_continuum_get, -1);
13028
- rb_define_method(cMemcachedSt.klass, "on_clone=", _wrap_MemcachedSt_on_clone_set, -1);
13029
- rb_define_method(cMemcachedSt.klass, "on_clone", _wrap_MemcachedSt_on_clone_get, -1);
13030
- rb_define_method(cMemcachedSt.klass, "on_cleanup=", _wrap_MemcachedSt_on_cleanup_set, -1);
13031
- rb_define_method(cMemcachedSt.klass, "on_cleanup", _wrap_MemcachedSt_on_cleanup_get, -1);
13032
- rb_define_method(cMemcachedSt.klass, "call_free=", _wrap_MemcachedSt_call_free_set, -1);
13033
- rb_define_method(cMemcachedSt.klass, "call_free", _wrap_MemcachedSt_call_free_get, -1);
13034
- rb_define_method(cMemcachedSt.klass, "call_malloc=", _wrap_MemcachedSt_call_malloc_set, -1);
13035
- rb_define_method(cMemcachedSt.klass, "call_malloc", _wrap_MemcachedSt_call_malloc_get, -1);
13036
- rb_define_method(cMemcachedSt.klass, "call_realloc=", _wrap_MemcachedSt_call_realloc_set, -1);
13037
- rb_define_method(cMemcachedSt.klass, "call_realloc", _wrap_MemcachedSt_call_realloc_get, -1);
13038
- rb_define_method(cMemcachedSt.klass, "call_calloc=", _wrap_MemcachedSt_call_calloc_set, -1);
13039
- rb_define_method(cMemcachedSt.klass, "call_calloc", _wrap_MemcachedSt_call_calloc_get, -1);
13040
- rb_define_method(cMemcachedSt.klass, "get_key_failure=", _wrap_MemcachedSt_get_key_failure_set, -1);
13041
- rb_define_method(cMemcachedSt.klass, "get_key_failure", _wrap_MemcachedSt_get_key_failure_get, -1);
13042
- rb_define_method(cMemcachedSt.klass, "delete_trigger=", _wrap_MemcachedSt_delete_trigger_set, -1);
13043
- rb_define_method(cMemcachedSt.klass, "delete_trigger", _wrap_MemcachedSt_delete_trigger_get, -1);
13044
- rb_define_method(cMemcachedSt.klass, "prefix_key=", _wrap_MemcachedSt_prefix_key_set, -1);
13045
- rb_define_method(cMemcachedSt.klass, "prefix_key", _wrap_MemcachedSt_prefix_key_get, -1);
13046
- rb_define_method(cMemcachedSt.klass, "number_of_replicas=", _wrap_MemcachedSt_number_of_replicas_set, -1);
13047
- rb_define_method(cMemcachedSt.klass, "number_of_replicas", _wrap_MemcachedSt_number_of_replicas_get, -1);
13048
- rb_define_method(cMemcachedSt.klass, "number_of_live_hosts=", _wrap_MemcachedSt_number_of_live_hosts_set, -1);
13049
- rb_define_method(cMemcachedSt.klass, "number_of_live_hosts", _wrap_MemcachedSt_number_of_live_hosts_get, -1);
13050
- rb_define_method(cMemcachedSt.klass, "live_host_indices=", _wrap_MemcachedSt_live_host_indices_set, -1);
13051
- rb_define_method(cMemcachedSt.klass, "live_host_indices", _wrap_MemcachedSt_live_host_indices_get, -1);
13052
- rb_define_method(cMemcachedSt.klass, "live_host_indices_size=", _wrap_MemcachedSt_live_host_indices_size_set, -1);
13053
- rb_define_method(cMemcachedSt.klass, "live_host_indices_size", _wrap_MemcachedSt_live_host_indices_size_get, -1);
13054
- rb_define_method(cMemcachedSt.klass, "sasl_callbacks=", _wrap_MemcachedSt_sasl_callbacks_set, -1);
13055
- rb_define_method(cMemcachedSt.klass, "sasl_callbacks", _wrap_MemcachedSt_sasl_callbacks_get, -1);
13056
- cMemcachedSt.mark = 0;
13057
- cMemcachedSt.destroy = (void (*)(void *)) memcached_free;
13058
- cMemcachedSt.trackObjects = 0;
13034
+ SwigClassMemcachedAnalysisSt.klass = rb_define_class_under(mRlibmemcached, "MemcachedAnalysisSt", rb_cObject);
13035
+ SWIG_TypeClientData(SWIGTYPE_p_memcached_analysis_st, (void *) &SwigClassMemcachedAnalysisSt);
13036
+ rb_define_alloc_func(SwigClassMemcachedAnalysisSt.klass, _wrap_MemcachedAnalysisSt_allocate);
13037
+ rb_define_method(SwigClassMemcachedAnalysisSt.klass, "initialize", _wrap_new_MemcachedAnalysisSt, -1);
13038
+ rb_define_method(SwigClassMemcachedAnalysisSt.klass, "average_item_size=", _wrap_MemcachedAnalysisSt_average_item_size_set, -1);
13039
+ rb_define_method(SwigClassMemcachedAnalysisSt.klass, "average_item_size", _wrap_MemcachedAnalysisSt_average_item_size_get, -1);
13040
+ rb_define_method(SwigClassMemcachedAnalysisSt.klass, "longest_uptime=", _wrap_MemcachedAnalysisSt_longest_uptime_set, -1);
13041
+ rb_define_method(SwigClassMemcachedAnalysisSt.klass, "longest_uptime", _wrap_MemcachedAnalysisSt_longest_uptime_get, -1);
13042
+ rb_define_method(SwigClassMemcachedAnalysisSt.klass, "least_free_server=", _wrap_MemcachedAnalysisSt_least_free_server_set, -1);
13043
+ rb_define_method(SwigClassMemcachedAnalysisSt.klass, "least_free_server", _wrap_MemcachedAnalysisSt_least_free_server_get, -1);
13044
+ rb_define_method(SwigClassMemcachedAnalysisSt.klass, "most_consumed_server=", _wrap_MemcachedAnalysisSt_most_consumed_server_set, -1);
13045
+ rb_define_method(SwigClassMemcachedAnalysisSt.klass, "most_consumed_server", _wrap_MemcachedAnalysisSt_most_consumed_server_get, -1);
13046
+ rb_define_method(SwigClassMemcachedAnalysisSt.klass, "oldest_server=", _wrap_MemcachedAnalysisSt_oldest_server_set, -1);
13047
+ rb_define_method(SwigClassMemcachedAnalysisSt.klass, "oldest_server", _wrap_MemcachedAnalysisSt_oldest_server_get, -1);
13048
+ rb_define_method(SwigClassMemcachedAnalysisSt.klass, "pool_hit_ratio=", _wrap_MemcachedAnalysisSt_pool_hit_ratio_set, -1);
13049
+ rb_define_method(SwigClassMemcachedAnalysisSt.klass, "pool_hit_ratio", _wrap_MemcachedAnalysisSt_pool_hit_ratio_get, -1);
13050
+ rb_define_method(SwigClassMemcachedAnalysisSt.klass, "most_used_bytes=", _wrap_MemcachedAnalysisSt_most_used_bytes_set, -1);
13051
+ rb_define_method(SwigClassMemcachedAnalysisSt.klass, "most_used_bytes", _wrap_MemcachedAnalysisSt_most_used_bytes_get, -1);
13052
+ rb_define_method(SwigClassMemcachedAnalysisSt.klass, "least_remaining_bytes=", _wrap_MemcachedAnalysisSt_least_remaining_bytes_set, -1);
13053
+ rb_define_method(SwigClassMemcachedAnalysisSt.klass, "least_remaining_bytes", _wrap_MemcachedAnalysisSt_least_remaining_bytes_get, -1);
13054
+ SwigClassMemcachedAnalysisSt.mark = 0;
13055
+ SwigClassMemcachedAnalysisSt.destroy = (void (*)(void *)) free_memcached_analysis_st;
13056
+ SwigClassMemcachedAnalysisSt.trackObjects = 0;
13057
+
13058
+ SwigClassMemcachedStatSt.klass = rb_define_class_under(mRlibmemcached, "MemcachedStatSt", rb_cObject);
13059
+ SWIG_TypeClientData(SWIGTYPE_p_memcached_stat_st, (void *) &SwigClassMemcachedStatSt);
13060
+ rb_define_alloc_func(SwigClassMemcachedStatSt.klass, _wrap_MemcachedStatSt_allocate);
13061
+ rb_define_method(SwigClassMemcachedStatSt.klass, "initialize", _wrap_new_MemcachedStatSt, -1);
13062
+ rb_define_method(SwigClassMemcachedStatSt.klass, "connection_structures=", _wrap_MemcachedStatSt_connection_structures_set, -1);
13063
+ rb_define_method(SwigClassMemcachedStatSt.klass, "connection_structures", _wrap_MemcachedStatSt_connection_structures_get, -1);
13064
+ rb_define_method(SwigClassMemcachedStatSt.klass, "curr_connections=", _wrap_MemcachedStatSt_curr_connections_set, -1);
13065
+ rb_define_method(SwigClassMemcachedStatSt.klass, "curr_connections", _wrap_MemcachedStatSt_curr_connections_get, -1);
13066
+ rb_define_method(SwigClassMemcachedStatSt.klass, "curr_items=", _wrap_MemcachedStatSt_curr_items_set, -1);
13067
+ rb_define_method(SwigClassMemcachedStatSt.klass, "curr_items", _wrap_MemcachedStatSt_curr_items_get, -1);
13068
+ rb_define_method(SwigClassMemcachedStatSt.klass, "pid=", _wrap_MemcachedStatSt_pid_set, -1);
13069
+ rb_define_method(SwigClassMemcachedStatSt.klass, "pid", _wrap_MemcachedStatSt_pid_get, -1);
13070
+ rb_define_method(SwigClassMemcachedStatSt.klass, "pointer_size=", _wrap_MemcachedStatSt_pointer_size_set, -1);
13071
+ rb_define_method(SwigClassMemcachedStatSt.klass, "pointer_size", _wrap_MemcachedStatSt_pointer_size_get, -1);
13072
+ rb_define_method(SwigClassMemcachedStatSt.klass, "rusage_system_microseconds=", _wrap_MemcachedStatSt_rusage_system_microseconds_set, -1);
13073
+ rb_define_method(SwigClassMemcachedStatSt.klass, "rusage_system_microseconds", _wrap_MemcachedStatSt_rusage_system_microseconds_get, -1);
13074
+ rb_define_method(SwigClassMemcachedStatSt.klass, "rusage_system_seconds=", _wrap_MemcachedStatSt_rusage_system_seconds_set, -1);
13075
+ rb_define_method(SwigClassMemcachedStatSt.klass, "rusage_system_seconds", _wrap_MemcachedStatSt_rusage_system_seconds_get, -1);
13076
+ rb_define_method(SwigClassMemcachedStatSt.klass, "rusage_user_microseconds=", _wrap_MemcachedStatSt_rusage_user_microseconds_set, -1);
13077
+ rb_define_method(SwigClassMemcachedStatSt.klass, "rusage_user_microseconds", _wrap_MemcachedStatSt_rusage_user_microseconds_get, -1);
13078
+ rb_define_method(SwigClassMemcachedStatSt.klass, "rusage_user_seconds=", _wrap_MemcachedStatSt_rusage_user_seconds_set, -1);
13079
+ rb_define_method(SwigClassMemcachedStatSt.klass, "rusage_user_seconds", _wrap_MemcachedStatSt_rusage_user_seconds_get, -1);
13080
+ rb_define_method(SwigClassMemcachedStatSt.klass, "threads=", _wrap_MemcachedStatSt_threads_set, -1);
13081
+ rb_define_method(SwigClassMemcachedStatSt.klass, "threads", _wrap_MemcachedStatSt_threads_get, -1);
13082
+ rb_define_method(SwigClassMemcachedStatSt.klass, "time=", _wrap_MemcachedStatSt_time_set, -1);
13083
+ rb_define_method(SwigClassMemcachedStatSt.klass, "time", _wrap_MemcachedStatSt_time_get, -1);
13084
+ rb_define_method(SwigClassMemcachedStatSt.klass, "total_connections=", _wrap_MemcachedStatSt_total_connections_set, -1);
13085
+ rb_define_method(SwigClassMemcachedStatSt.klass, "total_connections", _wrap_MemcachedStatSt_total_connections_get, -1);
13086
+ rb_define_method(SwigClassMemcachedStatSt.klass, "total_items=", _wrap_MemcachedStatSt_total_items_set, -1);
13087
+ rb_define_method(SwigClassMemcachedStatSt.klass, "total_items", _wrap_MemcachedStatSt_total_items_get, -1);
13088
+ rb_define_method(SwigClassMemcachedStatSt.klass, "uptime=", _wrap_MemcachedStatSt_uptime_set, -1);
13089
+ rb_define_method(SwigClassMemcachedStatSt.klass, "uptime", _wrap_MemcachedStatSt_uptime_get, -1);
13090
+ rb_define_method(SwigClassMemcachedStatSt.klass, "bytes=", _wrap_MemcachedStatSt_bytes_set, -1);
13091
+ rb_define_method(SwigClassMemcachedStatSt.klass, "bytes", _wrap_MemcachedStatSt_bytes_get, -1);
13092
+ rb_define_method(SwigClassMemcachedStatSt.klass, "bytes_read=", _wrap_MemcachedStatSt_bytes_read_set, -1);
13093
+ rb_define_method(SwigClassMemcachedStatSt.klass, "bytes_read", _wrap_MemcachedStatSt_bytes_read_get, -1);
13094
+ rb_define_method(SwigClassMemcachedStatSt.klass, "bytes_written=", _wrap_MemcachedStatSt_bytes_written_set, -1);
13095
+ rb_define_method(SwigClassMemcachedStatSt.klass, "bytes_written", _wrap_MemcachedStatSt_bytes_written_get, -1);
13096
+ rb_define_method(SwigClassMemcachedStatSt.klass, "cmd_get=", _wrap_MemcachedStatSt_cmd_get_set, -1);
13097
+ rb_define_method(SwigClassMemcachedStatSt.klass, "cmd_get", _wrap_MemcachedStatSt_cmd_get_get, -1);
13098
+ rb_define_method(SwigClassMemcachedStatSt.klass, "cmd_set=", _wrap_MemcachedStatSt_cmd_set_set, -1);
13099
+ rb_define_method(SwigClassMemcachedStatSt.klass, "cmd_set", _wrap_MemcachedStatSt_cmd_set_get, -1);
13100
+ rb_define_method(SwigClassMemcachedStatSt.klass, "evictions=", _wrap_MemcachedStatSt_evictions_set, -1);
13101
+ rb_define_method(SwigClassMemcachedStatSt.klass, "evictions", _wrap_MemcachedStatSt_evictions_get, -1);
13102
+ rb_define_method(SwigClassMemcachedStatSt.klass, "get_hits=", _wrap_MemcachedStatSt_get_hits_set, -1);
13103
+ rb_define_method(SwigClassMemcachedStatSt.klass, "get_hits", _wrap_MemcachedStatSt_get_hits_get, -1);
13104
+ rb_define_method(SwigClassMemcachedStatSt.klass, "get_misses=", _wrap_MemcachedStatSt_get_misses_set, -1);
13105
+ rb_define_method(SwigClassMemcachedStatSt.klass, "get_misses", _wrap_MemcachedStatSt_get_misses_get, -1);
13106
+ rb_define_method(SwigClassMemcachedStatSt.klass, "limit_maxbytes=", _wrap_MemcachedStatSt_limit_maxbytes_set, -1);
13107
+ rb_define_method(SwigClassMemcachedStatSt.klass, "limit_maxbytes", _wrap_MemcachedStatSt_limit_maxbytes_get, -1);
13108
+ rb_define_method(SwigClassMemcachedStatSt.klass, "version=", _wrap_MemcachedStatSt_version_set, -1);
13109
+ rb_define_method(SwigClassMemcachedStatSt.klass, "version", _wrap_MemcachedStatSt_version_get, -1);
13110
+ SwigClassMemcachedStatSt.mark = 0;
13111
+ SwigClassMemcachedStatSt.destroy = (void (*)(void *)) free_memcached_stat_st;
13112
+ SwigClassMemcachedStatSt.trackObjects = 0;
13113
+
13114
+ SwigClassMemcachedSt.klass = rb_define_class_under(mRlibmemcached, "MemcachedSt", rb_cObject);
13115
+ SWIG_TypeClientData(SWIGTYPE_p_memcached_st, (void *) &SwigClassMemcachedSt);
13116
+ rb_define_alloc_func(SwigClassMemcachedSt.klass, _wrap_MemcachedSt_allocate);
13117
+ rb_define_method(SwigClassMemcachedSt.klass, "initialize", _wrap_new_MemcachedSt, -1);
13118
+ rb_define_method(SwigClassMemcachedSt.klass, "purging=", _wrap_MemcachedSt_purging_set, -1);
13119
+ rb_define_method(SwigClassMemcachedSt.klass, "purging", _wrap_MemcachedSt_purging_get, -1);
13120
+ rb_define_method(SwigClassMemcachedSt.klass, "is_allocated=", _wrap_MemcachedSt_is_allocated_set, -1);
13121
+ rb_define_method(SwigClassMemcachedSt.klass, "is_allocated", _wrap_MemcachedSt_is_allocated_get, -1);
13122
+ rb_define_method(SwigClassMemcachedSt.klass, "distribution=", _wrap_MemcachedSt_distribution_set, -1);
13123
+ rb_define_method(SwigClassMemcachedSt.klass, "distribution", _wrap_MemcachedSt_distribution_get, -1);
13124
+ rb_define_method(SwigClassMemcachedSt.klass, "hash=", _wrap_MemcachedSt_hash_set, -1);
13125
+ rb_define_method(SwigClassMemcachedSt.klass, "hash", _wrap_MemcachedSt_hash_get, -1);
13126
+ rb_define_method(SwigClassMemcachedSt.klass, "continuum_points_counter=", _wrap_MemcachedSt_continuum_points_counter_set, -1);
13127
+ rb_define_method(SwigClassMemcachedSt.klass, "continuum_points_counter", _wrap_MemcachedSt_continuum_points_counter_get, -1);
13128
+ rb_define_method(SwigClassMemcachedSt.klass, "hosts=", _wrap_MemcachedSt_hosts_set, -1);
13129
+ rb_define_method(SwigClassMemcachedSt.klass, "hosts", _wrap_MemcachedSt_hosts_get, -1);
13130
+ rb_define_method(SwigClassMemcachedSt.klass, "snd_timeout=", _wrap_MemcachedSt_snd_timeout_set, -1);
13131
+ rb_define_method(SwigClassMemcachedSt.klass, "snd_timeout", _wrap_MemcachedSt_snd_timeout_get, -1);
13132
+ rb_define_method(SwigClassMemcachedSt.klass, "rcv_timeout=", _wrap_MemcachedSt_rcv_timeout_set, -1);
13133
+ rb_define_method(SwigClassMemcachedSt.klass, "rcv_timeout", _wrap_MemcachedSt_rcv_timeout_get, -1);
13134
+ rb_define_method(SwigClassMemcachedSt.klass, "server_failure_limit=", _wrap_MemcachedSt_server_failure_limit_set, -1);
13135
+ rb_define_method(SwigClassMemcachedSt.klass, "server_failure_limit", _wrap_MemcachedSt_server_failure_limit_get, -1);
13136
+ rb_define_method(SwigClassMemcachedSt.klass, "io_msg_watermark=", _wrap_MemcachedSt_io_msg_watermark_set, -1);
13137
+ rb_define_method(SwigClassMemcachedSt.klass, "io_msg_watermark", _wrap_MemcachedSt_io_msg_watermark_get, -1);
13138
+ rb_define_method(SwigClassMemcachedSt.klass, "io_bytes_watermark=", _wrap_MemcachedSt_io_bytes_watermark_set, -1);
13139
+ rb_define_method(SwigClassMemcachedSt.klass, "io_bytes_watermark", _wrap_MemcachedSt_io_bytes_watermark_get, -1);
13140
+ rb_define_method(SwigClassMemcachedSt.klass, "io_key_prefetch=", _wrap_MemcachedSt_io_key_prefetch_set, -1);
13141
+ rb_define_method(SwigClassMemcachedSt.klass, "io_key_prefetch", _wrap_MemcachedSt_io_key_prefetch_get, -1);
13142
+ rb_define_method(SwigClassMemcachedSt.klass, "number_of_hosts=", _wrap_MemcachedSt_number_of_hosts_set, -1);
13143
+ rb_define_method(SwigClassMemcachedSt.klass, "number_of_hosts", _wrap_MemcachedSt_number_of_hosts_get, -1);
13144
+ rb_define_method(SwigClassMemcachedSt.klass, "cursor_server=", _wrap_MemcachedSt_cursor_server_set, -1);
13145
+ rb_define_method(SwigClassMemcachedSt.klass, "cursor_server", _wrap_MemcachedSt_cursor_server_get, -1);
13146
+ rb_define_method(SwigClassMemcachedSt.klass, "cached_errno=", _wrap_MemcachedSt_cached_errno_set, -1);
13147
+ rb_define_method(SwigClassMemcachedSt.klass, "cached_errno", _wrap_MemcachedSt_cached_errno_get, -1);
13148
+ rb_define_method(SwigClassMemcachedSt.klass, "flags=", _wrap_MemcachedSt_flags_set, -1);
13149
+ rb_define_method(SwigClassMemcachedSt.klass, "flags", _wrap_MemcachedSt_flags_get, -1);
13150
+ rb_define_method(SwigClassMemcachedSt.klass, "poll_timeout=", _wrap_MemcachedSt_poll_timeout_set, -1);
13151
+ rb_define_method(SwigClassMemcachedSt.klass, "poll_timeout", _wrap_MemcachedSt_poll_timeout_get, -1);
13152
+ rb_define_method(SwigClassMemcachedSt.klass, "connect_timeout=", _wrap_MemcachedSt_connect_timeout_set, -1);
13153
+ rb_define_method(SwigClassMemcachedSt.klass, "connect_timeout", _wrap_MemcachedSt_connect_timeout_get, -1);
13154
+ rb_define_method(SwigClassMemcachedSt.klass, "retry_timeout=", _wrap_MemcachedSt_retry_timeout_set, -1);
13155
+ rb_define_method(SwigClassMemcachedSt.klass, "retry_timeout", _wrap_MemcachedSt_retry_timeout_get, -1);
13156
+ rb_define_method(SwigClassMemcachedSt.klass, "continuum_count=", _wrap_MemcachedSt_continuum_count_set, -1);
13157
+ rb_define_method(SwigClassMemcachedSt.klass, "continuum_count", _wrap_MemcachedSt_continuum_count_get, -1);
13158
+ rb_define_method(SwigClassMemcachedSt.klass, "send_size=", _wrap_MemcachedSt_send_size_set, -1);
13159
+ rb_define_method(SwigClassMemcachedSt.klass, "send_size", _wrap_MemcachedSt_send_size_get, -1);
13160
+ rb_define_method(SwigClassMemcachedSt.klass, "recv_size=", _wrap_MemcachedSt_recv_size_set, -1);
13161
+ rb_define_method(SwigClassMemcachedSt.klass, "recv_size", _wrap_MemcachedSt_recv_size_get, -1);
13162
+ rb_define_method(SwigClassMemcachedSt.klass, "user_data=", _wrap_MemcachedSt_user_data_set, -1);
13163
+ rb_define_method(SwigClassMemcachedSt.klass, "user_data", _wrap_MemcachedSt_user_data_get, -1);
13164
+ rb_define_method(SwigClassMemcachedSt.klass, "next_distribution_rebuild=", _wrap_MemcachedSt_next_distribution_rebuild_set, -1);
13165
+ rb_define_method(SwigClassMemcachedSt.klass, "next_distribution_rebuild", _wrap_MemcachedSt_next_distribution_rebuild_get, -1);
13166
+ rb_define_method(SwigClassMemcachedSt.klass, "prefix_key_length=", _wrap_MemcachedSt_prefix_key_length_set, -1);
13167
+ rb_define_method(SwigClassMemcachedSt.klass, "prefix_key_length", _wrap_MemcachedSt_prefix_key_length_get, -1);
13168
+ rb_define_method(SwigClassMemcachedSt.klass, "hash_continuum=", _wrap_MemcachedSt_hash_continuum_set, -1);
13169
+ rb_define_method(SwigClassMemcachedSt.klass, "hash_continuum", _wrap_MemcachedSt_hash_continuum_get, -1);
13170
+ rb_define_method(SwigClassMemcachedSt.klass, "result=", _wrap_MemcachedSt_result_set, -1);
13171
+ rb_define_method(SwigClassMemcachedSt.klass, "result", _wrap_MemcachedSt_result_get, -1);
13172
+ rb_define_method(SwigClassMemcachedSt.klass, "continuum=", _wrap_MemcachedSt_continuum_set, -1);
13173
+ rb_define_method(SwigClassMemcachedSt.klass, "continuum", _wrap_MemcachedSt_continuum_get, -1);
13174
+ rb_define_method(SwigClassMemcachedSt.klass, "on_clone=", _wrap_MemcachedSt_on_clone_set, -1);
13175
+ rb_define_method(SwigClassMemcachedSt.klass, "on_clone", _wrap_MemcachedSt_on_clone_get, -1);
13176
+ rb_define_method(SwigClassMemcachedSt.klass, "on_cleanup=", _wrap_MemcachedSt_on_cleanup_set, -1);
13177
+ rb_define_method(SwigClassMemcachedSt.klass, "on_cleanup", _wrap_MemcachedSt_on_cleanup_get, -1);
13178
+ rb_define_method(SwigClassMemcachedSt.klass, "call_free=", _wrap_MemcachedSt_call_free_set, -1);
13179
+ rb_define_method(SwigClassMemcachedSt.klass, "call_free", _wrap_MemcachedSt_call_free_get, -1);
13180
+ rb_define_method(SwigClassMemcachedSt.klass, "call_malloc=", _wrap_MemcachedSt_call_malloc_set, -1);
13181
+ rb_define_method(SwigClassMemcachedSt.klass, "call_malloc", _wrap_MemcachedSt_call_malloc_get, -1);
13182
+ rb_define_method(SwigClassMemcachedSt.klass, "call_realloc=", _wrap_MemcachedSt_call_realloc_set, -1);
13183
+ rb_define_method(SwigClassMemcachedSt.klass, "call_realloc", _wrap_MemcachedSt_call_realloc_get, -1);
13184
+ rb_define_method(SwigClassMemcachedSt.klass, "call_calloc=", _wrap_MemcachedSt_call_calloc_set, -1);
13185
+ rb_define_method(SwigClassMemcachedSt.klass, "call_calloc", _wrap_MemcachedSt_call_calloc_get, -1);
13186
+ rb_define_method(SwigClassMemcachedSt.klass, "get_key_failure=", _wrap_MemcachedSt_get_key_failure_set, -1);
13187
+ rb_define_method(SwigClassMemcachedSt.klass, "get_key_failure", _wrap_MemcachedSt_get_key_failure_get, -1);
13188
+ rb_define_method(SwigClassMemcachedSt.klass, "delete_trigger=", _wrap_MemcachedSt_delete_trigger_set, -1);
13189
+ rb_define_method(SwigClassMemcachedSt.klass, "delete_trigger", _wrap_MemcachedSt_delete_trigger_get, -1);
13190
+ rb_define_method(SwigClassMemcachedSt.klass, "prefix_key=", _wrap_MemcachedSt_prefix_key_set, -1);
13191
+ rb_define_method(SwigClassMemcachedSt.klass, "prefix_key", _wrap_MemcachedSt_prefix_key_get, -1);
13192
+ rb_define_method(SwigClassMemcachedSt.klass, "number_of_replicas=", _wrap_MemcachedSt_number_of_replicas_set, -1);
13193
+ rb_define_method(SwigClassMemcachedSt.klass, "number_of_replicas", _wrap_MemcachedSt_number_of_replicas_get, -1);
13194
+ rb_define_method(SwigClassMemcachedSt.klass, "number_of_live_hosts=", _wrap_MemcachedSt_number_of_live_hosts_set, -1);
13195
+ rb_define_method(SwigClassMemcachedSt.klass, "number_of_live_hosts", _wrap_MemcachedSt_number_of_live_hosts_get, -1);
13196
+ rb_define_method(SwigClassMemcachedSt.klass, "live_host_indices=", _wrap_MemcachedSt_live_host_indices_set, -1);
13197
+ rb_define_method(SwigClassMemcachedSt.klass, "live_host_indices", _wrap_MemcachedSt_live_host_indices_get, -1);
13198
+ rb_define_method(SwigClassMemcachedSt.klass, "live_host_indices_size=", _wrap_MemcachedSt_live_host_indices_size_set, -1);
13199
+ rb_define_method(SwigClassMemcachedSt.klass, "live_host_indices_size", _wrap_MemcachedSt_live_host_indices_size_get, -1);
13200
+ rb_define_method(SwigClassMemcachedSt.klass, "sasl_callbacks=", _wrap_MemcachedSt_sasl_callbacks_set, -1);
13201
+ rb_define_method(SwigClassMemcachedSt.klass, "sasl_callbacks", _wrap_MemcachedSt_sasl_callbacks_get, -1);
13202
+ rb_define_method(SwigClassMemcachedSt.klass, "last_server_key=", _wrap_MemcachedSt_last_server_key_set, -1);
13203
+ rb_define_method(SwigClassMemcachedSt.klass, "last_server_key", _wrap_MemcachedSt_last_server_key_get, -1);
13204
+ SwigClassMemcachedSt.mark = 0;
13205
+ SwigClassMemcachedSt.destroy = (void (*)(void *)) memcached_free;
13206
+ SwigClassMemcachedSt.trackObjects = 0;
13059
13207
  rb_define_module_function(mRlibmemcached, "memcached_version", _wrap_memcached_version, -1);
13060
13208
  rb_define_module_function(mRlibmemcached, "memcached_lib_version", _wrap_memcached_lib_version, -1);
13061
13209
  rb_define_module_function(mRlibmemcached, "memcached_create", _wrap_memcached_create, -1);
@@ -13206,6 +13354,7 @@ SWIGEXPORT void Init_rlibmemcached(void) {
13206
13354
  rb_define_const(mRlibmemcached, "MEMCACHED_HASH_HSIEH", SWIG_From_int((int)(MEMCACHED_HASH_HSIEH)));
13207
13355
  rb_define_const(mRlibmemcached, "MEMCACHED_HASH_MURMUR", SWIG_From_int((int)(MEMCACHED_HASH_MURMUR)));
13208
13356
  rb_define_const(mRlibmemcached, "MEMCACHED_HASH_JENKINS", SWIG_From_int((int)(MEMCACHED_HASH_JENKINS)));
13357
+ rb_define_const(mRlibmemcached, "MEMCACHED_HASH_NONE", SWIG_From_int((int)(MEMCACHED_HASH_NONE)));
13209
13358
  rb_define_const(mRlibmemcached, "MEMCACHED_CONNECTION_UNKNOWN", SWIG_From_int((int)(MEMCACHED_CONNECTION_UNKNOWN)));
13210
13359
  rb_define_const(mRlibmemcached, "MEMCACHED_CONNECTION_TCP", SWIG_From_int((int)(MEMCACHED_CONNECTION_TCP)));
13211
13360
  rb_define_const(mRlibmemcached, "MEMCACHED_CONNECTION_UDP", SWIG_From_int((int)(MEMCACHED_CONNECTION_UDP)));
@@ -13216,6 +13365,7 @@ SWIGEXPORT void Init_rlibmemcached(void) {
13216
13365
  rb_define_module_function(mRlibmemcached, "memcached_mget_by_key", _wrap_memcached_mget_by_key, -1);
13217
13366
  rb_define_module_function(mRlibmemcached, "memcached_fetch", _wrap_memcached_fetch, -1);
13218
13367
  rb_define_module_function(mRlibmemcached, "memcached_fetch_result", _wrap_memcached_fetch_result, -1);
13368
+ rb_define_module_function(mRlibmemcached, "memcached_get_from_last", _wrap_memcached_get_from_last, -1);
13219
13369
  rb_define_module_function(mRlibmemcached, "memcached_set", _wrap_memcached_set, -1);
13220
13370
  rb_define_module_function(mRlibmemcached, "memcached_add", _wrap_memcached_add, -1);
13221
13371
  rb_define_module_function(mRlibmemcached, "memcached_replace", _wrap_memcached_replace, -1);
@@ -13229,29 +13379,29 @@ SWIGEXPORT void Init_rlibmemcached(void) {
13229
13379
  rb_define_module_function(mRlibmemcached, "memcached_append_by_key", _wrap_memcached_append_by_key, -1);
13230
13380
  rb_define_module_function(mRlibmemcached, "memcached_cas_by_key", _wrap_memcached_cas_by_key, -1);
13231
13381
 
13232
- cMemcachedResultSt.klass = rb_define_class_under(mRlibmemcached, "MemcachedResultSt", rb_cObject);
13233
- SWIG_TypeClientData(SWIGTYPE_p_memcached_result_st, (void *) &cMemcachedResultSt);
13234
- rb_define_alloc_func(cMemcachedResultSt.klass, _wrap_MemcachedResultSt_allocate);
13235
- rb_define_method(cMemcachedResultSt.klass, "initialize", _wrap_new_MemcachedResultSt, -1);
13236
- rb_define_method(cMemcachedResultSt.klass, "flags=", _wrap_MemcachedResultSt_flags_set, -1);
13237
- rb_define_method(cMemcachedResultSt.klass, "flags", _wrap_MemcachedResultSt_flags_get, -1);
13238
- rb_define_method(cMemcachedResultSt.klass, "is_allocated=", _wrap_MemcachedResultSt_is_allocated_set, -1);
13239
- rb_define_method(cMemcachedResultSt.klass, "is_allocated", _wrap_MemcachedResultSt_is_allocated_get, -1);
13240
- rb_define_method(cMemcachedResultSt.klass, "expiration=", _wrap_MemcachedResultSt_expiration_set, -1);
13241
- rb_define_method(cMemcachedResultSt.klass, "expiration", _wrap_MemcachedResultSt_expiration_get, -1);
13242
- rb_define_method(cMemcachedResultSt.klass, "root=", _wrap_MemcachedResultSt_root_set, -1);
13243
- rb_define_method(cMemcachedResultSt.klass, "root", _wrap_MemcachedResultSt_root_get, -1);
13244
- rb_define_method(cMemcachedResultSt.klass, "key_length=", _wrap_MemcachedResultSt_key_length_set, -1);
13245
- rb_define_method(cMemcachedResultSt.klass, "key_length", _wrap_MemcachedResultSt_key_length_get, -1);
13246
- rb_define_method(cMemcachedResultSt.klass, "cas=", _wrap_MemcachedResultSt_cas_set, -1);
13247
- rb_define_method(cMemcachedResultSt.klass, "cas", _wrap_MemcachedResultSt_cas_get, -1);
13248
- rb_define_method(cMemcachedResultSt.klass, "value=", _wrap_MemcachedResultSt_value_set, -1);
13249
- rb_define_method(cMemcachedResultSt.klass, "value", _wrap_MemcachedResultSt_value_get, -1);
13250
- rb_define_method(cMemcachedResultSt.klass, "key=", _wrap_MemcachedResultSt_key_set, -1);
13251
- rb_define_method(cMemcachedResultSt.klass, "key", _wrap_MemcachedResultSt_key_get, -1);
13252
- cMemcachedResultSt.mark = 0;
13253
- cMemcachedResultSt.destroy = (void (*)(void *)) free_memcached_result_st;
13254
- cMemcachedResultSt.trackObjects = 0;
13382
+ SwigClassMemcachedResultSt.klass = rb_define_class_under(mRlibmemcached, "MemcachedResultSt", rb_cObject);
13383
+ SWIG_TypeClientData(SWIGTYPE_p_memcached_result_st, (void *) &SwigClassMemcachedResultSt);
13384
+ rb_define_alloc_func(SwigClassMemcachedResultSt.klass, _wrap_MemcachedResultSt_allocate);
13385
+ rb_define_method(SwigClassMemcachedResultSt.klass, "initialize", _wrap_new_MemcachedResultSt, -1);
13386
+ rb_define_method(SwigClassMemcachedResultSt.klass, "flags=", _wrap_MemcachedResultSt_flags_set, -1);
13387
+ rb_define_method(SwigClassMemcachedResultSt.klass, "flags", _wrap_MemcachedResultSt_flags_get, -1);
13388
+ rb_define_method(SwigClassMemcachedResultSt.klass, "is_allocated=", _wrap_MemcachedResultSt_is_allocated_set, -1);
13389
+ rb_define_method(SwigClassMemcachedResultSt.klass, "is_allocated", _wrap_MemcachedResultSt_is_allocated_get, -1);
13390
+ rb_define_method(SwigClassMemcachedResultSt.klass, "expiration=", _wrap_MemcachedResultSt_expiration_set, -1);
13391
+ rb_define_method(SwigClassMemcachedResultSt.klass, "expiration", _wrap_MemcachedResultSt_expiration_get, -1);
13392
+ rb_define_method(SwigClassMemcachedResultSt.klass, "root=", _wrap_MemcachedResultSt_root_set, -1);
13393
+ rb_define_method(SwigClassMemcachedResultSt.klass, "root", _wrap_MemcachedResultSt_root_get, -1);
13394
+ rb_define_method(SwigClassMemcachedResultSt.klass, "key_length=", _wrap_MemcachedResultSt_key_length_set, -1);
13395
+ rb_define_method(SwigClassMemcachedResultSt.klass, "key_length", _wrap_MemcachedResultSt_key_length_get, -1);
13396
+ rb_define_method(SwigClassMemcachedResultSt.klass, "cas=", _wrap_MemcachedResultSt_cas_set, -1);
13397
+ rb_define_method(SwigClassMemcachedResultSt.klass, "cas", _wrap_MemcachedResultSt_cas_get, -1);
13398
+ rb_define_method(SwigClassMemcachedResultSt.klass, "value=", _wrap_MemcachedResultSt_value_set, -1);
13399
+ rb_define_method(SwigClassMemcachedResultSt.klass, "value", _wrap_MemcachedResultSt_value_get, -1);
13400
+ rb_define_method(SwigClassMemcachedResultSt.klass, "key=", _wrap_MemcachedResultSt_key_set, -1);
13401
+ rb_define_method(SwigClassMemcachedResultSt.klass, "key", _wrap_MemcachedResultSt_key_get, -1);
13402
+ SwigClassMemcachedResultSt.mark = 0;
13403
+ SwigClassMemcachedResultSt.destroy = (void (*)(void *)) free_memcached_result_st;
13404
+ SwigClassMemcachedResultSt.trackObjects = 0;
13255
13405
  rb_define_module_function(mRlibmemcached, "memcached_result_free", _wrap_memcached_result_free, -1);
13256
13406
  rb_define_module_function(mRlibmemcached, "memcached_result_reset", _wrap_memcached_result_reset, -1);
13257
13407
  rb_define_module_function(mRlibmemcached, "memcached_result_create", _wrap_memcached_result_create, -1);
@@ -13259,65 +13409,65 @@ SWIGEXPORT void Init_rlibmemcached(void) {
13259
13409
  rb_define_module_function(mRlibmemcached, "memcached_result_length", _wrap_memcached_result_length, -1);
13260
13410
  rb_define_module_function(mRlibmemcached, "memcached_result_set_value", _wrap_memcached_result_set_value, -1);
13261
13411
 
13262
- cMemcachedServerSt.klass = rb_define_class_under(mRlibmemcached, "MemcachedServerSt", rb_cObject);
13263
- SWIG_TypeClientData(SWIGTYPE_p_memcached_server_st, (void *) &cMemcachedServerSt);
13264
- rb_define_alloc_func(cMemcachedServerSt.klass, _wrap_MemcachedServerSt_allocate);
13265
- rb_define_method(cMemcachedServerSt.klass, "initialize", _wrap_new_MemcachedServerSt, -1);
13266
- rb_define_method(cMemcachedServerSt.klass, "is_allocated=", _wrap_MemcachedServerSt_is_allocated_set, -1);
13267
- rb_define_method(cMemcachedServerSt.klass, "is_allocated", _wrap_MemcachedServerSt_is_allocated_get, -1);
13268
- rb_define_method(cMemcachedServerSt.klass, "sockaddr_inited=", _wrap_MemcachedServerSt_sockaddr_inited_set, -1);
13269
- rb_define_method(cMemcachedServerSt.klass, "sockaddr_inited", _wrap_MemcachedServerSt_sockaddr_inited_get, -1);
13270
- rb_define_method(cMemcachedServerSt.klass, "count=", _wrap_MemcachedServerSt_count_set, -1);
13271
- rb_define_method(cMemcachedServerSt.klass, "count", _wrap_MemcachedServerSt_count_get, -1);
13272
- rb_define_method(cMemcachedServerSt.klass, "cursor_active=", _wrap_MemcachedServerSt_cursor_active_set, -1);
13273
- rb_define_method(cMemcachedServerSt.klass, "cursor_active", _wrap_MemcachedServerSt_cursor_active_get, -1);
13274
- rb_define_method(cMemcachedServerSt.klass, "port=", _wrap_MemcachedServerSt_port_set, -1);
13275
- rb_define_method(cMemcachedServerSt.klass, "port", _wrap_MemcachedServerSt_port_get, -1);
13276
- rb_define_method(cMemcachedServerSt.klass, "cached_errno=", _wrap_MemcachedServerSt_cached_errno_set, -1);
13277
- rb_define_method(cMemcachedServerSt.klass, "cached_errno", _wrap_MemcachedServerSt_cached_errno_get, -1);
13278
- rb_define_method(cMemcachedServerSt.klass, "fd=", _wrap_MemcachedServerSt_fd_set, -1);
13279
- rb_define_method(cMemcachedServerSt.klass, "fd", _wrap_MemcachedServerSt_fd_get, -1);
13280
- rb_define_method(cMemcachedServerSt.klass, "io_bytes_sent=", _wrap_MemcachedServerSt_io_bytes_sent_set, -1);
13281
- rb_define_method(cMemcachedServerSt.klass, "io_bytes_sent", _wrap_MemcachedServerSt_io_bytes_sent_get, -1);
13282
- rb_define_method(cMemcachedServerSt.klass, "server_failure_counter=", _wrap_MemcachedServerSt_server_failure_counter_set, -1);
13283
- rb_define_method(cMemcachedServerSt.klass, "server_failure_counter", _wrap_MemcachedServerSt_server_failure_counter_get, -1);
13284
- rb_define_method(cMemcachedServerSt.klass, "weight=", _wrap_MemcachedServerSt_weight_set, -1);
13285
- rb_define_method(cMemcachedServerSt.klass, "weight", _wrap_MemcachedServerSt_weight_get, -1);
13286
- rb_define_method(cMemcachedServerSt.klass, "major_version=", _wrap_MemcachedServerSt_major_version_set, -1);
13287
- rb_define_method(cMemcachedServerSt.klass, "major_version", _wrap_MemcachedServerSt_major_version_get, -1);
13288
- rb_define_method(cMemcachedServerSt.klass, "micro_version=", _wrap_MemcachedServerSt_micro_version_set, -1);
13289
- rb_define_method(cMemcachedServerSt.klass, "micro_version", _wrap_MemcachedServerSt_micro_version_get, -1);
13290
- rb_define_method(cMemcachedServerSt.klass, "minor_version=", _wrap_MemcachedServerSt_minor_version_set, -1);
13291
- rb_define_method(cMemcachedServerSt.klass, "minor_version", _wrap_MemcachedServerSt_minor_version_get, -1);
13292
- rb_define_method(cMemcachedServerSt.klass, "type=", _wrap_MemcachedServerSt_type_set, -1);
13293
- rb_define_method(cMemcachedServerSt.klass, "type", _wrap_MemcachedServerSt_type_get, -1);
13294
- rb_define_method(cMemcachedServerSt.klass, "read_ptr=", _wrap_MemcachedServerSt_read_ptr_set, -1);
13295
- rb_define_method(cMemcachedServerSt.klass, "read_ptr", _wrap_MemcachedServerSt_read_ptr_get, -1);
13296
- rb_define_method(cMemcachedServerSt.klass, "cached_server_error=", _wrap_MemcachedServerSt_cached_server_error_set, -1);
13297
- rb_define_method(cMemcachedServerSt.klass, "cached_server_error", _wrap_MemcachedServerSt_cached_server_error_get, -1);
13298
- rb_define_method(cMemcachedServerSt.klass, "read_buffer_length=", _wrap_MemcachedServerSt_read_buffer_length_set, -1);
13299
- rb_define_method(cMemcachedServerSt.klass, "read_buffer_length", _wrap_MemcachedServerSt_read_buffer_length_get, -1);
13300
- rb_define_method(cMemcachedServerSt.klass, "read_data_length=", _wrap_MemcachedServerSt_read_data_length_set, -1);
13301
- rb_define_method(cMemcachedServerSt.klass, "read_data_length", _wrap_MemcachedServerSt_read_data_length_get, -1);
13302
- rb_define_method(cMemcachedServerSt.klass, "write_buffer_offset=", _wrap_MemcachedServerSt_write_buffer_offset_set, -1);
13303
- rb_define_method(cMemcachedServerSt.klass, "write_buffer_offset", _wrap_MemcachedServerSt_write_buffer_offset_get, -1);
13304
- rb_define_method(cMemcachedServerSt.klass, "address_info=", _wrap_MemcachedServerSt_address_info_set, -1);
13305
- rb_define_method(cMemcachedServerSt.klass, "address_info", _wrap_MemcachedServerSt_address_info_get, -1);
13306
- rb_define_method(cMemcachedServerSt.klass, "next_retry=", _wrap_MemcachedServerSt_next_retry_set, -1);
13307
- rb_define_method(cMemcachedServerSt.klass, "next_retry", _wrap_MemcachedServerSt_next_retry_get, -1);
13308
- rb_define_method(cMemcachedServerSt.klass, "root=", _wrap_MemcachedServerSt_root_set, -1);
13309
- rb_define_method(cMemcachedServerSt.klass, "root", _wrap_MemcachedServerSt_root_get, -1);
13310
- rb_define_method(cMemcachedServerSt.klass, "limit_maxbytes=", _wrap_MemcachedServerSt_limit_maxbytes_set, -1);
13311
- rb_define_method(cMemcachedServerSt.klass, "limit_maxbytes", _wrap_MemcachedServerSt_limit_maxbytes_get, -1);
13312
- rb_define_method(cMemcachedServerSt.klass, "read_buffer=", _wrap_MemcachedServerSt_read_buffer_set, -1);
13313
- rb_define_method(cMemcachedServerSt.klass, "read_buffer", _wrap_MemcachedServerSt_read_buffer_get, -1);
13314
- rb_define_method(cMemcachedServerSt.klass, "write_buffer=", _wrap_MemcachedServerSt_write_buffer_set, -1);
13315
- rb_define_method(cMemcachedServerSt.klass, "write_buffer", _wrap_MemcachedServerSt_write_buffer_get, -1);
13316
- rb_define_method(cMemcachedServerSt.klass, "hostname=", _wrap_MemcachedServerSt_hostname_set, -1);
13317
- rb_define_method(cMemcachedServerSt.klass, "hostname", _wrap_MemcachedServerSt_hostname_get, -1);
13318
- cMemcachedServerSt.mark = 0;
13319
- cMemcachedServerSt.destroy = (void (*)(void *)) memcached_server_free;
13320
- cMemcachedServerSt.trackObjects = 0;
13412
+ SwigClassMemcachedServerSt.klass = rb_define_class_under(mRlibmemcached, "MemcachedServerSt", rb_cObject);
13413
+ SWIG_TypeClientData(SWIGTYPE_p_memcached_server_st, (void *) &SwigClassMemcachedServerSt);
13414
+ rb_define_alloc_func(SwigClassMemcachedServerSt.klass, _wrap_MemcachedServerSt_allocate);
13415
+ rb_define_method(SwigClassMemcachedServerSt.klass, "initialize", _wrap_new_MemcachedServerSt, -1);
13416
+ rb_define_method(SwigClassMemcachedServerSt.klass, "is_allocated=", _wrap_MemcachedServerSt_is_allocated_set, -1);
13417
+ rb_define_method(SwigClassMemcachedServerSt.klass, "is_allocated", _wrap_MemcachedServerSt_is_allocated_get, -1);
13418
+ rb_define_method(SwigClassMemcachedServerSt.klass, "sockaddr_inited=", _wrap_MemcachedServerSt_sockaddr_inited_set, -1);
13419
+ rb_define_method(SwigClassMemcachedServerSt.klass, "sockaddr_inited", _wrap_MemcachedServerSt_sockaddr_inited_get, -1);
13420
+ rb_define_method(SwigClassMemcachedServerSt.klass, "count=", _wrap_MemcachedServerSt_count_set, -1);
13421
+ rb_define_method(SwigClassMemcachedServerSt.klass, "count", _wrap_MemcachedServerSt_count_get, -1);
13422
+ rb_define_method(SwigClassMemcachedServerSt.klass, "cursor_active=", _wrap_MemcachedServerSt_cursor_active_set, -1);
13423
+ rb_define_method(SwigClassMemcachedServerSt.klass, "cursor_active", _wrap_MemcachedServerSt_cursor_active_get, -1);
13424
+ rb_define_method(SwigClassMemcachedServerSt.klass, "port=", _wrap_MemcachedServerSt_port_set, -1);
13425
+ rb_define_method(SwigClassMemcachedServerSt.klass, "port", _wrap_MemcachedServerSt_port_get, -1);
13426
+ rb_define_method(SwigClassMemcachedServerSt.klass, "cached_errno=", _wrap_MemcachedServerSt_cached_errno_set, -1);
13427
+ rb_define_method(SwigClassMemcachedServerSt.klass, "cached_errno", _wrap_MemcachedServerSt_cached_errno_get, -1);
13428
+ rb_define_method(SwigClassMemcachedServerSt.klass, "fd=", _wrap_MemcachedServerSt_fd_set, -1);
13429
+ rb_define_method(SwigClassMemcachedServerSt.klass, "fd", _wrap_MemcachedServerSt_fd_get, -1);
13430
+ rb_define_method(SwigClassMemcachedServerSt.klass, "io_bytes_sent=", _wrap_MemcachedServerSt_io_bytes_sent_set, -1);
13431
+ rb_define_method(SwigClassMemcachedServerSt.klass, "io_bytes_sent", _wrap_MemcachedServerSt_io_bytes_sent_get, -1);
13432
+ rb_define_method(SwigClassMemcachedServerSt.klass, "server_failure_counter=", _wrap_MemcachedServerSt_server_failure_counter_set, -1);
13433
+ rb_define_method(SwigClassMemcachedServerSt.klass, "server_failure_counter", _wrap_MemcachedServerSt_server_failure_counter_get, -1);
13434
+ rb_define_method(SwigClassMemcachedServerSt.klass, "weight=", _wrap_MemcachedServerSt_weight_set, -1);
13435
+ rb_define_method(SwigClassMemcachedServerSt.klass, "weight", _wrap_MemcachedServerSt_weight_get, -1);
13436
+ rb_define_method(SwigClassMemcachedServerSt.klass, "major_version=", _wrap_MemcachedServerSt_major_version_set, -1);
13437
+ rb_define_method(SwigClassMemcachedServerSt.klass, "major_version", _wrap_MemcachedServerSt_major_version_get, -1);
13438
+ rb_define_method(SwigClassMemcachedServerSt.klass, "micro_version=", _wrap_MemcachedServerSt_micro_version_set, -1);
13439
+ rb_define_method(SwigClassMemcachedServerSt.klass, "micro_version", _wrap_MemcachedServerSt_micro_version_get, -1);
13440
+ rb_define_method(SwigClassMemcachedServerSt.klass, "minor_version=", _wrap_MemcachedServerSt_minor_version_set, -1);
13441
+ rb_define_method(SwigClassMemcachedServerSt.klass, "minor_version", _wrap_MemcachedServerSt_minor_version_get, -1);
13442
+ rb_define_method(SwigClassMemcachedServerSt.klass, "type=", _wrap_MemcachedServerSt_type_set, -1);
13443
+ rb_define_method(SwigClassMemcachedServerSt.klass, "type", _wrap_MemcachedServerSt_type_get, -1);
13444
+ rb_define_method(SwigClassMemcachedServerSt.klass, "read_ptr=", _wrap_MemcachedServerSt_read_ptr_set, -1);
13445
+ rb_define_method(SwigClassMemcachedServerSt.klass, "read_ptr", _wrap_MemcachedServerSt_read_ptr_get, -1);
13446
+ rb_define_method(SwigClassMemcachedServerSt.klass, "cached_server_error=", _wrap_MemcachedServerSt_cached_server_error_set, -1);
13447
+ rb_define_method(SwigClassMemcachedServerSt.klass, "cached_server_error", _wrap_MemcachedServerSt_cached_server_error_get, -1);
13448
+ rb_define_method(SwigClassMemcachedServerSt.klass, "read_buffer_length=", _wrap_MemcachedServerSt_read_buffer_length_set, -1);
13449
+ rb_define_method(SwigClassMemcachedServerSt.klass, "read_buffer_length", _wrap_MemcachedServerSt_read_buffer_length_get, -1);
13450
+ rb_define_method(SwigClassMemcachedServerSt.klass, "read_data_length=", _wrap_MemcachedServerSt_read_data_length_set, -1);
13451
+ rb_define_method(SwigClassMemcachedServerSt.klass, "read_data_length", _wrap_MemcachedServerSt_read_data_length_get, -1);
13452
+ rb_define_method(SwigClassMemcachedServerSt.klass, "write_buffer_offset=", _wrap_MemcachedServerSt_write_buffer_offset_set, -1);
13453
+ rb_define_method(SwigClassMemcachedServerSt.klass, "write_buffer_offset", _wrap_MemcachedServerSt_write_buffer_offset_get, -1);
13454
+ rb_define_method(SwigClassMemcachedServerSt.klass, "address_info=", _wrap_MemcachedServerSt_address_info_set, -1);
13455
+ rb_define_method(SwigClassMemcachedServerSt.klass, "address_info", _wrap_MemcachedServerSt_address_info_get, -1);
13456
+ rb_define_method(SwigClassMemcachedServerSt.klass, "next_retry=", _wrap_MemcachedServerSt_next_retry_set, -1);
13457
+ rb_define_method(SwigClassMemcachedServerSt.klass, "next_retry", _wrap_MemcachedServerSt_next_retry_get, -1);
13458
+ rb_define_method(SwigClassMemcachedServerSt.klass, "root=", _wrap_MemcachedServerSt_root_set, -1);
13459
+ rb_define_method(SwigClassMemcachedServerSt.klass, "root", _wrap_MemcachedServerSt_root_get, -1);
13460
+ rb_define_method(SwigClassMemcachedServerSt.klass, "limit_maxbytes=", _wrap_MemcachedServerSt_limit_maxbytes_set, -1);
13461
+ rb_define_method(SwigClassMemcachedServerSt.klass, "limit_maxbytes", _wrap_MemcachedServerSt_limit_maxbytes_get, -1);
13462
+ rb_define_method(SwigClassMemcachedServerSt.klass, "read_buffer=", _wrap_MemcachedServerSt_read_buffer_set, -1);
13463
+ rb_define_method(SwigClassMemcachedServerSt.klass, "read_buffer", _wrap_MemcachedServerSt_read_buffer_get, -1);
13464
+ rb_define_method(SwigClassMemcachedServerSt.klass, "write_buffer=", _wrap_MemcachedServerSt_write_buffer_set, -1);
13465
+ rb_define_method(SwigClassMemcachedServerSt.klass, "write_buffer", _wrap_MemcachedServerSt_write_buffer_get, -1);
13466
+ rb_define_method(SwigClassMemcachedServerSt.klass, "hostname=", _wrap_MemcachedServerSt_hostname_set, -1);
13467
+ rb_define_method(SwigClassMemcachedServerSt.klass, "hostname", _wrap_MemcachedServerSt_hostname_get, -1);
13468
+ SwigClassMemcachedServerSt.mark = 0;
13469
+ SwigClassMemcachedServerSt.destroy = (void (*)(void *)) memcached_server_free;
13470
+ SwigClassMemcachedServerSt.trackObjects = 0;
13321
13471
  rb_define_module_function(mRlibmemcached, "memcached_server_cursor", _wrap_memcached_server_cursor, -1);
13322
13472
  rb_define_module_function(mRlibmemcached, "memcached_server_by_key", _wrap_memcached_server_by_key, -1);
13323
13473
  rb_define_module_function(mRlibmemcached, "memcached_server_error", _wrap_memcached_server_error, -1);