Class: Rlibmemcached::MemcachedServerSt

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

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ Object 



12106
12107
12108
12109
12110
12111
12112
12113
12114
12115
12116
12117
12118
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 12106

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

Instance Method Details

#address_info(*args) ⇒ Object 



11719
11720
11721
11722
11723
11724
11725
11726
11727
11728
11729
11730
11731
11732
11733
11734
11735
11736
11737
11738
11739
11740
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 11719

SWIGINTERN VALUE
_wrap_MemcachedServerSt_address_info_get(int argc, VALUE *argv, VALUE self) {
  struct memcached_server_st *arg1 = (struct memcached_server_st *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  struct addrinfo *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_server_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_server_st *","address_info", 1, self )); 
  }
  arg1 = (struct memcached_server_st *)(argp1);
  result = (struct addrinfo *) ((arg1)->address_info);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_addrinfo, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

#address_info=(*args) ⇒ Object 



11690
11691
11692
11693
11694
11695
11696
11697
11698
11699
11700
11701
11702
11703
11704
11705
11706
11707
11708
11709
11710
11711
11712
11713
11714
11715
11716
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 11690

SWIGINTERN VALUE
_wrap_MemcachedServerSt_address_info_set(int argc, VALUE *argv, VALUE self) {
  struct memcached_server_st *arg1 = (struct memcached_server_st *) 0 ;
  struct addrinfo *arg2 = (struct addrinfo *) 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_server_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_server_st *","address_info", 1, self )); 
  }
  arg1 = (struct memcached_server_st *)(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_addrinfo, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "struct addrinfo *","address_info", 2, argv[0] )); 
  }
  arg2 = (struct addrinfo *)(argp2);
  if (arg1) (arg1)->address_info = arg2;
  return Qnil;
fail:
  return Qnil;
}

#cached_errno(*args) ⇒ Object 



10951
10952
10953
10954
10955
10956
10957
10958
10959
10960
10961
10962
10963
10964
10965
10966
10967
10968
10969
10970
10971
10972
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 10951

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

#cached_errno=(*args) ⇒ Object 



10922
10923
10924
10925
10926
10927
10928
10929
10930
10931
10932
10933
10934
10935
10936
10937
10938
10939
10940
10941
10942
10943
10944
10945
10946
10947
10948
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 10922

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

#cached_server_error(*args) ⇒ Object 



11507
11508
11509
11510
11511
11512
11513
11514
11515
11516
11517
11518
11519
11520
11521
11522
11523
11524
11525
11526
11527
11528
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 11507

SWIGINTERN VALUE
_wrap_MemcachedServerSt_cached_server_error_get(int argc, VALUE *argv, VALUE self) {
  struct memcached_server_st *arg1 = (struct memcached_server_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_server_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_server_st *","cached_server_error", 1, self )); 
  }
  arg1 = (struct memcached_server_st *)(argp1);
  result = (char *) ((arg1)->cached_server_error);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

#cached_server_error=(*args) ⇒ Object 



11469
11470
11471
11472
11473
11474
11475
11476
11477
11478
11479
11480
11481
11482
11483
11484
11485
11486
11487
11488
11489
11490
11491
11492
11493
11494
11495
11496
11497
11498
11499
11500
11501
11502
11503
11504
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 11469

SWIGINTERN VALUE
_wrap_MemcachedServerSt_cached_server_error_set(int argc, VALUE *argv, VALUE self) {
  struct memcached_server_st *arg1 = (struct memcached_server_st *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 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_server_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_server_st *","cached_server_error", 1, self )); 
  }
  arg1 = (struct memcached_server_st *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","cached_server_error", 2, argv[0] ));
  }
  arg2 = (char *)(buf2);
  if (arg1->cached_server_error) free((char*)arg1->cached_server_error);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->cached_server_error = (char *)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->cached_server_error = 0;
  }
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

#count(*args) ⇒ Object 



10792
10793
10794
10795
10796
10797
10798
10799
10800
10801
10802
10803
10804
10805
10806
10807
10808
10809
10810
10811
10812
10813
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 10792

SWIGINTERN VALUE
_wrap_MemcachedServerSt_count_get(int argc, VALUE *argv, VALUE self) {
  struct memcached_server_st *arg1 = (struct memcached_server_st *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uint16_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_server_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_server_st *","count", 1, self )); 
  }
  arg1 = (struct memcached_server_st *)(argp1);
  result =  ((arg1)->count);
  vresult = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return vresult;
fail:
  return Qnil;
}

#count=(*args) ⇒ Object 



10763
10764
10765
10766
10767
10768
10769
10770
10771
10772
10773
10774
10775
10776
10777
10778
10779
10780
10781
10782
10783
10784
10785
10786
10787
10788
10789
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 10763

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

#cursor_active(*args) ⇒ Object 



10845
10846
10847
10848
10849
10850
10851
10852
10853
10854
10855
10856
10857
10858
10859
10860
10861
10862
10863
10864
10865
10866
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 10845

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

#cursor_active=(*args) ⇒ Object 



10816
10817
10818
10819
10820
10821
10822
10823
10824
10825
10826
10827
10828
10829
10830
10831
10832
10833
10834
10835
10836
10837
10838
10839
10840
10841
10842
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 10816

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

#fd(*args) ⇒ Object 



11004
11005
11006
11007
11008
11009
11010
11011
11012
11013
11014
11015
11016
11017
11018
11019
11020
11021
11022
11023
11024
11025
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 11004

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

#fd=(*args) ⇒ Object 



10975
10976
10977
10978
10979
10980
10981
10982
10983
10984
10985
10986
10987
10988
10989
10990
10991
10992
10993
10994
10995
10996
10997
10998
10999
11000
11001
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 10975

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

#hostname(*args) ⇒ Object 



12061
12062
12063
12064
12065
12066
12067
12068
12069
12070
12071
12072
12073
12074
12075
12076
12077
12078
12079
12080
12081
12082
12083
12084
12085
12086
12087
12088
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 12061

SWIGINTERN VALUE
_wrap_MemcachedServerSt_hostname_get(int argc, VALUE *argv, VALUE self) {
  struct memcached_server_st *arg1 = (struct memcached_server_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_server_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_server_st *","hostname", 1, self )); 
  }
  arg1 = (struct memcached_server_st *)(argp1);
  result = (char *)(char *) ((arg1)->hostname);
  {
    size_t size = SWIG_strnlen(result, 64);
    
    
    
    vresult = SWIG_FromCharPtrAndSize(result, size);
  }
  return vresult;
fail:
  return Qnil;
}

#hostname=(*args) ⇒ Object 



12031
12032
12033
12034
12035
12036
12037
12038
12039
12040
12041
12042
12043
12044
12045
12046
12047
12048
12049
12050
12051
12052
12053
12054
12055
12056
12057
12058
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 12031

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

#io_bytes_sent(*args) ⇒ Object 



11063
11064
11065
11066
11067
11068
11069
11070
11071
11072
11073
11074
11075
11076
11077
11078
11079
11080
11081
11082
11083
11084
11085
11086
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 11063

SWIGINTERN VALUE
_wrap_MemcachedServerSt_io_bytes_sent_get(int argc, VALUE *argv, VALUE self) {
  struct memcached_server_st *arg1 = (struct memcached_server_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_server_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_server_st *","io_bytes_sent", 1, self )); 
  }
  arg1 = (struct memcached_server_st *)(argp1);
  result =  ((arg1)->io_bytes_sent);
  {
    vresult = UINT2NUM(result);
  }
  return vresult;
fail:
  return Qnil;
}

#io_bytes_sent=(*args) ⇒ Object 



11028
11029
11030
11031
11032
11033
11034
11035
11036
11037
11038
11039
11040
11041
11042
11043
11044
11045
11046
11047
11048
11049
11050
11051
11052
11053
11054
11055
11056
11057
11058
11059
11060
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 11028

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

#is_allocated(*args) ⇒ Object 



10686
10687
10688
10689
10690
10691
10692
10693
10694
10695
10696
10697
10698
10699
10700
10701
10702
10703
10704
10705
10706
10707
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 10686

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

#is_allocated=(*args) ⇒ Object 



10657
10658
10659
10660
10661
10662
10663
10664
10665
10666
10667
10668
10669
10670
10671
10672
10673
10674
10675
10676
10677
10678
10679
10680
10681
10682
10683
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 10657

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

#limit_maxbytes(*args) ⇒ Object 



11885
11886
11887
11888
11889
11890
11891
11892
11893
11894
11895
11896
11897
11898
11899
11900
11901
11902
11903
11904
11905
11906
11907
11908
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 11885

SWIGINTERN VALUE
_wrap_MemcachedServerSt_limit_maxbytes_get(int argc, VALUE *argv, VALUE self) {
  struct memcached_server_st *arg1 = (struct memcached_server_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_server_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_server_st *","limit_maxbytes", 1, self )); 
  }
  arg1 = (struct memcached_server_st *)(argp1);
  result =  ((arg1)->limit_maxbytes);
  {
    vresult = ULL2NUM(result);
  }
  return vresult;
fail:
  return Qnil;
}

#limit_maxbytes=(*args) ⇒ Object 



11850
11851
11852
11853
11854
11855
11856
11857
11858
11859
11860
11861
11862
11863
11864
11865
11866
11867
11868
11869
11870
11871
11872
11873
11874
11875
11876
11877
11878
11879
11880
11881
11882
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 11850

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

#major_version(*args) ⇒ Object 



11224
11225
11226
11227
11228
11229
11230
11231
11232
11233
11234
11235
11236
11237
11238
11239
11240
11241
11242
11243
11244
11245
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 11224

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

#major_version=(*args) ⇒ Object 



11195
11196
11197
11198
11199
11200
11201
11202
11203
11204
11205
11206
11207
11208
11209
11210
11211
11212
11213
11214
11215
11216
11217
11218
11219
11220
11221
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 11195

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

#micro_version(*args) ⇒ Object 



11277
11278
11279
11280
11281
11282
11283
11284
11285
11286
11287
11288
11289
11290
11291
11292
11293
11294
11295
11296
11297
11298
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 11277

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

#micro_version=(*args) ⇒ Object 



11248
11249
11250
11251
11252
11253
11254
11255
11256
11257
11258
11259
11260
11261
11262
11263
11264
11265
11266
11267
11268
11269
11270
11271
11272
11273
11274
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 11248

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

#minor_version(*args) ⇒ Object 



11330
11331
11332
11333
11334
11335
11336
11337
11338
11339
11340
11341
11342
11343
11344
11345
11346
11347
11348
11349
11350
11351
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 11330

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

#minor_version=(*args) ⇒ Object 



11301
11302
11303
11304
11305
11306
11307
11308
11309
11310
11311
11312
11313
11314
11315
11316
11317
11318
11319
11320
11321
11322
11323
11324
11325
11326
11327
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 11301

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

#next_retry(*args) ⇒ Object 



11771
11772
11773
11774
11775
11776
11777
11778
11779
11780
11781
11782
11783
11784
11785
11786
11787
11788
11789
11790
11791
11792
11793
11794
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 11771

SWIGINTERN VALUE
_wrap_MemcachedServerSt_next_retry_get(int argc, VALUE *argv, VALUE self) {
  struct memcached_server_st *arg1 = (struct memcached_server_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_server_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_server_st *","next_retry", 1, self )); 
  }
  arg1 = (struct memcached_server_st *)(argp1);
  result =  ((arg1)->next_retry);
  {
    vresult = rb_time_new(result, 0);
  }
  return vresult;
fail:
  return Qnil;
}

#next_retry=(*args) ⇒ Object 



11743
11744
11745
11746
11747
11748
11749
11750
11751
11752
11753
11754
11755
11756
11757
11758
11759
11760
11761
11762
11763
11764
11765
11766
11767
11768
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 11743

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

#port(*args) ⇒ Object 



10898
10899
10900
10901
10902
10903
10904
10905
10906
10907
10908
10909
10910
10911
10912
10913
10914
10915
10916
10917
10918
10919
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 10898

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

#port=(*args) ⇒ Object 



10869
10870
10871
10872
10873
10874
10875
10876
10877
10878
10879
10880
10881
10882
10883
10884
10885
10886
10887
10888
10889
10890
10891
10892
10893
10894
10895
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 10869

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

#read_buffer(*args) ⇒ Object 



11941
11942
11943
11944
11945
11946
11947
11948
11949
11950
11951
11952
11953
11954
11955
11956
11957
11958
11959
11960
11961
11962
11963
11964
11965
11966
11967
11968
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 11941

SWIGINTERN VALUE
_wrap_MemcachedServerSt_read_buffer_get(int argc, VALUE *argv, VALUE self) {
  struct memcached_server_st *arg1 = (struct memcached_server_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_server_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_server_st *","read_buffer", 1, self )); 
  }
  arg1 = (struct memcached_server_st *)(argp1);
  result = (char *)(char *) ((arg1)->read_buffer);
  {
    size_t size = SWIG_strnlen(result, 8196);
    
    
    
    vresult = SWIG_FromCharPtrAndSize(result, size);
  }
  return vresult;
fail:
  return Qnil;
}

#read_buffer=(*args) ⇒ Object 



11911
11912
11913
11914
11915
11916
11917
11918
11919
11920
11921
11922
11923
11924
11925
11926
11927
11928
11929
11930
11931
11932
11933
11934
11935
11936
11937
11938
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 11911

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

#read_buffer_length(*args) ⇒ Object 



11560
11561
11562
11563
11564
11565
11566
11567
11568
11569
11570
11571
11572
11573
11574
11575
11576
11577
11578
11579
11580
11581
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 11560

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

#read_buffer_length=(*args) ⇒ Object 



11531
11532
11533
11534
11535
11536
11537
11538
11539
11540
11541
11542
11543
11544
11545
11546
11547
11548
11549
11550
11551
11552
11553
11554
11555
11556
11557
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 11531

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

#read_data_length(*args) ⇒ Object 



11613
11614
11615
11616
11617
11618
11619
11620
11621
11622
11623
11624
11625
11626
11627
11628
11629
11630
11631
11632
11633
11634
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 11613

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

#read_data_length=(*args) ⇒ Object 



11584
11585
11586
11587
11588
11589
11590
11591
11592
11593
11594
11595
11596
11597
11598
11599
11600
11601
11602
11603
11604
11605
11606
11607
11608
11609
11610
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 11584

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

#read_ptr(*args) ⇒ Object 



11445
11446
11447
11448
11449
11450
11451
11452
11453
11454
11455
11456
11457
11458
11459
11460
11461
11462
11463
11464
11465
11466
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 11445

SWIGINTERN VALUE
_wrap_MemcachedServerSt_read_ptr_get(int argc, VALUE *argv, VALUE self) {
  struct memcached_server_st *arg1 = (struct memcached_server_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_server_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_server_st *","read_ptr", 1, self )); 
  }
  arg1 = (struct memcached_server_st *)(argp1);
  result = (char *) ((arg1)->read_ptr);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

#read_ptr=(*args) ⇒ Object 



11407
11408
11409
11410
11411
11412
11413
11414
11415
11416
11417
11418
11419
11420
11421
11422
11423
11424
11425
11426
11427
11428
11429
11430
11431
11432
11433
11434
11435
11436
11437
11438
11439
11440
11441
11442
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 11407

SWIGINTERN VALUE
_wrap_MemcachedServerSt_read_ptr_set(int argc, VALUE *argv, VALUE self) {
  struct memcached_server_st *arg1 = (struct memcached_server_st *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 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_server_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_server_st *","read_ptr", 1, self )); 
  }
  arg1 = (struct memcached_server_st *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","read_ptr", 2, argv[0] ));
  }
  arg2 = (char *)(buf2);
  if (arg1->read_ptr) free((char*)arg1->read_ptr);
  if (arg2) {
    size_t size = strlen((const char *)(arg2)) + 1;
    arg1->read_ptr = (char *)(char *)memcpy(malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
  } else {
    arg1->read_ptr = 0;
  }
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

#root(*args) ⇒ Object 



11826
11827
11828
11829
11830
11831
11832
11833
11834
11835
11836
11837
11838
11839
11840
11841
11842
11843
11844
11845
11846
11847
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 11826

SWIGINTERN VALUE
_wrap_MemcachedServerSt_root_get(int argc, VALUE *argv, VALUE self) {
  struct memcached_server_st *arg1 = (struct memcached_server_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_server_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_server_st *","root", 1, self )); 
  }
  arg1 = (struct memcached_server_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 



11797
11798
11799
11800
11801
11802
11803
11804
11805
11806
11807
11808
11809
11810
11811
11812
11813
11814
11815
11816
11817
11818
11819
11820
11821
11822
11823
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 11797

SWIGINTERN VALUE
_wrap_MemcachedServerSt_root_set(int argc, VALUE *argv, VALUE self) {
  struct memcached_server_st *arg1 = (struct memcached_server_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_server_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_server_st *","root", 1, self )); 
  }
  arg1 = (struct memcached_server_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;
}

#server_failure_counter(*args) ⇒ Object 



11118
11119
11120
11121
11122
11123
11124
11125
11126
11127
11128
11129
11130
11131
11132
11133
11134
11135
11136
11137
11138
11139
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 11118

SWIGINTERN VALUE
_wrap_MemcachedServerSt_server_failure_counter_get(int argc, VALUE *argv, VALUE self) {
  struct memcached_server_st *arg1 = (struct memcached_server_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_server_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_server_st *","server_failure_counter", 1, self )); 
  }
  arg1 = (struct memcached_server_st *)(argp1);
  result =  ((arg1)->server_failure_counter);
  vresult = SWIG_From_unsigned_SS_int((unsigned int)(result));
  return vresult;
fail:
  return Qnil;
}

#server_failure_counter=(*args) ⇒ Object 



11089
11090
11091
11092
11093
11094
11095
11096
11097
11098
11099
11100
11101
11102
11103
11104
11105
11106
11107
11108
11109
11110
11111
11112
11113
11114
11115
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 11089

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

#sockaddr_inited(*args) ⇒ Object 



10739
10740
10741
10742
10743
10744
10745
10746
10747
10748
10749
10750
10751
10752
10753
10754
10755
10756
10757
10758
10759
10760
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 10739

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

#sockaddr_inited=(*args) ⇒ Object 



10710
10711
10712
10713
10714
10715
10716
10717
10718
10719
10720
10721
10722
10723
10724
10725
10726
10727
10728
10729
10730
10731
10732
10733
10734
10735
10736
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 10710

SWIGINTERN VALUE
_wrap_MemcachedServerSt_sockaddr_inited_set(int argc, VALUE *argv, VALUE self) {
  struct memcached_server_st *arg1 = (struct memcached_server_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_server_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_server_st *","sockaddr_inited", 1, self )); 
  }
  arg1 = (struct memcached_server_st *)(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","sockaddr_inited", 2, argv[0] ));
  } 
  arg2 = (bool)(val2);
  if (arg1) (arg1)->sockaddr_inited = arg2;
  return Qnil;
fail:
  return Qnil;
}

#type(*args) ⇒ Object 



11383
11384
11385
11386
11387
11388
11389
11390
11391
11392
11393
11394
11395
11396
11397
11398
11399
11400
11401
11402
11403
11404
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 11383

SWIGINTERN VALUE
_wrap_MemcachedServerSt_type_get(int argc, VALUE *argv, VALUE self) {
  struct memcached_server_st *arg1 = (struct memcached_server_st *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  memcached_connection 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_server_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_server_st *","type", 1, self )); 
  }
  arg1 = (struct memcached_server_st *)(argp1);
  result = (memcached_connection) ((arg1)->type);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

#type=(*args) ⇒ Object 



11354
11355
11356
11357
11358
11359
11360
11361
11362
11363
11364
11365
11366
11367
11368
11369
11370
11371
11372
11373
11374
11375
11376
11377
11378
11379
11380
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 11354

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

#weight(*args) ⇒ Object 



11171
11172
11173
11174
11175
11176
11177
11178
11179
11180
11181
11182
11183
11184
11185
11186
11187
11188
11189
11190
11191
11192
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 11171

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

#weight=(*args) ⇒ Object 



11142
11143
11144
11145
11146
11147
11148
11149
11150
11151
11152
11153
11154
11155
11156
11157
11158
11159
11160
11161
11162
11163
11164
11165
11166
11167
11168
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 11142

SWIGINTERN VALUE
_wrap_MemcachedServerSt_weight_set(int argc, VALUE *argv, VALUE self) {
  struct memcached_server_st *arg1 = (struct memcached_server_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_server_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_server_st *","weight", 1, self )); 
  }
  arg1 = (struct memcached_server_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","weight", 2, argv[0] ));
  } 
  arg2 = (uint32_t)(val2);
  if (arg1) (arg1)->weight = arg2;
  return Qnil;
fail:
  return Qnil;
}

#write_buffer(*args) ⇒ Object 



12001
12002
12003
12004
12005
12006
12007
12008
12009
12010
12011
12012
12013
12014
12015
12016
12017
12018
12019
12020
12021
12022
12023
12024
12025
12026
12027
12028
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 12001

SWIGINTERN VALUE
_wrap_MemcachedServerSt_write_buffer_get(int argc, VALUE *argv, VALUE self) {
  struct memcached_server_st *arg1 = (struct memcached_server_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_server_st, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_server_st *","write_buffer", 1, self )); 
  }
  arg1 = (struct memcached_server_st *)(argp1);
  result = (char *)(char *) ((arg1)->write_buffer);
  {
    size_t size = SWIG_strnlen(result, 8196);
    
    
    
    vresult = SWIG_FromCharPtrAndSize(result, size);
  }
  return vresult;
fail:
  return Qnil;
}

#write_buffer=(*args) ⇒ Object 



11971
11972
11973
11974
11975
11976
11977
11978
11979
11980
11981
11982
11983
11984
11985
11986
11987
11988
11989
11990
11991
11992
11993
11994
11995
11996
11997
11998
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 11971

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

#write_buffer_offset(*args) ⇒ Object 



11666
11667
11668
11669
11670
11671
11672
11673
11674
11675
11676
11677
11678
11679
11680
11681
11682
11683
11684
11685
11686
11687
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 11666

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

#write_buffer_offset=(*args) ⇒ Object 



11637
11638
11639
11640
11641
11642
11643
11644
11645
11646
11647
11648
11649
11650
11651
11652
11653
11654
11655
11656
11657
11658
11659
11660
11661
11662
11663
 
# File 'ext/rlibmemcached/rlibmemcached_wrap.c', line 11637

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