memcached 0.11 → 0.12
Sign up to get free protection for your applications and to get access to all the features.
- data.tar.gz.sig +0 -0
- data/CHANGELOG +3 -1
- data/COMPATIBILITY +1 -0
- data/README +3 -5
- data/ext/extconf.rb +14 -10
- data/ext/rlibmemcached.i +1 -1
- data/ext/rlibmemcached_wrap.c +1417 -379
- data/lib/memcached/behaviors.rb +1 -1
- data/lib/memcached/exceptions.rb +6 -13
- data/lib/memcached/memcached.rb +149 -115
- data/lib/memcached/rails.rb +34 -13
- data/memcached.gemspec +34 -104
- data/test/unit/memcached_test.rb +249 -163
- data/test/unit/rails_test.rb +1 -1
- metadata +4 -4
- metadata.gz.sig +1 -2
data.tar.gz.sig
CHANGED
Binary file
|
data/CHANGELOG
CHANGED
@@ -1,5 +1,7 @@
|
|
1
1
|
|
2
|
-
v0.
|
2
|
+
v0.12. Update to libmemcached 0.24. Support weights and flags. Default to HASH_WITH_PREFIX behavior. Note, if you use ketama, upgrading will invalidate your entire cache.
|
3
|
+
|
4
|
+
v0.11. Update to libmemcached 0.22. Support hostname lookups. Register %freefunc for MemcachedSt and remove destroy() method. Use new built-in behavior for namespacing. Raise on version mismatch. Remove private hash function. Fix bug related to socket size behavior reset when struct is initialized with missing servers (Jeffrey Hardy). Note, if you use a namespace, upgrading will invalidate your entire cache.
|
3
5
|
|
4
6
|
v0.10. Update to libmemcached 0.20. Failover support. Close consistent hashing bugs.
|
5
7
|
|
data/COMPATIBILITY
CHANGED
data/README
CHANGED
@@ -22,14 +22,14 @@ The <b>memcached</b> library wraps the pure-C libmemcached client via SWIG.
|
|
22
22
|
|
23
23
|
== Installation
|
24
24
|
|
25
|
-
You need Ruby 1.8.6, and {libmemcached 0.
|
25
|
+
You need Ruby 1.8.6, and {libmemcached 0.25}[http://tangent.org/552/libmemcached.html]. Other versions are not supported. You also need {memcached itself}[http://www.danga.com/memcached/] if you want to test against a local server.
|
26
26
|
|
27
|
-
For Linux, download and extract the {libmemcached tarball}[http://download.tangent.org/libmemcached-0.
|
27
|
+
For Linux, download and extract the {libmemcached tarball}[http://download.tangent.org/libmemcached-0.25.tar.gz]. Then run:
|
28
28
|
./configure
|
29
29
|
make && sudo make install
|
30
30
|
|
31
31
|
For OS X, you may be able to install it from MacPorts:
|
32
|
-
sudo port install libmemcached @0.
|
32
|
+
sudo port install libmemcached @0.25
|
33
33
|
|
34
34
|
Now install the gem:
|
35
35
|
sudo gem install memcached --no-rdoc --no-ri
|
@@ -91,8 +91,6 @@ Note that the API is not the same as that of <b>Ruby-MemCache</b> or <b>memcache
|
|
91
91
|
|
92
92
|
There is a compatibility wrapper for legacy applications called Memcached::Rails.
|
93
93
|
|
94
|
-
The easiest way to use it in your app is by installing Interlock[http://blog.evanweaver.com/files/doc/fauna/interlock] and setting <tt>client: memcached</tt> in <tt>config/memcached.yml</tt>. This gives you memcached fragments by default. You do not have to use the other Interlock features unless you want to.
|
95
|
-
|
96
94
|
== Threading
|
97
95
|
|
98
96
|
<b>memcached</b> is threadsafe, but each thread requires its own Memcached instance. Create a global Memcached, and then call Memcached#clone each time you spawn a thread.
|
data/ext/extconf.rb
CHANGED
@@ -6,30 +6,34 @@ if ENV['SWIG']
|
|
6
6
|
$stdout.write `swig -I/opt/local/include -ruby -autorename rlibmemcached.i`
|
7
7
|
end
|
8
8
|
|
9
|
+
if `uname -sp` == "Darwin i386\n"
|
10
|
+
$CFLAGS.gsub! /-arch \S+/, ''
|
11
|
+
$CFLAGS << " -arch i386"
|
12
|
+
$LDFLAGS.gsub! /-arch \S+/, ''
|
13
|
+
$LDFLAGS << " -arch i386"
|
14
|
+
end
|
15
|
+
|
9
16
|
$CFLAGS.gsub! /-O\d/, ''
|
10
17
|
|
11
18
|
if ENV['DEBUG']
|
12
19
|
puts "setting debug flags"
|
13
|
-
$CFLAGS << " -O0 -ggdb -DHAVE_DEBUG"
|
20
|
+
$CFLAGS << " -O0 -ggdb -DHAVE_DEBUG"
|
14
21
|
else
|
15
22
|
$CFLAGS << " -O3"
|
16
23
|
end
|
17
24
|
|
18
|
-
|
19
|
-
|
20
|
-
# XXX There's probably a better way to do this
|
21
|
-
raise "shared library 'libmemcached' not found" unless
|
22
|
-
find_library('memcached', 'memcached_server_add', *ENV['LD_LIBRARY_PATH'].to_s.split(":"))
|
25
|
+
find_library(*['memcached', 'memcached_server_add_with_weight', dir_config('libmemcached').last].compact) or
|
26
|
+
raise "shared library 'libmemcached' not found"
|
23
27
|
|
24
|
-
[
|
28
|
+
[
|
25
29
|
'libmemcached/memcached.h',
|
26
|
-
'libmemcached/memcached_constants.h',
|
30
|
+
'libmemcached/memcached_constants.h',
|
27
31
|
'libmemcached/memcached_storage.h',
|
28
32
|
'libmemcached/memcached_result.h',
|
29
33
|
'libmemcached/memcached_server.h'
|
30
34
|
].each do |header|
|
31
|
-
|
32
|
-
|
35
|
+
find_header(*[header, dir_config('libmemcached').first].compact) or
|
36
|
+
raise "header file '#{header}' not found"
|
33
37
|
end
|
34
38
|
|
35
39
|
create_makefile 'rlibmemcached'
|
data/ext/rlibmemcached.i
CHANGED
@@ -18,7 +18,7 @@
|
|
18
18
|
|
19
19
|
%apply unsigned short { uint8_t };
|
20
20
|
%apply unsigned int { uint16_t };
|
21
|
-
%apply unsigned long { uint32_t flags, uint32_t offset };
|
21
|
+
%apply unsigned long { uint32_t flags, uint32_t offset, uint32_t weight };
|
22
22
|
%apply unsigned long long {uint64_t data, uint64_t cas };
|
23
23
|
|
24
24
|
// Array of strings map for multiget
|
data/ext/rlibmemcached_wrap.c
CHANGED
@@ -1792,10 +1792,9 @@ int SWIG_Ruby_arity( VALUE proc, int minimal )
|
|
1792
1792
|
#define SWIGTYPE_p_time_t swig_types[27]
|
1793
1793
|
#define SWIGTYPE_p_uint32_t swig_types[28]
|
1794
1794
|
#define SWIGTYPE_p_uint64_t swig_types[29]
|
1795
|
-
#define
|
1796
|
-
|
1797
|
-
static
|
1798
|
-
static swig_module_info swig_module = {swig_types, 32, 0, 0, 0, 0};
|
1795
|
+
#define SWIGTYPE_p_void swig_types[30]
|
1796
|
+
static swig_type_info *swig_types[32];
|
1797
|
+
static swig_module_info swig_module = {swig_types, 31, 0, 0, 0, 0};
|
1799
1798
|
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
|
1800
1799
|
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
|
1801
1800
|
|
@@ -2042,22 +2041,6 @@ SWIG_AsVal_unsigned_SS_long (VALUE obj, unsigned long *val)
|
|
2042
2041
|
}
|
2043
2042
|
|
2044
2043
|
|
2045
|
-
SWIGINTERN int
|
2046
|
-
SWIG_AsVal_unsigned_SS_int (VALUE obj, unsigned int *val)
|
2047
|
-
{
|
2048
|
-
unsigned long v;
|
2049
|
-
int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
|
2050
|
-
if (SWIG_IsOK(res)) {
|
2051
|
-
if ((v > UINT_MAX)) {
|
2052
|
-
return SWIG_OverflowError;
|
2053
|
-
} else {
|
2054
|
-
if (val) *val = (unsigned int)(v);
|
2055
|
-
}
|
2056
|
-
}
|
2057
|
-
return res;
|
2058
|
-
}
|
2059
|
-
|
2060
|
-
|
2061
2044
|
SWIGINTERNINLINE VALUE
|
2062
2045
|
SWIG_From_unsigned_SS_long (unsigned long value)
|
2063
2046
|
{
|
@@ -2065,13 +2048,6 @@ SWIG_From_unsigned_SS_long (unsigned long value)
|
|
2065
2048
|
}
|
2066
2049
|
|
2067
2050
|
|
2068
|
-
SWIGINTERNINLINE VALUE
|
2069
|
-
SWIG_From_unsigned_SS_int (unsigned int value)
|
2070
|
-
{
|
2071
|
-
return SWIG_From_unsigned_SS_long (value);
|
2072
|
-
}
|
2073
|
-
|
2074
|
-
|
2075
2051
|
SWIGINTERNINLINE int
|
2076
2052
|
SWIG_AsVal_size_t (VALUE obj, size_t *val)
|
2077
2053
|
{
|
@@ -2089,6 +2065,32 @@ SWIG_From_size_t (size_t value)
|
|
2089
2065
|
}
|
2090
2066
|
|
2091
2067
|
|
2068
|
+
SWIGINTERN int
|
2069
|
+
SWIG_AsVal_char (VALUE obj, char *val)
|
2070
|
+
{
|
2071
|
+
int res = SWIG_AsCharArray(obj, val, 1);
|
2072
|
+
if (!SWIG_IsOK(res)) {
|
2073
|
+
long v;
|
2074
|
+
res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
|
2075
|
+
if (SWIG_IsOK(res)) {
|
2076
|
+
if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
|
2077
|
+
if (val) *val = (char)(v);
|
2078
|
+
} else {
|
2079
|
+
res = SWIG_OverflowError;
|
2080
|
+
}
|
2081
|
+
}
|
2082
|
+
}
|
2083
|
+
return res;
|
2084
|
+
}
|
2085
|
+
|
2086
|
+
|
2087
|
+
SWIGINTERNINLINE VALUE
|
2088
|
+
SWIG_From_char (char c)
|
2089
|
+
{
|
2090
|
+
return SWIG_FromCharPtrAndSize(&c,1);
|
2091
|
+
}
|
2092
|
+
|
2093
|
+
|
2092
2094
|
|
2093
2095
|
|
2094
2096
|
|
@@ -2113,6 +2115,22 @@ SWIG_From_unsigned_SS_short (unsigned short value)
|
|
2113
2115
|
}
|
2114
2116
|
|
2115
2117
|
|
2118
|
+
SWIGINTERN int
|
2119
|
+
SWIG_AsVal_unsigned_SS_int (VALUE obj, unsigned int *val)
|
2120
|
+
{
|
2121
|
+
unsigned long v;
|
2122
|
+
int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
|
2123
|
+
if (SWIG_IsOK(res)) {
|
2124
|
+
if ((v > UINT_MAX)) {
|
2125
|
+
return SWIG_OverflowError;
|
2126
|
+
} else {
|
2127
|
+
if (val) *val = (unsigned int)(v);
|
2128
|
+
}
|
2129
|
+
}
|
2130
|
+
return res;
|
2131
|
+
}
|
2132
|
+
|
2133
|
+
|
2116
2134
|
/*@SWIG:/opt/local/share/swig/1.3.36/ruby/rubyprimtypes.swg,23,%ruby_aux_method@*/
|
2117
2135
|
SWIGINTERN VALUE SWIG_AUX_NUM2ULL(VALUE *args)
|
2118
2136
|
{
|
@@ -2142,6 +2160,13 @@ SWIG_AsVal_unsigned_SS_long_SS_long (VALUE obj, unsigned long long *val)
|
|
2142
2160
|
}
|
2143
2161
|
|
2144
2162
|
|
2163
|
+
SWIGINTERNINLINE VALUE
|
2164
|
+
SWIG_From_unsigned_SS_int (unsigned int value)
|
2165
|
+
{
|
2166
|
+
return SWIG_From_unsigned_SS_long (value);
|
2167
|
+
}
|
2168
|
+
|
2169
|
+
|
2145
2170
|
SWIGINTERN int
|
2146
2171
|
SWIG_AsVal_unsigned_SS_short (VALUE obj, unsigned short *val)
|
2147
2172
|
{
|
@@ -3945,11 +3970,11 @@ fail:
|
|
3945
3970
|
SWIGINTERN VALUE
|
3946
3971
|
_wrap_MemcachedSt_number_of_hosts_set(int argc, VALUE *argv, VALUE self) {
|
3947
3972
|
struct memcached_st *arg1 = (struct memcached_st *) 0 ;
|
3948
|
-
|
3973
|
+
uint32_t arg2 ;
|
3949
3974
|
void *argp1 = 0 ;
|
3950
3975
|
int res1 = 0 ;
|
3951
|
-
|
3952
|
-
int
|
3976
|
+
void *argp2 ;
|
3977
|
+
int res2 = 0 ;
|
3953
3978
|
|
3954
3979
|
if ((argc < 1) || (argc > 1)) {
|
3955
3980
|
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
@@ -3959,11 +3984,17 @@ _wrap_MemcachedSt_number_of_hosts_set(int argc, VALUE *argv, VALUE self) {
|
|
3959
3984
|
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","number_of_hosts", 1, self ));
|
3960
3985
|
}
|
3961
3986
|
arg1 = (struct memcached_st *)(argp1);
|
3962
|
-
|
3963
|
-
|
3964
|
-
|
3965
|
-
|
3966
|
-
|
3987
|
+
{
|
3988
|
+
res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_uint32_t, 0 );
|
3989
|
+
if (!SWIG_IsOK(res2)) {
|
3990
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "uint32_t","number_of_hosts", 2, argv[0] ));
|
3991
|
+
}
|
3992
|
+
if (!argp2) {
|
3993
|
+
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "uint32_t","number_of_hosts", 2, argv[0]));
|
3994
|
+
} else {
|
3995
|
+
arg2 = *((uint32_t *)(argp2));
|
3996
|
+
}
|
3997
|
+
}
|
3967
3998
|
if (arg1) (arg1)->number_of_hosts = arg2;
|
3968
3999
|
return Qnil;
|
3969
4000
|
fail:
|
@@ -3976,7 +4007,7 @@ _wrap_MemcachedSt_number_of_hosts_get(int argc, VALUE *argv, VALUE self) {
|
|
3976
4007
|
struct memcached_st *arg1 = (struct memcached_st *) 0 ;
|
3977
4008
|
void *argp1 = 0 ;
|
3978
4009
|
int res1 = 0 ;
|
3979
|
-
|
4010
|
+
uint32_t result;
|
3980
4011
|
VALUE vresult = Qnil;
|
3981
4012
|
|
3982
4013
|
if ((argc < 0) || (argc > 0)) {
|
@@ -3987,8 +4018,8 @@ _wrap_MemcachedSt_number_of_hosts_get(int argc, VALUE *argv, VALUE self) {
|
|
3987
4018
|
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","number_of_hosts", 1, self ));
|
3988
4019
|
}
|
3989
4020
|
arg1 = (struct memcached_st *)(argp1);
|
3990
|
-
result =
|
3991
|
-
vresult =
|
4021
|
+
result = ((arg1)->number_of_hosts);
|
4022
|
+
vresult = SWIG_NewPointerObj((uint32_t *)memcpy((uint32_t *)malloc(sizeof(uint32_t)),&result,sizeof(uint32_t)), SWIGTYPE_p_uint32_t, SWIG_POINTER_OWN | 0 );
|
3992
4023
|
return vresult;
|
3993
4024
|
fail:
|
3994
4025
|
return Qnil;
|
@@ -3998,11 +4029,11 @@ fail:
|
|
3998
4029
|
SWIGINTERN VALUE
|
3999
4030
|
_wrap_MemcachedSt_cursor_server_set(int argc, VALUE *argv, VALUE self) {
|
4000
4031
|
struct memcached_st *arg1 = (struct memcached_st *) 0 ;
|
4001
|
-
|
4032
|
+
uint32_t arg2 ;
|
4002
4033
|
void *argp1 = 0 ;
|
4003
4034
|
int res1 = 0 ;
|
4004
|
-
|
4005
|
-
int
|
4035
|
+
void *argp2 ;
|
4036
|
+
int res2 = 0 ;
|
4006
4037
|
|
4007
4038
|
if ((argc < 1) || (argc > 1)) {
|
4008
4039
|
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
@@ -4012,11 +4043,17 @@ _wrap_MemcachedSt_cursor_server_set(int argc, VALUE *argv, VALUE self) {
|
|
4012
4043
|
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","cursor_server", 1, self ));
|
4013
4044
|
}
|
4014
4045
|
arg1 = (struct memcached_st *)(argp1);
|
4015
|
-
|
4016
|
-
|
4017
|
-
|
4018
|
-
|
4019
|
-
|
4046
|
+
{
|
4047
|
+
res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_uint32_t, 0 );
|
4048
|
+
if (!SWIG_IsOK(res2)) {
|
4049
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "uint32_t","cursor_server", 2, argv[0] ));
|
4050
|
+
}
|
4051
|
+
if (!argp2) {
|
4052
|
+
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "uint32_t","cursor_server", 2, argv[0]));
|
4053
|
+
} else {
|
4054
|
+
arg2 = *((uint32_t *)(argp2));
|
4055
|
+
}
|
4056
|
+
}
|
4020
4057
|
if (arg1) (arg1)->cursor_server = arg2;
|
4021
4058
|
return Qnil;
|
4022
4059
|
fail:
|
@@ -4029,7 +4066,7 @@ _wrap_MemcachedSt_cursor_server_get(int argc, VALUE *argv, VALUE self) {
|
|
4029
4066
|
struct memcached_st *arg1 = (struct memcached_st *) 0 ;
|
4030
4067
|
void *argp1 = 0 ;
|
4031
4068
|
int res1 = 0 ;
|
4032
|
-
|
4069
|
+
uint32_t result;
|
4033
4070
|
VALUE vresult = Qnil;
|
4034
4071
|
|
4035
4072
|
if ((argc < 0) || (argc > 0)) {
|
@@ -4040,8 +4077,8 @@ _wrap_MemcachedSt_cursor_server_get(int argc, VALUE *argv, VALUE self) {
|
|
4040
4077
|
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","cursor_server", 1, self ));
|
4041
4078
|
}
|
4042
4079
|
arg1 = (struct memcached_st *)(argp1);
|
4043
|
-
result =
|
4044
|
-
vresult =
|
4080
|
+
result = ((arg1)->cursor_server);
|
4081
|
+
vresult = SWIG_NewPointerObj((uint32_t *)memcpy((uint32_t *)malloc(sizeof(uint32_t)),&result,sizeof(uint32_t)), SWIGTYPE_p_uint32_t, SWIG_POINTER_OWN | 0 );
|
4045
4082
|
return vresult;
|
4046
4083
|
fail:
|
4047
4084
|
return Qnil;
|
@@ -4671,118 +4708,6 @@ fail:
|
|
4671
4708
|
}
|
4672
4709
|
|
4673
4710
|
|
4674
|
-
SWIGINTERN VALUE
|
4675
|
-
_wrap_MemcachedSt_wheel_set(int argc, VALUE *argv, VALUE self) {
|
4676
|
-
struct memcached_st *arg1 = (struct memcached_st *) 0 ;
|
4677
|
-
unsigned int *arg2 = (unsigned int *) 0 ;
|
4678
|
-
void *argp1 = 0 ;
|
4679
|
-
int res1 = 0 ;
|
4680
|
-
void *argp2 = 0 ;
|
4681
|
-
int res2 = 0 ;
|
4682
|
-
|
4683
|
-
if ((argc < 1) || (argc > 1)) {
|
4684
|
-
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
4685
|
-
}
|
4686
|
-
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 | 0 );
|
4687
|
-
if (!SWIG_IsOK(res1)) {
|
4688
|
-
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","wheel", 1, self ));
|
4689
|
-
}
|
4690
|
-
arg1 = (struct memcached_st *)(argp1);
|
4691
|
-
res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_unsigned_int, SWIG_POINTER_DISOWN | 0 );
|
4692
|
-
if (!SWIG_IsOK(res2)) {
|
4693
|
-
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "unsigned int *","wheel", 2, argv[0] ));
|
4694
|
-
}
|
4695
|
-
arg2 = (unsigned int *)(argp2);
|
4696
|
-
if (arg1) (arg1)->wheel = arg2;
|
4697
|
-
return Qnil;
|
4698
|
-
fail:
|
4699
|
-
return Qnil;
|
4700
|
-
}
|
4701
|
-
|
4702
|
-
|
4703
|
-
SWIGINTERN VALUE
|
4704
|
-
_wrap_MemcachedSt_wheel_get(int argc, VALUE *argv, VALUE self) {
|
4705
|
-
struct memcached_st *arg1 = (struct memcached_st *) 0 ;
|
4706
|
-
void *argp1 = 0 ;
|
4707
|
-
int res1 = 0 ;
|
4708
|
-
unsigned int *result = 0 ;
|
4709
|
-
VALUE vresult = Qnil;
|
4710
|
-
|
4711
|
-
if ((argc < 0) || (argc > 0)) {
|
4712
|
-
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
4713
|
-
}
|
4714
|
-
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 | 0 );
|
4715
|
-
if (!SWIG_IsOK(res1)) {
|
4716
|
-
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","wheel", 1, self ));
|
4717
|
-
}
|
4718
|
-
arg1 = (struct memcached_st *)(argp1);
|
4719
|
-
result = (unsigned int *) ((arg1)->wheel);
|
4720
|
-
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 | 0 );
|
4721
|
-
return vresult;
|
4722
|
-
fail:
|
4723
|
-
return Qnil;
|
4724
|
-
}
|
4725
|
-
|
4726
|
-
|
4727
|
-
SWIGINTERN VALUE
|
4728
|
-
_wrap_MemcachedSt_wheel_count_set(int argc, VALUE *argv, VALUE self) {
|
4729
|
-
struct memcached_st *arg1 = (struct memcached_st *) 0 ;
|
4730
|
-
uint32_t arg2 ;
|
4731
|
-
void *argp1 = 0 ;
|
4732
|
-
int res1 = 0 ;
|
4733
|
-
void *argp2 ;
|
4734
|
-
int res2 = 0 ;
|
4735
|
-
|
4736
|
-
if ((argc < 1) || (argc > 1)) {
|
4737
|
-
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
4738
|
-
}
|
4739
|
-
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 | 0 );
|
4740
|
-
if (!SWIG_IsOK(res1)) {
|
4741
|
-
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","wheel_count", 1, self ));
|
4742
|
-
}
|
4743
|
-
arg1 = (struct memcached_st *)(argp1);
|
4744
|
-
{
|
4745
|
-
res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_uint32_t, 0 );
|
4746
|
-
if (!SWIG_IsOK(res2)) {
|
4747
|
-
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "uint32_t","wheel_count", 2, argv[0] ));
|
4748
|
-
}
|
4749
|
-
if (!argp2) {
|
4750
|
-
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "uint32_t","wheel_count", 2, argv[0]));
|
4751
|
-
} else {
|
4752
|
-
arg2 = *((uint32_t *)(argp2));
|
4753
|
-
}
|
4754
|
-
}
|
4755
|
-
if (arg1) (arg1)->wheel_count = arg2;
|
4756
|
-
return Qnil;
|
4757
|
-
fail:
|
4758
|
-
return Qnil;
|
4759
|
-
}
|
4760
|
-
|
4761
|
-
|
4762
|
-
SWIGINTERN VALUE
|
4763
|
-
_wrap_MemcachedSt_wheel_count_get(int argc, VALUE *argv, VALUE self) {
|
4764
|
-
struct memcached_st *arg1 = (struct memcached_st *) 0 ;
|
4765
|
-
void *argp1 = 0 ;
|
4766
|
-
int res1 = 0 ;
|
4767
|
-
uint32_t result;
|
4768
|
-
VALUE vresult = Qnil;
|
4769
|
-
|
4770
|
-
if ((argc < 0) || (argc > 0)) {
|
4771
|
-
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
4772
|
-
}
|
4773
|
-
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 | 0 );
|
4774
|
-
if (!SWIG_IsOK(res1)) {
|
4775
|
-
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","wheel_count", 1, self ));
|
4776
|
-
}
|
4777
|
-
arg1 = (struct memcached_st *)(argp1);
|
4778
|
-
result = ((arg1)->wheel_count);
|
4779
|
-
vresult = SWIG_NewPointerObj((uint32_t *)memcpy((uint32_t *)malloc(sizeof(uint32_t)),&result,sizeof(uint32_t)), SWIGTYPE_p_uint32_t, SWIG_POINTER_OWN | 0 );
|
4780
|
-
return vresult;
|
4781
|
-
fail:
|
4782
|
-
return Qnil;
|
4783
|
-
}
|
4784
|
-
|
4785
|
-
|
4786
4711
|
SWIGINTERN VALUE
|
4787
4712
|
_wrap_MemcachedSt_continuum_count_set(int argc, VALUE *argv, VALUE self) {
|
4788
4713
|
struct memcached_st *arg1 = (struct memcached_st *) 0 ;
|
@@ -5421,48 +5346,53 @@ fail:
|
|
5421
5346
|
}
|
5422
5347
|
|
5423
5348
|
|
5424
|
-
#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
|
5425
|
-
SWIGINTERN VALUE
|
5426
|
-
_wrap_MemcachedSt_allocate(VALUE self) {
|
5427
|
-
#else
|
5428
|
-
SWIGINTERN VALUE
|
5429
|
-
_wrap_MemcachedSt_allocate(int argc, VALUE *argv, VALUE self) {
|
5430
|
-
#endif
|
5431
|
-
|
5432
|
-
|
5433
|
-
VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_memcached_st);
|
5434
|
-
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
|
5435
|
-
rb_obj_call_init(vresult, argc, argv);
|
5436
|
-
#endif
|
5437
|
-
return vresult;
|
5438
|
-
}
|
5439
|
-
|
5440
|
-
|
5441
5349
|
SWIGINTERN VALUE
|
5442
|
-
|
5443
|
-
struct memcached_st *
|
5350
|
+
_wrap_MemcachedSt_hash_continuum_set(int argc, VALUE *argv, VALUE self) {
|
5351
|
+
struct memcached_st *arg1 = (struct memcached_st *) 0 ;
|
5352
|
+
memcached_hash arg2 ;
|
5353
|
+
void *argp1 = 0 ;
|
5354
|
+
int res1 = 0 ;
|
5355
|
+
int val2 ;
|
5356
|
+
int ecode2 = 0 ;
|
5444
5357
|
|
5445
|
-
if ((argc <
|
5446
|
-
rb_raise(rb_eArgError, "wrong # of arguments(%d for
|
5358
|
+
if ((argc < 1) || (argc > 1)) {
|
5359
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
5447
5360
|
}
|
5448
|
-
|
5449
|
-
|
5450
|
-
|
5361
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 | 0 );
|
5362
|
+
if (!SWIG_IsOK(res1)) {
|
5363
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","hash_continuum", 1, self ));
|
5364
|
+
}
|
5365
|
+
arg1 = (struct memcached_st *)(argp1);
|
5366
|
+
ecode2 = SWIG_AsVal_int(argv[0], &val2);
|
5367
|
+
if (!SWIG_IsOK(ecode2)) {
|
5368
|
+
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "memcached_hash","hash_continuum", 2, argv[0] ));
|
5369
|
+
}
|
5370
|
+
arg2 = (memcached_hash)(val2);
|
5371
|
+
if (arg1) (arg1)->hash_continuum = arg2;
|
5372
|
+
return Qnil;
|
5451
5373
|
fail:
|
5452
5374
|
return Qnil;
|
5453
5375
|
}
|
5454
5376
|
|
5455
5377
|
|
5456
5378
|
SWIGINTERN VALUE
|
5457
|
-
|
5458
|
-
|
5379
|
+
_wrap_MemcachedSt_hash_continuum_get(int argc, VALUE *argv, VALUE self) {
|
5380
|
+
struct memcached_st *arg1 = (struct memcached_st *) 0 ;
|
5381
|
+
void *argp1 = 0 ;
|
5382
|
+
int res1 = 0 ;
|
5383
|
+
memcached_hash result;
|
5459
5384
|
VALUE vresult = Qnil;
|
5460
5385
|
|
5461
5386
|
if ((argc < 0) || (argc > 0)) {
|
5462
5387
|
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
5463
5388
|
}
|
5464
|
-
|
5465
|
-
|
5389
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 | 0 );
|
5390
|
+
if (!SWIG_IsOK(res1)) {
|
5391
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","hash_continuum", 1, self ));
|
5392
|
+
}
|
5393
|
+
arg1 = (struct memcached_st *)(argp1);
|
5394
|
+
result = (memcached_hash) ((arg1)->hash_continuum);
|
5395
|
+
vresult = SWIG_From_int((int)(result));
|
5466
5396
|
return vresult;
|
5467
5397
|
fail:
|
5468
5398
|
return Qnil;
|
@@ -5470,7 +5400,462 @@ fail:
|
|
5470
5400
|
|
5471
5401
|
|
5472
5402
|
SWIGINTERN VALUE
|
5473
|
-
|
5403
|
+
_wrap_MemcachedSt_continuum_points_counter_set(int argc, VALUE *argv, VALUE self) {
|
5404
|
+
struct memcached_st *arg1 = (struct memcached_st *) 0 ;
|
5405
|
+
uint32_t arg2 ;
|
5406
|
+
void *argp1 = 0 ;
|
5407
|
+
int res1 = 0 ;
|
5408
|
+
void *argp2 ;
|
5409
|
+
int res2 = 0 ;
|
5410
|
+
|
5411
|
+
if ((argc < 1) || (argc > 1)) {
|
5412
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
5413
|
+
}
|
5414
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 | 0 );
|
5415
|
+
if (!SWIG_IsOK(res1)) {
|
5416
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","continuum_points_counter", 1, self ));
|
5417
|
+
}
|
5418
|
+
arg1 = (struct memcached_st *)(argp1);
|
5419
|
+
{
|
5420
|
+
res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_uint32_t, 0 );
|
5421
|
+
if (!SWIG_IsOK(res2)) {
|
5422
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "uint32_t","continuum_points_counter", 2, argv[0] ));
|
5423
|
+
}
|
5424
|
+
if (!argp2) {
|
5425
|
+
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "uint32_t","continuum_points_counter", 2, argv[0]));
|
5426
|
+
} else {
|
5427
|
+
arg2 = *((uint32_t *)(argp2));
|
5428
|
+
}
|
5429
|
+
}
|
5430
|
+
if (arg1) (arg1)->continuum_points_counter = arg2;
|
5431
|
+
return Qnil;
|
5432
|
+
fail:
|
5433
|
+
return Qnil;
|
5434
|
+
}
|
5435
|
+
|
5436
|
+
|
5437
|
+
SWIGINTERN VALUE
|
5438
|
+
_wrap_MemcachedSt_continuum_points_counter_get(int argc, VALUE *argv, VALUE self) {
|
5439
|
+
struct memcached_st *arg1 = (struct memcached_st *) 0 ;
|
5440
|
+
void *argp1 = 0 ;
|
5441
|
+
int res1 = 0 ;
|
5442
|
+
uint32_t result;
|
5443
|
+
VALUE vresult = Qnil;
|
5444
|
+
|
5445
|
+
if ((argc < 0) || (argc > 0)) {
|
5446
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
5447
|
+
}
|
5448
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 | 0 );
|
5449
|
+
if (!SWIG_IsOK(res1)) {
|
5450
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","continuum_points_counter", 1, self ));
|
5451
|
+
}
|
5452
|
+
arg1 = (struct memcached_st *)(argp1);
|
5453
|
+
result = ((arg1)->continuum_points_counter);
|
5454
|
+
vresult = SWIG_NewPointerObj((uint32_t *)memcpy((uint32_t *)malloc(sizeof(uint32_t)),&result,sizeof(uint32_t)), SWIGTYPE_p_uint32_t, SWIG_POINTER_OWN | 0 );
|
5455
|
+
return vresult;
|
5456
|
+
fail:
|
5457
|
+
return Qnil;
|
5458
|
+
}
|
5459
|
+
|
5460
|
+
|
5461
|
+
SWIGINTERN VALUE
|
5462
|
+
_wrap_MemcachedSt_snd_timeout_set(int argc, VALUE *argv, VALUE self) {
|
5463
|
+
struct memcached_st *arg1 = (struct memcached_st *) 0 ;
|
5464
|
+
int32_t arg2 ;
|
5465
|
+
void *argp1 = 0 ;
|
5466
|
+
int res1 = 0 ;
|
5467
|
+
void *argp2 ;
|
5468
|
+
int res2 = 0 ;
|
5469
|
+
|
5470
|
+
if ((argc < 1) || (argc > 1)) {
|
5471
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
5472
|
+
}
|
5473
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 | 0 );
|
5474
|
+
if (!SWIG_IsOK(res1)) {
|
5475
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","snd_timeout", 1, self ));
|
5476
|
+
}
|
5477
|
+
arg1 = (struct memcached_st *)(argp1);
|
5478
|
+
{
|
5479
|
+
res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_int32_t, 0 );
|
5480
|
+
if (!SWIG_IsOK(res2)) {
|
5481
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "int32_t","snd_timeout", 2, argv[0] ));
|
5482
|
+
}
|
5483
|
+
if (!argp2) {
|
5484
|
+
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "int32_t","snd_timeout", 2, argv[0]));
|
5485
|
+
} else {
|
5486
|
+
arg2 = *((int32_t *)(argp2));
|
5487
|
+
}
|
5488
|
+
}
|
5489
|
+
if (arg1) (arg1)->snd_timeout = arg2;
|
5490
|
+
return Qnil;
|
5491
|
+
fail:
|
5492
|
+
return Qnil;
|
5493
|
+
}
|
5494
|
+
|
5495
|
+
|
5496
|
+
SWIGINTERN VALUE
|
5497
|
+
_wrap_MemcachedSt_snd_timeout_get(int argc, VALUE *argv, VALUE self) {
|
5498
|
+
struct memcached_st *arg1 = (struct memcached_st *) 0 ;
|
5499
|
+
void *argp1 = 0 ;
|
5500
|
+
int res1 = 0 ;
|
5501
|
+
int32_t result;
|
5502
|
+
VALUE vresult = Qnil;
|
5503
|
+
|
5504
|
+
if ((argc < 0) || (argc > 0)) {
|
5505
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
5506
|
+
}
|
5507
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 | 0 );
|
5508
|
+
if (!SWIG_IsOK(res1)) {
|
5509
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","snd_timeout", 1, self ));
|
5510
|
+
}
|
5511
|
+
arg1 = (struct memcached_st *)(argp1);
|
5512
|
+
result = ((arg1)->snd_timeout);
|
5513
|
+
vresult = SWIG_NewPointerObj((int32_t *)memcpy((int32_t *)malloc(sizeof(int32_t)),&result,sizeof(int32_t)), SWIGTYPE_p_int32_t, SWIG_POINTER_OWN | 0 );
|
5514
|
+
return vresult;
|
5515
|
+
fail:
|
5516
|
+
return Qnil;
|
5517
|
+
}
|
5518
|
+
|
5519
|
+
|
5520
|
+
SWIGINTERN VALUE
|
5521
|
+
_wrap_MemcachedSt_rcv_timeout_set(int argc, VALUE *argv, VALUE self) {
|
5522
|
+
struct memcached_st *arg1 = (struct memcached_st *) 0 ;
|
5523
|
+
int32_t arg2 ;
|
5524
|
+
void *argp1 = 0 ;
|
5525
|
+
int res1 = 0 ;
|
5526
|
+
void *argp2 ;
|
5527
|
+
int res2 = 0 ;
|
5528
|
+
|
5529
|
+
if ((argc < 1) || (argc > 1)) {
|
5530
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
5531
|
+
}
|
5532
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 | 0 );
|
5533
|
+
if (!SWIG_IsOK(res1)) {
|
5534
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","rcv_timeout", 1, self ));
|
5535
|
+
}
|
5536
|
+
arg1 = (struct memcached_st *)(argp1);
|
5537
|
+
{
|
5538
|
+
res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_int32_t, 0 );
|
5539
|
+
if (!SWIG_IsOK(res2)) {
|
5540
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "int32_t","rcv_timeout", 2, argv[0] ));
|
5541
|
+
}
|
5542
|
+
if (!argp2) {
|
5543
|
+
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "int32_t","rcv_timeout", 2, argv[0]));
|
5544
|
+
} else {
|
5545
|
+
arg2 = *((int32_t *)(argp2));
|
5546
|
+
}
|
5547
|
+
}
|
5548
|
+
if (arg1) (arg1)->rcv_timeout = arg2;
|
5549
|
+
return Qnil;
|
5550
|
+
fail:
|
5551
|
+
return Qnil;
|
5552
|
+
}
|
5553
|
+
|
5554
|
+
|
5555
|
+
SWIGINTERN VALUE
|
5556
|
+
_wrap_MemcachedSt_rcv_timeout_get(int argc, VALUE *argv, VALUE self) {
|
5557
|
+
struct memcached_st *arg1 = (struct memcached_st *) 0 ;
|
5558
|
+
void *argp1 = 0 ;
|
5559
|
+
int res1 = 0 ;
|
5560
|
+
int32_t result;
|
5561
|
+
VALUE vresult = Qnil;
|
5562
|
+
|
5563
|
+
if ((argc < 0) || (argc > 0)) {
|
5564
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
5565
|
+
}
|
5566
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 | 0 );
|
5567
|
+
if (!SWIG_IsOK(res1)) {
|
5568
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","rcv_timeout", 1, self ));
|
5569
|
+
}
|
5570
|
+
arg1 = (struct memcached_st *)(argp1);
|
5571
|
+
result = ((arg1)->rcv_timeout);
|
5572
|
+
vresult = SWIG_NewPointerObj((int32_t *)memcpy((int32_t *)malloc(sizeof(int32_t)),&result,sizeof(int32_t)), SWIGTYPE_p_int32_t, SWIG_POINTER_OWN | 0 );
|
5573
|
+
return vresult;
|
5574
|
+
fail:
|
5575
|
+
return Qnil;
|
5576
|
+
}
|
5577
|
+
|
5578
|
+
|
5579
|
+
SWIGINTERN VALUE
|
5580
|
+
_wrap_MemcachedSt_server_failure_limit_set(int argc, VALUE *argv, VALUE self) {
|
5581
|
+
struct memcached_st *arg1 = (struct memcached_st *) 0 ;
|
5582
|
+
uint32_t arg2 ;
|
5583
|
+
void *argp1 = 0 ;
|
5584
|
+
int res1 = 0 ;
|
5585
|
+
void *argp2 ;
|
5586
|
+
int res2 = 0 ;
|
5587
|
+
|
5588
|
+
if ((argc < 1) || (argc > 1)) {
|
5589
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
5590
|
+
}
|
5591
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 | 0 );
|
5592
|
+
if (!SWIG_IsOK(res1)) {
|
5593
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","server_failure_limit", 1, self ));
|
5594
|
+
}
|
5595
|
+
arg1 = (struct memcached_st *)(argp1);
|
5596
|
+
{
|
5597
|
+
res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_uint32_t, 0 );
|
5598
|
+
if (!SWIG_IsOK(res2)) {
|
5599
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "uint32_t","server_failure_limit", 2, argv[0] ));
|
5600
|
+
}
|
5601
|
+
if (!argp2) {
|
5602
|
+
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "uint32_t","server_failure_limit", 2, argv[0]));
|
5603
|
+
} else {
|
5604
|
+
arg2 = *((uint32_t *)(argp2));
|
5605
|
+
}
|
5606
|
+
}
|
5607
|
+
if (arg1) (arg1)->server_failure_limit = arg2;
|
5608
|
+
return Qnil;
|
5609
|
+
fail:
|
5610
|
+
return Qnil;
|
5611
|
+
}
|
5612
|
+
|
5613
|
+
|
5614
|
+
SWIGINTERN VALUE
|
5615
|
+
_wrap_MemcachedSt_server_failure_limit_get(int argc, VALUE *argv, VALUE self) {
|
5616
|
+
struct memcached_st *arg1 = (struct memcached_st *) 0 ;
|
5617
|
+
void *argp1 = 0 ;
|
5618
|
+
int res1 = 0 ;
|
5619
|
+
uint32_t result;
|
5620
|
+
VALUE vresult = Qnil;
|
5621
|
+
|
5622
|
+
if ((argc < 0) || (argc > 0)) {
|
5623
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
5624
|
+
}
|
5625
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 | 0 );
|
5626
|
+
if (!SWIG_IsOK(res1)) {
|
5627
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","server_failure_limit", 1, self ));
|
5628
|
+
}
|
5629
|
+
arg1 = (struct memcached_st *)(argp1);
|
5630
|
+
result = ((arg1)->server_failure_limit);
|
5631
|
+
vresult = SWIG_NewPointerObj((uint32_t *)memcpy((uint32_t *)malloc(sizeof(uint32_t)),&result,sizeof(uint32_t)), SWIGTYPE_p_uint32_t, SWIG_POINTER_OWN | 0 );
|
5632
|
+
return vresult;
|
5633
|
+
fail:
|
5634
|
+
return Qnil;
|
5635
|
+
}
|
5636
|
+
|
5637
|
+
|
5638
|
+
SWIGINTERN VALUE
|
5639
|
+
_wrap_MemcachedSt_io_msg_watermark_set(int argc, VALUE *argv, VALUE self) {
|
5640
|
+
struct memcached_st *arg1 = (struct memcached_st *) 0 ;
|
5641
|
+
uint32_t arg2 ;
|
5642
|
+
void *argp1 = 0 ;
|
5643
|
+
int res1 = 0 ;
|
5644
|
+
void *argp2 ;
|
5645
|
+
int res2 = 0 ;
|
5646
|
+
|
5647
|
+
if ((argc < 1) || (argc > 1)) {
|
5648
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
5649
|
+
}
|
5650
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 | 0 );
|
5651
|
+
if (!SWIG_IsOK(res1)) {
|
5652
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","io_msg_watermark", 1, self ));
|
5653
|
+
}
|
5654
|
+
arg1 = (struct memcached_st *)(argp1);
|
5655
|
+
{
|
5656
|
+
res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_uint32_t, 0 );
|
5657
|
+
if (!SWIG_IsOK(res2)) {
|
5658
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "uint32_t","io_msg_watermark", 2, argv[0] ));
|
5659
|
+
}
|
5660
|
+
if (!argp2) {
|
5661
|
+
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "uint32_t","io_msg_watermark", 2, argv[0]));
|
5662
|
+
} else {
|
5663
|
+
arg2 = *((uint32_t *)(argp2));
|
5664
|
+
}
|
5665
|
+
}
|
5666
|
+
if (arg1) (arg1)->io_msg_watermark = arg2;
|
5667
|
+
return Qnil;
|
5668
|
+
fail:
|
5669
|
+
return Qnil;
|
5670
|
+
}
|
5671
|
+
|
5672
|
+
|
5673
|
+
SWIGINTERN VALUE
|
5674
|
+
_wrap_MemcachedSt_io_msg_watermark_get(int argc, VALUE *argv, VALUE self) {
|
5675
|
+
struct memcached_st *arg1 = (struct memcached_st *) 0 ;
|
5676
|
+
void *argp1 = 0 ;
|
5677
|
+
int res1 = 0 ;
|
5678
|
+
uint32_t result;
|
5679
|
+
VALUE vresult = Qnil;
|
5680
|
+
|
5681
|
+
if ((argc < 0) || (argc > 0)) {
|
5682
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
5683
|
+
}
|
5684
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 | 0 );
|
5685
|
+
if (!SWIG_IsOK(res1)) {
|
5686
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","io_msg_watermark", 1, self ));
|
5687
|
+
}
|
5688
|
+
arg1 = (struct memcached_st *)(argp1);
|
5689
|
+
result = ((arg1)->io_msg_watermark);
|
5690
|
+
vresult = SWIG_NewPointerObj((uint32_t *)memcpy((uint32_t *)malloc(sizeof(uint32_t)),&result,sizeof(uint32_t)), SWIGTYPE_p_uint32_t, SWIG_POINTER_OWN | 0 );
|
5691
|
+
return vresult;
|
5692
|
+
fail:
|
5693
|
+
return Qnil;
|
5694
|
+
}
|
5695
|
+
|
5696
|
+
|
5697
|
+
SWIGINTERN VALUE
|
5698
|
+
_wrap_MemcachedSt_io_bytes_watermark_set(int argc, VALUE *argv, VALUE self) {
|
5699
|
+
struct memcached_st *arg1 = (struct memcached_st *) 0 ;
|
5700
|
+
uint32_t arg2 ;
|
5701
|
+
void *argp1 = 0 ;
|
5702
|
+
int res1 = 0 ;
|
5703
|
+
void *argp2 ;
|
5704
|
+
int res2 = 0 ;
|
5705
|
+
|
5706
|
+
if ((argc < 1) || (argc > 1)) {
|
5707
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
5708
|
+
}
|
5709
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 | 0 );
|
5710
|
+
if (!SWIG_IsOK(res1)) {
|
5711
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","io_bytes_watermark", 1, self ));
|
5712
|
+
}
|
5713
|
+
arg1 = (struct memcached_st *)(argp1);
|
5714
|
+
{
|
5715
|
+
res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_uint32_t, 0 );
|
5716
|
+
if (!SWIG_IsOK(res2)) {
|
5717
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "uint32_t","io_bytes_watermark", 2, argv[0] ));
|
5718
|
+
}
|
5719
|
+
if (!argp2) {
|
5720
|
+
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "uint32_t","io_bytes_watermark", 2, argv[0]));
|
5721
|
+
} else {
|
5722
|
+
arg2 = *((uint32_t *)(argp2));
|
5723
|
+
}
|
5724
|
+
}
|
5725
|
+
if (arg1) (arg1)->io_bytes_watermark = arg2;
|
5726
|
+
return Qnil;
|
5727
|
+
fail:
|
5728
|
+
return Qnil;
|
5729
|
+
}
|
5730
|
+
|
5731
|
+
|
5732
|
+
SWIGINTERN VALUE
|
5733
|
+
_wrap_MemcachedSt_io_bytes_watermark_get(int argc, VALUE *argv, VALUE self) {
|
5734
|
+
struct memcached_st *arg1 = (struct memcached_st *) 0 ;
|
5735
|
+
void *argp1 = 0 ;
|
5736
|
+
int res1 = 0 ;
|
5737
|
+
uint32_t result;
|
5738
|
+
VALUE vresult = Qnil;
|
5739
|
+
|
5740
|
+
if ((argc < 0) || (argc > 0)) {
|
5741
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
5742
|
+
}
|
5743
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 | 0 );
|
5744
|
+
if (!SWIG_IsOK(res1)) {
|
5745
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","io_bytes_watermark", 1, self ));
|
5746
|
+
}
|
5747
|
+
arg1 = (struct memcached_st *)(argp1);
|
5748
|
+
result = ((arg1)->io_bytes_watermark);
|
5749
|
+
vresult = SWIG_NewPointerObj((uint32_t *)memcpy((uint32_t *)malloc(sizeof(uint32_t)),&result,sizeof(uint32_t)), SWIGTYPE_p_uint32_t, SWIG_POINTER_OWN | 0 );
|
5750
|
+
return vresult;
|
5751
|
+
fail:
|
5752
|
+
return Qnil;
|
5753
|
+
}
|
5754
|
+
|
5755
|
+
|
5756
|
+
SWIGINTERN VALUE
|
5757
|
+
_wrap_MemcachedSt_purging_set(int argc, VALUE *argv, VALUE self) {
|
5758
|
+
struct memcached_st *arg1 = (struct memcached_st *) 0 ;
|
5759
|
+
char arg2 ;
|
5760
|
+
void *argp1 = 0 ;
|
5761
|
+
int res1 = 0 ;
|
5762
|
+
char val2 ;
|
5763
|
+
int ecode2 = 0 ;
|
5764
|
+
|
5765
|
+
if ((argc < 1) || (argc > 1)) {
|
5766
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
5767
|
+
}
|
5768
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 | 0 );
|
5769
|
+
if (!SWIG_IsOK(res1)) {
|
5770
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","purging", 1, self ));
|
5771
|
+
}
|
5772
|
+
arg1 = (struct memcached_st *)(argp1);
|
5773
|
+
ecode2 = SWIG_AsVal_char(argv[0], &val2);
|
5774
|
+
if (!SWIG_IsOK(ecode2)) {
|
5775
|
+
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "char","purging", 2, argv[0] ));
|
5776
|
+
}
|
5777
|
+
arg2 = (char)(val2);
|
5778
|
+
if (arg1) (arg1)->purging = arg2;
|
5779
|
+
return Qnil;
|
5780
|
+
fail:
|
5781
|
+
return Qnil;
|
5782
|
+
}
|
5783
|
+
|
5784
|
+
|
5785
|
+
SWIGINTERN VALUE
|
5786
|
+
_wrap_MemcachedSt_purging_get(int argc, VALUE *argv, VALUE self) {
|
5787
|
+
struct memcached_st *arg1 = (struct memcached_st *) 0 ;
|
5788
|
+
void *argp1 = 0 ;
|
5789
|
+
int res1 = 0 ;
|
5790
|
+
char result;
|
5791
|
+
VALUE vresult = Qnil;
|
5792
|
+
|
5793
|
+
if ((argc < 0) || (argc > 0)) {
|
5794
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
5795
|
+
}
|
5796
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 | 0 );
|
5797
|
+
if (!SWIG_IsOK(res1)) {
|
5798
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","purging", 1, self ));
|
5799
|
+
}
|
5800
|
+
arg1 = (struct memcached_st *)(argp1);
|
5801
|
+
result = (char) ((arg1)->purging);
|
5802
|
+
vresult = SWIG_From_char((char)(result));
|
5803
|
+
return vresult;
|
5804
|
+
fail:
|
5805
|
+
return Qnil;
|
5806
|
+
}
|
5807
|
+
|
5808
|
+
|
5809
|
+
#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
|
5810
|
+
SWIGINTERN VALUE
|
5811
|
+
_wrap_MemcachedSt_allocate(VALUE self) {
|
5812
|
+
#else
|
5813
|
+
SWIGINTERN VALUE
|
5814
|
+
_wrap_MemcachedSt_allocate(int argc, VALUE *argv, VALUE self) {
|
5815
|
+
#endif
|
5816
|
+
|
5817
|
+
|
5818
|
+
VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_memcached_st);
|
5819
|
+
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
|
5820
|
+
rb_obj_call_init(vresult, argc, argv);
|
5821
|
+
#endif
|
5822
|
+
return vresult;
|
5823
|
+
}
|
5824
|
+
|
5825
|
+
|
5826
|
+
SWIGINTERN VALUE
|
5827
|
+
_wrap_new_MemcachedSt(int argc, VALUE *argv, VALUE self) {
|
5828
|
+
struct memcached_st *result = 0 ;
|
5829
|
+
|
5830
|
+
if ((argc < 0) || (argc > 0)) {
|
5831
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
5832
|
+
}
|
5833
|
+
result = (struct memcached_st *)calloc(1, sizeof(struct memcached_st));
|
5834
|
+
DATA_PTR(self) = result;
|
5835
|
+
return self;
|
5836
|
+
fail:
|
5837
|
+
return Qnil;
|
5838
|
+
}
|
5839
|
+
|
5840
|
+
|
5841
|
+
SWIGINTERN VALUE
|
5842
|
+
_wrap_memcached_lib_version(int argc, VALUE *argv, VALUE self) {
|
5843
|
+
char *result = 0 ;
|
5844
|
+
VALUE vresult = Qnil;
|
5845
|
+
|
5846
|
+
if ((argc < 0) || (argc > 0)) {
|
5847
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
5848
|
+
}
|
5849
|
+
result = (char *)memcached_lib_version();
|
5850
|
+
vresult = SWIG_FromCharPtr((const char *)result);
|
5851
|
+
return vresult;
|
5852
|
+
fail:
|
5853
|
+
return Qnil;
|
5854
|
+
}
|
5855
|
+
|
5856
|
+
|
5857
|
+
SWIGINTERN VALUE
|
5858
|
+
_wrap_memcached_create(int argc, VALUE *argv, VALUE self) {
|
5474
5859
|
memcached_st *arg1 = (memcached_st *) 0 ;
|
5475
5860
|
void *argp1 = 0 ;
|
5476
5861
|
int res1 = 0 ;
|
@@ -5945,63 +6330,185 @@ _wrap_memcached_behavior_set(int argc, VALUE *argv, VALUE self) {
|
|
5945
6330
|
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_behavior_set", 1, argv[0] ));
|
5946
6331
|
}
|
5947
6332
|
arg1 = (memcached_st *)(argp1);
|
5948
|
-
ecode2 = SWIG_AsVal_int(argv[1], &val2);
|
5949
|
-
if (!SWIG_IsOK(ecode2)) {
|
5950
|
-
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "memcached_behavior","memcached_behavior_set", 2, argv[1] ));
|
5951
|
-
}
|
5952
|
-
arg2 = (memcached_behavior)(val2);
|
5953
|
-
ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(argv[2], &val3);
|
5954
|
-
if (!SWIG_IsOK(ecode3)) {
|
5955
|
-
SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "uint64_t","memcached_behavior_set", 3, argv[2] ));
|
5956
|
-
}
|
5957
|
-
arg3 = (uint64_t)(val3);
|
5958
|
-
result = (memcached_return)memcached_behavior_set(arg1,arg2,arg3);
|
6333
|
+
ecode2 = SWIG_AsVal_int(argv[1], &val2);
|
6334
|
+
if (!SWIG_IsOK(ecode2)) {
|
6335
|
+
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "memcached_behavior","memcached_behavior_set", 2, argv[1] ));
|
6336
|
+
}
|
6337
|
+
arg2 = (memcached_behavior)(val2);
|
6338
|
+
ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(argv[2], &val3);
|
6339
|
+
if (!SWIG_IsOK(ecode3)) {
|
6340
|
+
SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "uint64_t","memcached_behavior_set", 3, argv[2] ));
|
6341
|
+
}
|
6342
|
+
arg3 = (uint64_t)(val3);
|
6343
|
+
result = (memcached_return)memcached_behavior_set(arg1,arg2,arg3);
|
6344
|
+
vresult = SWIG_From_int((int)(result));
|
6345
|
+
return vresult;
|
6346
|
+
fail:
|
6347
|
+
return Qnil;
|
6348
|
+
}
|
6349
|
+
|
6350
|
+
|
6351
|
+
SWIGINTERN VALUE
|
6352
|
+
_wrap_memcached_behavior_get(int argc, VALUE *argv, VALUE self) {
|
6353
|
+
memcached_st *arg1 = (memcached_st *) 0 ;
|
6354
|
+
memcached_behavior arg2 ;
|
6355
|
+
void *argp1 = 0 ;
|
6356
|
+
int res1 = 0 ;
|
6357
|
+
int val2 ;
|
6358
|
+
int ecode2 = 0 ;
|
6359
|
+
uint64_t result;
|
6360
|
+
VALUE vresult = Qnil;
|
6361
|
+
|
6362
|
+
if ((argc < 2) || (argc > 2)) {
|
6363
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
|
6364
|
+
}
|
6365
|
+
res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 | 0 );
|
6366
|
+
if (!SWIG_IsOK(res1)) {
|
6367
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_behavior_get", 1, argv[0] ));
|
6368
|
+
}
|
6369
|
+
arg1 = (memcached_st *)(argp1);
|
6370
|
+
ecode2 = SWIG_AsVal_int(argv[1], &val2);
|
6371
|
+
if (!SWIG_IsOK(ecode2)) {
|
6372
|
+
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "memcached_behavior","memcached_behavior_get", 2, argv[1] ));
|
6373
|
+
}
|
6374
|
+
arg2 = (memcached_behavior)(val2);
|
6375
|
+
result = memcached_behavior_get(arg1,arg2);
|
6376
|
+
{
|
6377
|
+
vresult = INT2FIX(result);
|
6378
|
+
}
|
6379
|
+
return vresult;
|
6380
|
+
fail:
|
6381
|
+
return Qnil;
|
6382
|
+
}
|
6383
|
+
|
6384
|
+
|
6385
|
+
SWIGINTERN VALUE
|
6386
|
+
_wrap_memcached_server_add_udp(int argc, VALUE *argv, VALUE self) {
|
6387
|
+
memcached_st *arg1 = (memcached_st *) 0 ;
|
6388
|
+
char *arg2 = (char *) 0 ;
|
6389
|
+
unsigned int arg3 ;
|
6390
|
+
void *argp1 = 0 ;
|
6391
|
+
int res1 = 0 ;
|
6392
|
+
int res2 ;
|
6393
|
+
char *buf2 = 0 ;
|
6394
|
+
int alloc2 = 0 ;
|
6395
|
+
unsigned int val3 ;
|
6396
|
+
int ecode3 = 0 ;
|
6397
|
+
memcached_return result;
|
6398
|
+
VALUE vresult = Qnil;
|
6399
|
+
|
6400
|
+
if ((argc < 3) || (argc > 3)) {
|
6401
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
|
6402
|
+
}
|
6403
|
+
res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 | 0 );
|
6404
|
+
if (!SWIG_IsOK(res1)) {
|
6405
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_server_add_udp", 1, argv[0] ));
|
6406
|
+
}
|
6407
|
+
arg1 = (memcached_st *)(argp1);
|
6408
|
+
res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
|
6409
|
+
if (!SWIG_IsOK(res2)) {
|
6410
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","memcached_server_add_udp", 2, argv[1] ));
|
6411
|
+
}
|
6412
|
+
arg2 = (char *)(buf2);
|
6413
|
+
ecode3 = SWIG_AsVal_unsigned_SS_int(argv[2], &val3);
|
6414
|
+
if (!SWIG_IsOK(ecode3)) {
|
6415
|
+
SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","memcached_server_add_udp", 3, argv[2] ));
|
6416
|
+
}
|
6417
|
+
arg3 = (unsigned int)(val3);
|
6418
|
+
result = (memcached_return)memcached_server_add_udp(arg1,(char const *)arg2,arg3);
|
6419
|
+
vresult = SWIG_From_int((int)(result));
|
6420
|
+
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
|
6421
|
+
return vresult;
|
6422
|
+
fail:
|
6423
|
+
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
|
6424
|
+
return Qnil;
|
6425
|
+
}
|
6426
|
+
|
6427
|
+
|
6428
|
+
SWIGINTERN VALUE
|
6429
|
+
_wrap_memcached_server_add_unix_socket(int argc, VALUE *argv, VALUE self) {
|
6430
|
+
memcached_st *arg1 = (memcached_st *) 0 ;
|
6431
|
+
char *arg2 = (char *) 0 ;
|
6432
|
+
void *argp1 = 0 ;
|
6433
|
+
int res1 = 0 ;
|
6434
|
+
int res2 ;
|
6435
|
+
char *buf2 = 0 ;
|
6436
|
+
int alloc2 = 0 ;
|
6437
|
+
memcached_return result;
|
6438
|
+
VALUE vresult = Qnil;
|
6439
|
+
|
6440
|
+
if ((argc < 2) || (argc > 2)) {
|
6441
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
|
6442
|
+
}
|
6443
|
+
res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 | 0 );
|
6444
|
+
if (!SWIG_IsOK(res1)) {
|
6445
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_server_add_unix_socket", 1, argv[0] ));
|
6446
|
+
}
|
6447
|
+
arg1 = (memcached_st *)(argp1);
|
6448
|
+
res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
|
6449
|
+
if (!SWIG_IsOK(res2)) {
|
6450
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","memcached_server_add_unix_socket", 2, argv[1] ));
|
6451
|
+
}
|
6452
|
+
arg2 = (char *)(buf2);
|
6453
|
+
result = (memcached_return)memcached_server_add_unix_socket(arg1,(char const *)arg2);
|
5959
6454
|
vresult = SWIG_From_int((int)(result));
|
6455
|
+
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
|
5960
6456
|
return vresult;
|
5961
6457
|
fail:
|
6458
|
+
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
|
5962
6459
|
return Qnil;
|
5963
6460
|
}
|
5964
6461
|
|
5965
6462
|
|
5966
6463
|
SWIGINTERN VALUE
|
5967
|
-
|
6464
|
+
_wrap_memcached_server_add(int argc, VALUE *argv, VALUE self) {
|
5968
6465
|
memcached_st *arg1 = (memcached_st *) 0 ;
|
5969
|
-
|
6466
|
+
char *arg2 = (char *) 0 ;
|
6467
|
+
unsigned int arg3 ;
|
5970
6468
|
void *argp1 = 0 ;
|
5971
6469
|
int res1 = 0 ;
|
5972
|
-
int
|
5973
|
-
|
5974
|
-
|
6470
|
+
int res2 ;
|
6471
|
+
char *buf2 = 0 ;
|
6472
|
+
int alloc2 = 0 ;
|
6473
|
+
unsigned int val3 ;
|
6474
|
+
int ecode3 = 0 ;
|
6475
|
+
memcached_return result;
|
5975
6476
|
VALUE vresult = Qnil;
|
5976
6477
|
|
5977
|
-
if ((argc <
|
5978
|
-
rb_raise(rb_eArgError, "wrong # of arguments(%d for
|
6478
|
+
if ((argc < 3) || (argc > 3)) {
|
6479
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
|
5979
6480
|
}
|
5980
6481
|
res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 | 0 );
|
5981
6482
|
if (!SWIG_IsOK(res1)) {
|
5982
|
-
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","
|
6483
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_server_add", 1, argv[0] ));
|
5983
6484
|
}
|
5984
6485
|
arg1 = (memcached_st *)(argp1);
|
5985
|
-
|
5986
|
-
if (!SWIG_IsOK(
|
5987
|
-
SWIG_exception_fail(SWIG_ArgError(
|
5988
|
-
}
|
5989
|
-
arg2 = (memcached_behavior)(val2);
|
5990
|
-
result = memcached_behavior_get(arg1,arg2);
|
5991
|
-
{
|
5992
|
-
vresult = INT2FIX(result);
|
6486
|
+
res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
|
6487
|
+
if (!SWIG_IsOK(res2)) {
|
6488
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","memcached_server_add", 2, argv[1] ));
|
5993
6489
|
}
|
6490
|
+
arg2 = (char *)(buf2);
|
6491
|
+
ecode3 = SWIG_AsVal_unsigned_SS_int(argv[2], &val3);
|
6492
|
+
if (!SWIG_IsOK(ecode3)) {
|
6493
|
+
SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","memcached_server_add", 3, argv[2] ));
|
6494
|
+
}
|
6495
|
+
arg3 = (unsigned int)(val3);
|
6496
|
+
result = (memcached_return)memcached_server_add(arg1,(char const *)arg2,arg3);
|
6497
|
+
vresult = SWIG_From_int((int)(result));
|
6498
|
+
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
|
5994
6499
|
return vresult;
|
5995
6500
|
fail:
|
6501
|
+
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
|
5996
6502
|
return Qnil;
|
5997
6503
|
}
|
5998
6504
|
|
5999
6505
|
|
6000
6506
|
SWIGINTERN VALUE
|
6001
|
-
|
6507
|
+
_wrap_memcached_server_add_udp_with_weight(int argc, VALUE *argv, VALUE self) {
|
6002
6508
|
memcached_st *arg1 = (memcached_st *) 0 ;
|
6003
6509
|
char *arg2 = (char *) 0 ;
|
6004
6510
|
unsigned int arg3 ;
|
6511
|
+
uint32_t arg4 ;
|
6005
6512
|
void *argp1 = 0 ;
|
6006
6513
|
int res1 = 0 ;
|
6007
6514
|
int res2 ;
|
@@ -6009,28 +6516,35 @@ _wrap_memcached_server_add_udp(int argc, VALUE *argv, VALUE self) {
|
|
6009
6516
|
int alloc2 = 0 ;
|
6010
6517
|
unsigned int val3 ;
|
6011
6518
|
int ecode3 = 0 ;
|
6519
|
+
unsigned long val4 ;
|
6520
|
+
int ecode4 = 0 ;
|
6012
6521
|
memcached_return result;
|
6013
6522
|
VALUE vresult = Qnil;
|
6014
6523
|
|
6015
|
-
if ((argc <
|
6016
|
-
rb_raise(rb_eArgError, "wrong # of arguments(%d for
|
6524
|
+
if ((argc < 4) || (argc > 4)) {
|
6525
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
|
6017
6526
|
}
|
6018
6527
|
res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 | 0 );
|
6019
6528
|
if (!SWIG_IsOK(res1)) {
|
6020
|
-
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","
|
6529
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_server_add_udp_with_weight", 1, argv[0] ));
|
6021
6530
|
}
|
6022
6531
|
arg1 = (memcached_st *)(argp1);
|
6023
6532
|
res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
|
6024
6533
|
if (!SWIG_IsOK(res2)) {
|
6025
|
-
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","
|
6534
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","memcached_server_add_udp_with_weight", 2, argv[1] ));
|
6026
6535
|
}
|
6027
6536
|
arg2 = (char *)(buf2);
|
6028
6537
|
ecode3 = SWIG_AsVal_unsigned_SS_int(argv[2], &val3);
|
6029
6538
|
if (!SWIG_IsOK(ecode3)) {
|
6030
|
-
SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","
|
6539
|
+
SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","memcached_server_add_udp_with_weight", 3, argv[2] ));
|
6031
6540
|
}
|
6032
6541
|
arg3 = (unsigned int)(val3);
|
6033
|
-
|
6542
|
+
ecode4 = SWIG_AsVal_unsigned_SS_long(argv[3], &val4);
|
6543
|
+
if (!SWIG_IsOK(ecode4)) {
|
6544
|
+
SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "uint32_t","memcached_server_add_udp_with_weight", 4, argv[3] ));
|
6545
|
+
}
|
6546
|
+
arg4 = (uint32_t)(val4);
|
6547
|
+
result = (memcached_return)memcached_server_add_udp_with_weight(arg1,(char const *)arg2,arg3,arg4);
|
6034
6548
|
vresult = SWIG_From_int((int)(result));
|
6035
6549
|
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
|
6036
6550
|
return vresult;
|
@@ -6041,31 +6555,39 @@ fail:
|
|
6041
6555
|
|
6042
6556
|
|
6043
6557
|
SWIGINTERN VALUE
|
6044
|
-
|
6558
|
+
_wrap_memcached_server_add_unix_socket_with_weight(int argc, VALUE *argv, VALUE self) {
|
6045
6559
|
memcached_st *arg1 = (memcached_st *) 0 ;
|
6046
6560
|
char *arg2 = (char *) 0 ;
|
6561
|
+
uint32_t arg3 ;
|
6047
6562
|
void *argp1 = 0 ;
|
6048
6563
|
int res1 = 0 ;
|
6049
6564
|
int res2 ;
|
6050
6565
|
char *buf2 = 0 ;
|
6051
6566
|
int alloc2 = 0 ;
|
6567
|
+
unsigned long val3 ;
|
6568
|
+
int ecode3 = 0 ;
|
6052
6569
|
memcached_return result;
|
6053
6570
|
VALUE vresult = Qnil;
|
6054
6571
|
|
6055
|
-
if ((argc <
|
6056
|
-
rb_raise(rb_eArgError, "wrong # of arguments(%d for
|
6572
|
+
if ((argc < 3) || (argc > 3)) {
|
6573
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
|
6057
6574
|
}
|
6058
6575
|
res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 | 0 );
|
6059
6576
|
if (!SWIG_IsOK(res1)) {
|
6060
|
-
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","
|
6577
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_server_add_unix_socket_with_weight", 1, argv[0] ));
|
6061
6578
|
}
|
6062
6579
|
arg1 = (memcached_st *)(argp1);
|
6063
6580
|
res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
|
6064
6581
|
if (!SWIG_IsOK(res2)) {
|
6065
|
-
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","
|
6582
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","memcached_server_add_unix_socket_with_weight", 2, argv[1] ));
|
6066
6583
|
}
|
6067
6584
|
arg2 = (char *)(buf2);
|
6068
|
-
|
6585
|
+
ecode3 = SWIG_AsVal_unsigned_SS_long(argv[2], &val3);
|
6586
|
+
if (!SWIG_IsOK(ecode3)) {
|
6587
|
+
SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "uint32_t","memcached_server_add_unix_socket_with_weight", 3, argv[2] ));
|
6588
|
+
}
|
6589
|
+
arg3 = (uint32_t)(val3);
|
6590
|
+
result = (memcached_return)memcached_server_add_unix_socket_with_weight(arg1,(char const *)arg2,arg3);
|
6069
6591
|
vresult = SWIG_From_int((int)(result));
|
6070
6592
|
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
|
6071
6593
|
return vresult;
|
@@ -6076,10 +6598,11 @@ fail:
|
|
6076
6598
|
|
6077
6599
|
|
6078
6600
|
SWIGINTERN VALUE
|
6079
|
-
|
6601
|
+
_wrap_memcached_server_add_with_weight(int argc, VALUE *argv, VALUE self) {
|
6080
6602
|
memcached_st *arg1 = (memcached_st *) 0 ;
|
6081
6603
|
char *arg2 = (char *) 0 ;
|
6082
6604
|
unsigned int arg3 ;
|
6605
|
+
uint32_t arg4 ;
|
6083
6606
|
void *argp1 = 0 ;
|
6084
6607
|
int res1 = 0 ;
|
6085
6608
|
int res2 ;
|
@@ -6087,28 +6610,35 @@ _wrap_memcached_server_add(int argc, VALUE *argv, VALUE self) {
|
|
6087
6610
|
int alloc2 = 0 ;
|
6088
6611
|
unsigned int val3 ;
|
6089
6612
|
int ecode3 = 0 ;
|
6613
|
+
unsigned long val4 ;
|
6614
|
+
int ecode4 = 0 ;
|
6090
6615
|
memcached_return result;
|
6091
6616
|
VALUE vresult = Qnil;
|
6092
6617
|
|
6093
|
-
if ((argc <
|
6094
|
-
rb_raise(rb_eArgError, "wrong # of arguments(%d for
|
6618
|
+
if ((argc < 4) || (argc > 4)) {
|
6619
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
|
6095
6620
|
}
|
6096
6621
|
res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 | 0 );
|
6097
6622
|
if (!SWIG_IsOK(res1)) {
|
6098
|
-
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","
|
6623
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_server_add_with_weight", 1, argv[0] ));
|
6099
6624
|
}
|
6100
6625
|
arg1 = (memcached_st *)(argp1);
|
6101
6626
|
res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
|
6102
6627
|
if (!SWIG_IsOK(res2)) {
|
6103
|
-
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","
|
6628
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","memcached_server_add_with_weight", 2, argv[1] ));
|
6104
6629
|
}
|
6105
6630
|
arg2 = (char *)(buf2);
|
6106
6631
|
ecode3 = SWIG_AsVal_unsigned_SS_int(argv[2], &val3);
|
6107
6632
|
if (!SWIG_IsOK(ecode3)) {
|
6108
|
-
SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","
|
6633
|
+
SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","memcached_server_add_with_weight", 3, argv[2] ));
|
6109
6634
|
}
|
6110
6635
|
arg3 = (unsigned int)(val3);
|
6111
|
-
|
6636
|
+
ecode4 = SWIG_AsVal_unsigned_SS_long(argv[3], &val4);
|
6637
|
+
if (!SWIG_IsOK(ecode4)) {
|
6638
|
+
SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "uint32_t","memcached_server_add_with_weight", 4, argv[3] ));
|
6639
|
+
}
|
6640
|
+
arg4 = (uint32_t)(val4);
|
6641
|
+
result = (memcached_return)memcached_server_add_with_weight(arg1,(char const *)arg2,arg3,arg4);
|
6112
6642
|
vresult = SWIG_From_int((int)(result));
|
6113
6643
|
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
|
6114
6644
|
return vresult;
|
@@ -6200,7 +6730,7 @@ _wrap_memcached_server_list_append(int argc, VALUE *argv, VALUE self) {
|
|
6200
6730
|
arg1 = (memcached_server_st *)(argp1);
|
6201
6731
|
res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
|
6202
6732
|
if (!SWIG_IsOK(res2)) {
|
6203
|
-
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","memcached_server_list_append", 2, argv[1] ));
|
6733
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","memcached_server_list_append", 2, argv[1] ));
|
6204
6734
|
}
|
6205
6735
|
arg2 = (char *)(buf2);
|
6206
6736
|
ecode3 = SWIG_AsVal_unsigned_SS_int(argv[2], &val3);
|
@@ -6208,7 +6738,7 @@ _wrap_memcached_server_list_append(int argc, VALUE *argv, VALUE self) {
|
|
6208
6738
|
SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","memcached_server_list_append", 3, argv[2] ));
|
6209
6739
|
}
|
6210
6740
|
arg3 = (unsigned int)(val3);
|
6211
|
-
result = (memcached_server_st *)memcached_server_list_append(arg1,arg2,arg3,arg4);
|
6741
|
+
result = (memcached_server_st *)memcached_server_list_append(arg1,(char const *)arg2,arg3,arg4);
|
6212
6742
|
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_memcached_server_st, 0 | 0 );
|
6213
6743
|
if (SWIG_IsTmpObj(res4)) {
|
6214
6744
|
vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_short((*arg4)));
|
@@ -6224,6 +6754,67 @@ fail:
|
|
6224
6754
|
}
|
6225
6755
|
|
6226
6756
|
|
6757
|
+
SWIGINTERN VALUE
|
6758
|
+
_wrap_memcached_server_list_append_with_weight(int argc, VALUE *argv, VALUE self) {
|
6759
|
+
memcached_server_st *arg1 = (memcached_server_st *) 0 ;
|
6760
|
+
char *arg2 = (char *) 0 ;
|
6761
|
+
unsigned int arg3 ;
|
6762
|
+
uint32_t arg4 ;
|
6763
|
+
memcached_return *arg5 = (memcached_return *) 0 ;
|
6764
|
+
void *argp1 = 0 ;
|
6765
|
+
int res1 = 0 ;
|
6766
|
+
int res2 ;
|
6767
|
+
char *buf2 = 0 ;
|
6768
|
+
int alloc2 = 0 ;
|
6769
|
+
unsigned int val3 ;
|
6770
|
+
int ecode3 = 0 ;
|
6771
|
+
unsigned long val4 ;
|
6772
|
+
int ecode4 = 0 ;
|
6773
|
+
memcached_return temp5 ;
|
6774
|
+
int res5 = SWIG_TMPOBJ ;
|
6775
|
+
memcached_server_st *result = 0 ;
|
6776
|
+
VALUE vresult = Qnil;
|
6777
|
+
|
6778
|
+
arg5 = &temp5;
|
6779
|
+
if ((argc < 4) || (argc > 4)) {
|
6780
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
|
6781
|
+
}
|
6782
|
+
res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_server_st, 0 | 0 );
|
6783
|
+
if (!SWIG_IsOK(res1)) {
|
6784
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_server_st *","memcached_server_list_append_with_weight", 1, argv[0] ));
|
6785
|
+
}
|
6786
|
+
arg1 = (memcached_server_st *)(argp1);
|
6787
|
+
res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
|
6788
|
+
if (!SWIG_IsOK(res2)) {
|
6789
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","memcached_server_list_append_with_weight", 2, argv[1] ));
|
6790
|
+
}
|
6791
|
+
arg2 = (char *)(buf2);
|
6792
|
+
ecode3 = SWIG_AsVal_unsigned_SS_int(argv[2], &val3);
|
6793
|
+
if (!SWIG_IsOK(ecode3)) {
|
6794
|
+
SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","memcached_server_list_append_with_weight", 3, argv[2] ));
|
6795
|
+
}
|
6796
|
+
arg3 = (unsigned int)(val3);
|
6797
|
+
ecode4 = SWIG_AsVal_unsigned_SS_long(argv[3], &val4);
|
6798
|
+
if (!SWIG_IsOK(ecode4)) {
|
6799
|
+
SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "uint32_t","memcached_server_list_append_with_weight", 4, argv[3] ));
|
6800
|
+
}
|
6801
|
+
arg4 = (uint32_t)(val4);
|
6802
|
+
result = (memcached_server_st *)memcached_server_list_append_with_weight(arg1,(char const *)arg2,arg3,arg4,arg5);
|
6803
|
+
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_memcached_server_st, 0 | 0 );
|
6804
|
+
if (SWIG_IsTmpObj(res5)) {
|
6805
|
+
vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_short((*arg5)));
|
6806
|
+
} else {
|
6807
|
+
int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
|
6808
|
+
vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_memcached_return, new_flags));
|
6809
|
+
}
|
6810
|
+
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
|
6811
|
+
return vresult;
|
6812
|
+
fail:
|
6813
|
+
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
|
6814
|
+
return Qnil;
|
6815
|
+
}
|
6816
|
+
|
6817
|
+
|
6227
6818
|
SWIGINTERN VALUE
|
6228
6819
|
_wrap_memcached_server_list_count(int argc, VALUE *argv, VALUE self) {
|
6229
6820
|
memcached_server_st *arg1 = (memcached_server_st *) 0 ;
|
@@ -6543,52 +7134,6 @@ fail:
|
|
6543
7134
|
}
|
6544
7135
|
|
6545
7136
|
|
6546
|
-
SWIGINTERN VALUE
|
6547
|
-
_wrap_memcached_server_cursor(int argc, VALUE *argv, VALUE self) {
|
6548
|
-
memcached_st *arg1 = (memcached_st *) 0 ;
|
6549
|
-
memcached_server_function *arg2 = (memcached_server_function *) 0 ;
|
6550
|
-
void *arg3 = (void *) 0 ;
|
6551
|
-
unsigned int arg4 ;
|
6552
|
-
void *argp1 = 0 ;
|
6553
|
-
int res1 = 0 ;
|
6554
|
-
void *argp2 = 0 ;
|
6555
|
-
int res2 = 0 ;
|
6556
|
-
int res3 ;
|
6557
|
-
unsigned int val4 ;
|
6558
|
-
int ecode4 = 0 ;
|
6559
|
-
memcached_return result;
|
6560
|
-
VALUE vresult = Qnil;
|
6561
|
-
|
6562
|
-
if ((argc < 4) || (argc > 4)) {
|
6563
|
-
rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
|
6564
|
-
}
|
6565
|
-
res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 | 0 );
|
6566
|
-
if (!SWIG_IsOK(res1)) {
|
6567
|
-
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_server_cursor", 1, argv[0] ));
|
6568
|
-
}
|
6569
|
-
arg1 = (memcached_st *)(argp1);
|
6570
|
-
res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_memcached_server_function, 0 | 0 );
|
6571
|
-
if (!SWIG_IsOK(res2)) {
|
6572
|
-
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "memcached_server_function *","memcached_server_cursor", 2, argv[1] ));
|
6573
|
-
}
|
6574
|
-
arg2 = (memcached_server_function *)(argp2);
|
6575
|
-
res3 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg3), 0, 0);
|
6576
|
-
if (!SWIG_IsOK(res3)) {
|
6577
|
-
SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "void *","memcached_server_cursor", 3, argv[2] ));
|
6578
|
-
}
|
6579
|
-
ecode4 = SWIG_AsVal_unsigned_SS_int(argv[3], &val4);
|
6580
|
-
if (!SWIG_IsOK(ecode4)) {
|
6581
|
-
SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "unsigned int","memcached_server_cursor", 4, argv[3] ));
|
6582
|
-
}
|
6583
|
-
arg4 = (unsigned int)(val4);
|
6584
|
-
result = (memcached_return)memcached_server_cursor(arg1,arg2,arg3,arg4);
|
6585
|
-
vresult = SWIG_From_int((int)(result));
|
6586
|
-
return vresult;
|
6587
|
-
fail:
|
6588
|
-
return Qnil;
|
6589
|
-
}
|
6590
|
-
|
6591
|
-
|
6592
7137
|
SWIGINTERN VALUE
|
6593
7138
|
_wrap_memcached_get(int argc, VALUE *argv, VALUE self) {
|
6594
7139
|
memcached_st *arg1 = (memcached_st *) 0 ;
|
@@ -8170,50 +8715,103 @@ fail:
|
|
8170
8715
|
|
8171
8716
|
|
8172
8717
|
SWIGINTERN VALUE
|
8173
|
-
_wrap_memcached_result_set_value(int argc, VALUE *argv, VALUE self) {
|
8174
|
-
memcached_result_st *arg1 = (memcached_result_st *) 0 ;
|
8175
|
-
char *arg2 = (char *) 0 ;
|
8176
|
-
size_t arg3 ;
|
8718
|
+
_wrap_memcached_result_set_value(int argc, VALUE *argv, VALUE self) {
|
8719
|
+
memcached_result_st *arg1 = (memcached_result_st *) 0 ;
|
8720
|
+
char *arg2 = (char *) 0 ;
|
8721
|
+
size_t arg3 ;
|
8722
|
+
void *argp1 = 0 ;
|
8723
|
+
int res1 = 0 ;
|
8724
|
+
int res2 ;
|
8725
|
+
char *buf2 = 0 ;
|
8726
|
+
int alloc2 = 0 ;
|
8727
|
+
size_t val3 ;
|
8728
|
+
int ecode3 = 0 ;
|
8729
|
+
memcached_return result;
|
8730
|
+
VALUE vresult = Qnil;
|
8731
|
+
|
8732
|
+
if ((argc < 3) || (argc > 3)) {
|
8733
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
|
8734
|
+
}
|
8735
|
+
res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_result_st, 0 | 0 );
|
8736
|
+
if (!SWIG_IsOK(res1)) {
|
8737
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_result_st *","memcached_result_set_value", 1, argv[0] ));
|
8738
|
+
}
|
8739
|
+
arg1 = (memcached_result_st *)(argp1);
|
8740
|
+
res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
|
8741
|
+
if (!SWIG_IsOK(res2)) {
|
8742
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","memcached_result_set_value", 2, argv[1] ));
|
8743
|
+
}
|
8744
|
+
arg2 = (char *)(buf2);
|
8745
|
+
ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
|
8746
|
+
if (!SWIG_IsOK(ecode3)) {
|
8747
|
+
SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","memcached_result_set_value", 3, argv[2] ));
|
8748
|
+
}
|
8749
|
+
arg3 = (size_t)(val3);
|
8750
|
+
result = (memcached_return)memcached_result_set_value(arg1,arg2,arg3);
|
8751
|
+
vresult = SWIG_From_int((int)(result));
|
8752
|
+
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
|
8753
|
+
return vresult;
|
8754
|
+
fail:
|
8755
|
+
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
|
8756
|
+
return Qnil;
|
8757
|
+
}
|
8758
|
+
|
8759
|
+
|
8760
|
+
swig_class cMemcachedServerSt;
|
8761
|
+
|
8762
|
+
SWIGINTERN VALUE
|
8763
|
+
_wrap_MemcachedServerSt_is_allocated_set(int argc, VALUE *argv, VALUE self) {
|
8764
|
+
struct memcached_server_st *arg1 = (struct memcached_server_st *) 0 ;
|
8765
|
+
memcached_allocated arg2 ;
|
8766
|
+
void *argp1 = 0 ;
|
8767
|
+
int res1 = 0 ;
|
8768
|
+
int val2 ;
|
8769
|
+
int ecode2 = 0 ;
|
8770
|
+
|
8771
|
+
if ((argc < 1) || (argc > 1)) {
|
8772
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
8773
|
+
}
|
8774
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_server_st, 0 | 0 );
|
8775
|
+
if (!SWIG_IsOK(res1)) {
|
8776
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_server_st *","is_allocated", 1, self ));
|
8777
|
+
}
|
8778
|
+
arg1 = (struct memcached_server_st *)(argp1);
|
8779
|
+
ecode2 = SWIG_AsVal_int(argv[0], &val2);
|
8780
|
+
if (!SWIG_IsOK(ecode2)) {
|
8781
|
+
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "memcached_allocated","is_allocated", 2, argv[0] ));
|
8782
|
+
}
|
8783
|
+
arg2 = (memcached_allocated)(val2);
|
8784
|
+
if (arg1) (arg1)->is_allocated = arg2;
|
8785
|
+
return Qnil;
|
8786
|
+
fail:
|
8787
|
+
return Qnil;
|
8788
|
+
}
|
8789
|
+
|
8790
|
+
|
8791
|
+
SWIGINTERN VALUE
|
8792
|
+
_wrap_MemcachedServerSt_is_allocated_get(int argc, VALUE *argv, VALUE self) {
|
8793
|
+
struct memcached_server_st *arg1 = (struct memcached_server_st *) 0 ;
|
8177
8794
|
void *argp1 = 0 ;
|
8178
8795
|
int res1 = 0 ;
|
8179
|
-
|
8180
|
-
char *buf2 = 0 ;
|
8181
|
-
int alloc2 = 0 ;
|
8182
|
-
size_t val3 ;
|
8183
|
-
int ecode3 = 0 ;
|
8184
|
-
memcached_return result;
|
8796
|
+
memcached_allocated result;
|
8185
8797
|
VALUE vresult = Qnil;
|
8186
8798
|
|
8187
|
-
if ((argc <
|
8188
|
-
rb_raise(rb_eArgError, "wrong # of arguments(%d for
|
8799
|
+
if ((argc < 0) || (argc > 0)) {
|
8800
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
8189
8801
|
}
|
8190
|
-
res1 = SWIG_ConvertPtr(
|
8802
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_server_st, 0 | 0 );
|
8191
8803
|
if (!SWIG_IsOK(res1)) {
|
8192
|
-
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "
|
8193
|
-
}
|
8194
|
-
arg1 = (memcached_result_st *)(argp1);
|
8195
|
-
res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
|
8196
|
-
if (!SWIG_IsOK(res2)) {
|
8197
|
-
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","memcached_result_set_value", 2, argv[1] ));
|
8804
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_server_st *","is_allocated", 1, self ));
|
8198
8805
|
}
|
8199
|
-
|
8200
|
-
|
8201
|
-
if (!SWIG_IsOK(ecode3)) {
|
8202
|
-
SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","memcached_result_set_value", 3, argv[2] ));
|
8203
|
-
}
|
8204
|
-
arg3 = (size_t)(val3);
|
8205
|
-
result = (memcached_return)memcached_result_set_value(arg1,arg2,arg3);
|
8806
|
+
arg1 = (struct memcached_server_st *)(argp1);
|
8807
|
+
result = (memcached_allocated) ((arg1)->is_allocated);
|
8206
8808
|
vresult = SWIG_From_int((int)(result));
|
8207
|
-
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
|
8208
8809
|
return vresult;
|
8209
8810
|
fail:
|
8210
|
-
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
|
8211
8811
|
return Qnil;
|
8212
8812
|
}
|
8213
8813
|
|
8214
8814
|
|
8215
|
-
swig_class cMemcachedServerSt;
|
8216
|
-
|
8217
8815
|
SWIGINTERN VALUE
|
8218
8816
|
_wrap_MemcachedServerSt_hostname_set(int argc, VALUE *argv, VALUE self) {
|
8219
8817
|
struct memcached_server_st *arg1 = (struct memcached_server_st *) 0 ;
|
@@ -9122,11 +9720,230 @@ fail:
|
|
9122
9720
|
|
9123
9721
|
|
9124
9722
|
SWIGINTERN VALUE
|
9125
|
-
_wrap_MemcachedServerSt_micro_version_get(int argc, VALUE *argv, VALUE self) {
|
9723
|
+
_wrap_MemcachedServerSt_micro_version_get(int argc, VALUE *argv, VALUE self) {
|
9724
|
+
struct memcached_server_st *arg1 = (struct memcached_server_st *) 0 ;
|
9725
|
+
void *argp1 = 0 ;
|
9726
|
+
int res1 = 0 ;
|
9727
|
+
uint8_t result;
|
9728
|
+
VALUE vresult = Qnil;
|
9729
|
+
|
9730
|
+
if ((argc < 0) || (argc > 0)) {
|
9731
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
9732
|
+
}
|
9733
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_server_st, 0 | 0 );
|
9734
|
+
if (!SWIG_IsOK(res1)) {
|
9735
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_server_st *","micro_version", 1, self ));
|
9736
|
+
}
|
9737
|
+
arg1 = (struct memcached_server_st *)(argp1);
|
9738
|
+
result = ((arg1)->micro_version);
|
9739
|
+
vresult = SWIG_From_unsigned_SS_short((unsigned short)(result));
|
9740
|
+
return vresult;
|
9741
|
+
fail:
|
9742
|
+
return Qnil;
|
9743
|
+
}
|
9744
|
+
|
9745
|
+
|
9746
|
+
SWIGINTERN VALUE
|
9747
|
+
_wrap_MemcachedServerSt_count_set(int argc, VALUE *argv, VALUE self) {
|
9748
|
+
struct memcached_server_st *arg1 = (struct memcached_server_st *) 0 ;
|
9749
|
+
uint16_t arg2 ;
|
9750
|
+
void *argp1 = 0 ;
|
9751
|
+
int res1 = 0 ;
|
9752
|
+
unsigned int val2 ;
|
9753
|
+
int ecode2 = 0 ;
|
9754
|
+
|
9755
|
+
if ((argc < 1) || (argc > 1)) {
|
9756
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
9757
|
+
}
|
9758
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_server_st, 0 | 0 );
|
9759
|
+
if (!SWIG_IsOK(res1)) {
|
9760
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_server_st *","count", 1, self ));
|
9761
|
+
}
|
9762
|
+
arg1 = (struct memcached_server_st *)(argp1);
|
9763
|
+
ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
|
9764
|
+
if (!SWIG_IsOK(ecode2)) {
|
9765
|
+
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "uint16_t","count", 2, argv[0] ));
|
9766
|
+
}
|
9767
|
+
arg2 = (uint16_t)(val2);
|
9768
|
+
if (arg1) (arg1)->count = arg2;
|
9769
|
+
return Qnil;
|
9770
|
+
fail:
|
9771
|
+
return Qnil;
|
9772
|
+
}
|
9773
|
+
|
9774
|
+
|
9775
|
+
SWIGINTERN VALUE
|
9776
|
+
_wrap_MemcachedServerSt_count_get(int argc, VALUE *argv, VALUE self) {
|
9777
|
+
struct memcached_server_st *arg1 = (struct memcached_server_st *) 0 ;
|
9778
|
+
void *argp1 = 0 ;
|
9779
|
+
int res1 = 0 ;
|
9780
|
+
uint16_t result;
|
9781
|
+
VALUE vresult = Qnil;
|
9782
|
+
|
9783
|
+
if ((argc < 0) || (argc > 0)) {
|
9784
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
9785
|
+
}
|
9786
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_server_st, 0 | 0 );
|
9787
|
+
if (!SWIG_IsOK(res1)) {
|
9788
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_server_st *","count", 1, self ));
|
9789
|
+
}
|
9790
|
+
arg1 = (struct memcached_server_st *)(argp1);
|
9791
|
+
result = ((arg1)->count);
|
9792
|
+
vresult = SWIG_From_unsigned_SS_int((unsigned int)(result));
|
9793
|
+
return vresult;
|
9794
|
+
fail:
|
9795
|
+
return Qnil;
|
9796
|
+
}
|
9797
|
+
|
9798
|
+
|
9799
|
+
SWIGINTERN VALUE
|
9800
|
+
_wrap_MemcachedServerSt_next_retry_set(int argc, VALUE *argv, VALUE self) {
|
9801
|
+
struct memcached_server_st *arg1 = (struct memcached_server_st *) 0 ;
|
9802
|
+
time_t arg2 ;
|
9803
|
+
void *argp1 = 0 ;
|
9804
|
+
int res1 = 0 ;
|
9805
|
+
|
9806
|
+
if ((argc < 1) || (argc > 1)) {
|
9807
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
9808
|
+
}
|
9809
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_server_st, 0 | 0 );
|
9810
|
+
if (!SWIG_IsOK(res1)) {
|
9811
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_server_st *","next_retry", 1, self ));
|
9812
|
+
}
|
9813
|
+
arg1 = (struct memcached_server_st *)(argp1);
|
9814
|
+
{
|
9815
|
+
if (NIL_P(argv[0]))
|
9816
|
+
arg2 = (time_t)-1;
|
9817
|
+
else
|
9818
|
+
arg2 = NUM2LONG(rb_funcall(argv[0], rb_intern("tv_sec"), 0));
|
9819
|
+
}
|
9820
|
+
if (arg1) (arg1)->next_retry = arg2;
|
9821
|
+
return Qnil;
|
9822
|
+
fail:
|
9823
|
+
return Qnil;
|
9824
|
+
}
|
9825
|
+
|
9826
|
+
|
9827
|
+
SWIGINTERN VALUE
|
9828
|
+
_wrap_MemcachedServerSt_next_retry_get(int argc, VALUE *argv, VALUE self) {
|
9829
|
+
struct memcached_server_st *arg1 = (struct memcached_server_st *) 0 ;
|
9830
|
+
void *argp1 = 0 ;
|
9831
|
+
int res1 = 0 ;
|
9832
|
+
time_t result;
|
9833
|
+
VALUE vresult = Qnil;
|
9834
|
+
|
9835
|
+
if ((argc < 0) || (argc > 0)) {
|
9836
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
9837
|
+
}
|
9838
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_server_st, 0 | 0 );
|
9839
|
+
if (!SWIG_IsOK(res1)) {
|
9840
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_server_st *","next_retry", 1, self ));
|
9841
|
+
}
|
9842
|
+
arg1 = (struct memcached_server_st *)(argp1);
|
9843
|
+
result = ((arg1)->next_retry);
|
9844
|
+
{
|
9845
|
+
vresult = rb_time_new(result, 0);
|
9846
|
+
}
|
9847
|
+
return vresult;
|
9848
|
+
fail:
|
9849
|
+
return Qnil;
|
9850
|
+
}
|
9851
|
+
|
9852
|
+
|
9853
|
+
SWIGINTERN VALUE
|
9854
|
+
_wrap_MemcachedServerSt_root_set(int argc, VALUE *argv, VALUE self) {
|
9855
|
+
struct memcached_server_st *arg1 = (struct memcached_server_st *) 0 ;
|
9856
|
+
memcached_st *arg2 = (memcached_st *) 0 ;
|
9857
|
+
void *argp1 = 0 ;
|
9858
|
+
int res1 = 0 ;
|
9859
|
+
void *argp2 = 0 ;
|
9860
|
+
int res2 = 0 ;
|
9861
|
+
|
9862
|
+
if ((argc < 1) || (argc > 1)) {
|
9863
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
9864
|
+
}
|
9865
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_server_st, 0 | 0 );
|
9866
|
+
if (!SWIG_IsOK(res1)) {
|
9867
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_server_st *","root", 1, self ));
|
9868
|
+
}
|
9869
|
+
arg1 = (struct memcached_server_st *)(argp1);
|
9870
|
+
res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_memcached_st, SWIG_POINTER_DISOWN | 0 );
|
9871
|
+
if (!SWIG_IsOK(res2)) {
|
9872
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "memcached_st *","root", 2, argv[0] ));
|
9873
|
+
}
|
9874
|
+
arg2 = (memcached_st *)(argp2);
|
9875
|
+
if (arg1) (arg1)->root = arg2;
|
9876
|
+
return Qnil;
|
9877
|
+
fail:
|
9878
|
+
return Qnil;
|
9879
|
+
}
|
9880
|
+
|
9881
|
+
|
9882
|
+
SWIGINTERN VALUE
|
9883
|
+
_wrap_MemcachedServerSt_root_get(int argc, VALUE *argv, VALUE self) {
|
9884
|
+
struct memcached_server_st *arg1 = (struct memcached_server_st *) 0 ;
|
9885
|
+
void *argp1 = 0 ;
|
9886
|
+
int res1 = 0 ;
|
9887
|
+
memcached_st *result = 0 ;
|
9888
|
+
VALUE vresult = Qnil;
|
9889
|
+
|
9890
|
+
if ((argc < 0) || (argc > 0)) {
|
9891
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
9892
|
+
}
|
9893
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_server_st, 0 | 0 );
|
9894
|
+
if (!SWIG_IsOK(res1)) {
|
9895
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_server_st *","root", 1, self ));
|
9896
|
+
}
|
9897
|
+
arg1 = (struct memcached_server_st *)(argp1);
|
9898
|
+
result = (memcached_st *) ((arg1)->root);
|
9899
|
+
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_memcached_st, 0 | 0 );
|
9900
|
+
return vresult;
|
9901
|
+
fail:
|
9902
|
+
return Qnil;
|
9903
|
+
}
|
9904
|
+
|
9905
|
+
|
9906
|
+
SWIGINTERN VALUE
|
9907
|
+
_wrap_MemcachedServerSt_limit_maxbytes_set(int argc, VALUE *argv, VALUE self) {
|
9908
|
+
struct memcached_server_st *arg1 = (struct memcached_server_st *) 0 ;
|
9909
|
+
uint64_t arg2 ;
|
9910
|
+
void *argp1 = 0 ;
|
9911
|
+
int res1 = 0 ;
|
9912
|
+
void *argp2 ;
|
9913
|
+
int res2 = 0 ;
|
9914
|
+
|
9915
|
+
if ((argc < 1) || (argc > 1)) {
|
9916
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
9917
|
+
}
|
9918
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_server_st, 0 | 0 );
|
9919
|
+
if (!SWIG_IsOK(res1)) {
|
9920
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_server_st *","limit_maxbytes", 1, self ));
|
9921
|
+
}
|
9922
|
+
arg1 = (struct memcached_server_st *)(argp1);
|
9923
|
+
{
|
9924
|
+
res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_uint64_t, 0 );
|
9925
|
+
if (!SWIG_IsOK(res2)) {
|
9926
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "uint64_t","limit_maxbytes", 2, argv[0] ));
|
9927
|
+
}
|
9928
|
+
if (!argp2) {
|
9929
|
+
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "uint64_t","limit_maxbytes", 2, argv[0]));
|
9930
|
+
} else {
|
9931
|
+
arg2 = *((uint64_t *)(argp2));
|
9932
|
+
}
|
9933
|
+
}
|
9934
|
+
if (arg1) (arg1)->limit_maxbytes = arg2;
|
9935
|
+
return Qnil;
|
9936
|
+
fail:
|
9937
|
+
return Qnil;
|
9938
|
+
}
|
9939
|
+
|
9940
|
+
|
9941
|
+
SWIGINTERN VALUE
|
9942
|
+
_wrap_MemcachedServerSt_limit_maxbytes_get(int argc, VALUE *argv, VALUE self) {
|
9126
9943
|
struct memcached_server_st *arg1 = (struct memcached_server_st *) 0 ;
|
9127
9944
|
void *argp1 = 0 ;
|
9128
9945
|
int res1 = 0 ;
|
9129
|
-
|
9946
|
+
uint64_t result;
|
9130
9947
|
VALUE vresult = Qnil;
|
9131
9948
|
|
9132
9949
|
if ((argc < 0) || (argc > 0)) {
|
@@ -9134,11 +9951,13 @@ _wrap_MemcachedServerSt_micro_version_get(int argc, VALUE *argv, VALUE self) {
|
|
9134
9951
|
}
|
9135
9952
|
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_server_st, 0 | 0 );
|
9136
9953
|
if (!SWIG_IsOK(res1)) {
|
9137
|
-
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_server_st *","
|
9954
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_server_st *","limit_maxbytes", 1, self ));
|
9138
9955
|
}
|
9139
9956
|
arg1 = (struct memcached_server_st *)(argp1);
|
9140
|
-
result = ((arg1)->
|
9141
|
-
|
9957
|
+
result = ((arg1)->limit_maxbytes);
|
9958
|
+
{
|
9959
|
+
vresult = INT2FIX(result);
|
9960
|
+
}
|
9142
9961
|
return vresult;
|
9143
9962
|
fail:
|
9144
9963
|
return Qnil;
|
@@ -9146,28 +9965,34 @@ fail:
|
|
9146
9965
|
|
9147
9966
|
|
9148
9967
|
SWIGINTERN VALUE
|
9149
|
-
|
9968
|
+
_wrap_MemcachedServerSt_server_failure_counter_set(int argc, VALUE *argv, VALUE self) {
|
9150
9969
|
struct memcached_server_st *arg1 = (struct memcached_server_st *) 0 ;
|
9151
|
-
|
9970
|
+
uint32_t arg2 ;
|
9152
9971
|
void *argp1 = 0 ;
|
9153
9972
|
int res1 = 0 ;
|
9154
|
-
|
9155
|
-
int
|
9973
|
+
void *argp2 ;
|
9974
|
+
int res2 = 0 ;
|
9156
9975
|
|
9157
9976
|
if ((argc < 1) || (argc > 1)) {
|
9158
9977
|
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
9159
9978
|
}
|
9160
9979
|
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_server_st, 0 | 0 );
|
9161
9980
|
if (!SWIG_IsOK(res1)) {
|
9162
|
-
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_server_st *","
|
9981
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_server_st *","server_failure_counter", 1, self ));
|
9163
9982
|
}
|
9164
9983
|
arg1 = (struct memcached_server_st *)(argp1);
|
9165
|
-
|
9166
|
-
|
9167
|
-
|
9168
|
-
|
9169
|
-
|
9170
|
-
|
9984
|
+
{
|
9985
|
+
res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_uint32_t, 0 );
|
9986
|
+
if (!SWIG_IsOK(res2)) {
|
9987
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "uint32_t","server_failure_counter", 2, argv[0] ));
|
9988
|
+
}
|
9989
|
+
if (!argp2) {
|
9990
|
+
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "uint32_t","server_failure_counter", 2, argv[0]));
|
9991
|
+
} else {
|
9992
|
+
arg2 = *((uint32_t *)(argp2));
|
9993
|
+
}
|
9994
|
+
}
|
9995
|
+
if (arg1) (arg1)->server_failure_counter = arg2;
|
9171
9996
|
return Qnil;
|
9172
9997
|
fail:
|
9173
9998
|
return Qnil;
|
@@ -9175,11 +10000,11 @@ fail:
|
|
9175
10000
|
|
9176
10001
|
|
9177
10002
|
SWIGINTERN VALUE
|
9178
|
-
|
10003
|
+
_wrap_MemcachedServerSt_server_failure_counter_get(int argc, VALUE *argv, VALUE self) {
|
9179
10004
|
struct memcached_server_st *arg1 = (struct memcached_server_st *) 0 ;
|
9180
10005
|
void *argp1 = 0 ;
|
9181
10006
|
int res1 = 0 ;
|
9182
|
-
|
10007
|
+
uint32_t result;
|
9183
10008
|
VALUE vresult = Qnil;
|
9184
10009
|
|
9185
10010
|
if ((argc < 0) || (argc > 0)) {
|
@@ -9187,11 +10012,11 @@ _wrap_MemcachedServerSt_count_get(int argc, VALUE *argv, VALUE self) {
|
|
9187
10012
|
}
|
9188
10013
|
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_server_st, 0 | 0 );
|
9189
10014
|
if (!SWIG_IsOK(res1)) {
|
9190
|
-
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_server_st *","
|
10015
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_server_st *","server_failure_counter", 1, self ));
|
9191
10016
|
}
|
9192
10017
|
arg1 = (struct memcached_server_st *)(argp1);
|
9193
|
-
result = ((arg1)->
|
9194
|
-
vresult =
|
10018
|
+
result = ((arg1)->server_failure_counter);
|
10019
|
+
vresult = SWIG_NewPointerObj((uint32_t *)memcpy((uint32_t *)malloc(sizeof(uint32_t)),&result,sizeof(uint32_t)), SWIGTYPE_p_uint32_t, SWIG_POINTER_OWN | 0 );
|
9195
10020
|
return vresult;
|
9196
10021
|
fail:
|
9197
10022
|
return Qnil;
|
@@ -9199,27 +10024,34 @@ fail:
|
|
9199
10024
|
|
9200
10025
|
|
9201
10026
|
SWIGINTERN VALUE
|
9202
|
-
|
10027
|
+
_wrap_MemcachedServerSt_io_bytes_sent_set(int argc, VALUE *argv, VALUE self) {
|
9203
10028
|
struct memcached_server_st *arg1 = (struct memcached_server_st *) 0 ;
|
9204
|
-
|
10029
|
+
uint32_t arg2 ;
|
9205
10030
|
void *argp1 = 0 ;
|
9206
10031
|
int res1 = 0 ;
|
10032
|
+
void *argp2 ;
|
10033
|
+
int res2 = 0 ;
|
9207
10034
|
|
9208
10035
|
if ((argc < 1) || (argc > 1)) {
|
9209
10036
|
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
9210
10037
|
}
|
9211
10038
|
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_server_st, 0 | 0 );
|
9212
10039
|
if (!SWIG_IsOK(res1)) {
|
9213
|
-
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_server_st *","
|
10040
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_server_st *","io_bytes_sent", 1, self ));
|
9214
10041
|
}
|
9215
10042
|
arg1 = (struct memcached_server_st *)(argp1);
|
9216
10043
|
{
|
9217
|
-
|
9218
|
-
|
9219
|
-
|
9220
|
-
|
10044
|
+
res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_uint32_t, 0 );
|
10045
|
+
if (!SWIG_IsOK(res2)) {
|
10046
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "uint32_t","io_bytes_sent", 2, argv[0] ));
|
10047
|
+
}
|
10048
|
+
if (!argp2) {
|
10049
|
+
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "uint32_t","io_bytes_sent", 2, argv[0]));
|
10050
|
+
} else {
|
10051
|
+
arg2 = *((uint32_t *)(argp2));
|
10052
|
+
}
|
9221
10053
|
}
|
9222
|
-
if (arg1) (arg1)->
|
10054
|
+
if (arg1) (arg1)->io_bytes_sent = arg2;
|
9223
10055
|
return Qnil;
|
9224
10056
|
fail:
|
9225
10057
|
return Qnil;
|
@@ -9227,11 +10059,11 @@ fail:
|
|
9227
10059
|
|
9228
10060
|
|
9229
10061
|
SWIGINTERN VALUE
|
9230
|
-
|
10062
|
+
_wrap_MemcachedServerSt_io_bytes_sent_get(int argc, VALUE *argv, VALUE self) {
|
9231
10063
|
struct memcached_server_st *arg1 = (struct memcached_server_st *) 0 ;
|
9232
10064
|
void *argp1 = 0 ;
|
9233
10065
|
int res1 = 0 ;
|
9234
|
-
|
10066
|
+
uint32_t result;
|
9235
10067
|
VALUE vresult = Qnil;
|
9236
10068
|
|
9237
10069
|
if ((argc < 0) || (argc > 0)) {
|
@@ -9239,13 +10071,11 @@ _wrap_MemcachedServerSt_next_retry_get(int argc, VALUE *argv, VALUE self) {
|
|
9239
10071
|
}
|
9240
10072
|
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_server_st, 0 | 0 );
|
9241
10073
|
if (!SWIG_IsOK(res1)) {
|
9242
|
-
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_server_st *","
|
10074
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_server_st *","io_bytes_sent", 1, self ));
|
9243
10075
|
}
|
9244
10076
|
arg1 = (struct memcached_server_st *)(argp1);
|
9245
|
-
result = ((arg1)->
|
9246
|
-
|
9247
|
-
vresult = rb_time_new(result, 0);
|
9248
|
-
}
|
10077
|
+
result = ((arg1)->io_bytes_sent);
|
10078
|
+
vresult = SWIG_NewPointerObj((uint32_t *)memcpy((uint32_t *)malloc(sizeof(uint32_t)),&result,sizeof(uint32_t)), SWIGTYPE_p_uint32_t, SWIG_POINTER_OWN | 0 );
|
9249
10079
|
return vresult;
|
9250
10080
|
fail:
|
9251
10081
|
return Qnil;
|
@@ -9253,28 +10083,28 @@ fail:
|
|
9253
10083
|
|
9254
10084
|
|
9255
10085
|
SWIGINTERN VALUE
|
9256
|
-
|
10086
|
+
_wrap_MemcachedServerSt_weight_set(int argc, VALUE *argv, VALUE self) {
|
9257
10087
|
struct memcached_server_st *arg1 = (struct memcached_server_st *) 0 ;
|
9258
|
-
|
10088
|
+
uint32_t arg2 ;
|
9259
10089
|
void *argp1 = 0 ;
|
9260
10090
|
int res1 = 0 ;
|
9261
|
-
|
9262
|
-
int
|
10091
|
+
unsigned long val2 ;
|
10092
|
+
int ecode2 = 0 ;
|
9263
10093
|
|
9264
10094
|
if ((argc < 1) || (argc > 1)) {
|
9265
10095
|
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
9266
10096
|
}
|
9267
10097
|
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_server_st, 0 | 0 );
|
9268
10098
|
if (!SWIG_IsOK(res1)) {
|
9269
|
-
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_server_st *","
|
10099
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_server_st *","weight", 1, self ));
|
9270
10100
|
}
|
9271
10101
|
arg1 = (struct memcached_server_st *)(argp1);
|
9272
|
-
|
9273
|
-
if (!SWIG_IsOK(
|
9274
|
-
SWIG_exception_fail(SWIG_ArgError(
|
9275
|
-
}
|
9276
|
-
arg2 = (
|
9277
|
-
if (arg1) (arg1)->
|
10102
|
+
ecode2 = SWIG_AsVal_unsigned_SS_long(argv[0], &val2);
|
10103
|
+
if (!SWIG_IsOK(ecode2)) {
|
10104
|
+
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "uint32_t","weight", 2, argv[0] ));
|
10105
|
+
}
|
10106
|
+
arg2 = (uint32_t)(val2);
|
10107
|
+
if (arg1) (arg1)->weight = arg2;
|
9278
10108
|
return Qnil;
|
9279
10109
|
fail:
|
9280
10110
|
return Qnil;
|
@@ -9282,11 +10112,11 @@ fail:
|
|
9282
10112
|
|
9283
10113
|
|
9284
10114
|
SWIGINTERN VALUE
|
9285
|
-
|
10115
|
+
_wrap_MemcachedServerSt_weight_get(int argc, VALUE *argv, VALUE self) {
|
9286
10116
|
struct memcached_server_st *arg1 = (struct memcached_server_st *) 0 ;
|
9287
10117
|
void *argp1 = 0 ;
|
9288
10118
|
int res1 = 0 ;
|
9289
|
-
|
10119
|
+
uint32_t result;
|
9290
10120
|
VALUE vresult = Qnil;
|
9291
10121
|
|
9292
10122
|
if ((argc < 0) || (argc > 0)) {
|
@@ -9294,11 +10124,11 @@ _wrap_MemcachedServerSt_root_get(int argc, VALUE *argv, VALUE self) {
|
|
9294
10124
|
}
|
9295
10125
|
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_server_st, 0 | 0 );
|
9296
10126
|
if (!SWIG_IsOK(res1)) {
|
9297
|
-
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_server_st *","
|
10127
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_server_st *","weight", 1, self ));
|
9298
10128
|
}
|
9299
10129
|
arg1 = (struct memcached_server_st *)(argp1);
|
9300
|
-
result =
|
9301
|
-
vresult =
|
10130
|
+
result = ((arg1)->weight);
|
10131
|
+
vresult = SWIG_From_unsigned_SS_long((unsigned long)(result));
|
9302
10132
|
return vresult;
|
9303
10133
|
fail:
|
9304
10134
|
return Qnil;
|
@@ -9342,6 +10172,177 @@ free_memcached_server_st(struct memcached_server_st *arg1) {
|
|
9342
10172
|
free((char *) arg1);
|
9343
10173
|
}
|
9344
10174
|
|
10175
|
+
SWIGINTERN VALUE
|
10176
|
+
_wrap_memcached_server_cursor(int argc, VALUE *argv, VALUE self) {
|
10177
|
+
memcached_st *arg1 = (memcached_st *) 0 ;
|
10178
|
+
memcached_server_function *arg2 = (memcached_server_function *) 0 ;
|
10179
|
+
void *arg3 = (void *) 0 ;
|
10180
|
+
unsigned int arg4 ;
|
10181
|
+
void *argp1 = 0 ;
|
10182
|
+
int res1 = 0 ;
|
10183
|
+
void *argp2 = 0 ;
|
10184
|
+
int res2 = 0 ;
|
10185
|
+
int res3 ;
|
10186
|
+
unsigned int val4 ;
|
10187
|
+
int ecode4 = 0 ;
|
10188
|
+
memcached_return result;
|
10189
|
+
VALUE vresult = Qnil;
|
10190
|
+
|
10191
|
+
if ((argc < 4) || (argc > 4)) {
|
10192
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
|
10193
|
+
}
|
10194
|
+
res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 | 0 );
|
10195
|
+
if (!SWIG_IsOK(res1)) {
|
10196
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_server_cursor", 1, argv[0] ));
|
10197
|
+
}
|
10198
|
+
arg1 = (memcached_st *)(argp1);
|
10199
|
+
res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_memcached_server_function, 0 | 0 );
|
10200
|
+
if (!SWIG_IsOK(res2)) {
|
10201
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "memcached_server_function *","memcached_server_cursor", 2, argv[1] ));
|
10202
|
+
}
|
10203
|
+
arg2 = (memcached_server_function *)(argp2);
|
10204
|
+
res3 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg3), 0, 0);
|
10205
|
+
if (!SWIG_IsOK(res3)) {
|
10206
|
+
SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "void *","memcached_server_cursor", 3, argv[2] ));
|
10207
|
+
}
|
10208
|
+
ecode4 = SWIG_AsVal_unsigned_SS_int(argv[3], &val4);
|
10209
|
+
if (!SWIG_IsOK(ecode4)) {
|
10210
|
+
SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "unsigned int","memcached_server_cursor", 4, argv[3] ));
|
10211
|
+
}
|
10212
|
+
arg4 = (unsigned int)(val4);
|
10213
|
+
result = (memcached_return)memcached_server_cursor(arg1,arg2,arg3,arg4);
|
10214
|
+
vresult = SWIG_From_int((int)(result));
|
10215
|
+
return vresult;
|
10216
|
+
fail:
|
10217
|
+
return Qnil;
|
10218
|
+
}
|
10219
|
+
|
10220
|
+
|
10221
|
+
SWIGINTERN VALUE
|
10222
|
+
_wrap_memcached_server_by_key(int argc, VALUE *argv, VALUE self) {
|
10223
|
+
memcached_st *arg1 = (memcached_st *) 0 ;
|
10224
|
+
char *arg2 = (char *) 0 ;
|
10225
|
+
size_t arg3 ;
|
10226
|
+
memcached_return *arg4 = (memcached_return *) 0 ;
|
10227
|
+
void *argp1 = 0 ;
|
10228
|
+
int res1 = 0 ;
|
10229
|
+
memcached_return temp4 ;
|
10230
|
+
int res4 = SWIG_TMPOBJ ;
|
10231
|
+
memcached_server_st *result = 0 ;
|
10232
|
+
VALUE vresult = Qnil;
|
10233
|
+
|
10234
|
+
arg4 = &temp4;
|
10235
|
+
if ((argc < 2) || (argc > 2)) {
|
10236
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
|
10237
|
+
}
|
10238
|
+
res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 | 0 );
|
10239
|
+
if (!SWIG_IsOK(res1)) {
|
10240
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_server_by_key", 1, argv[0] ));
|
10241
|
+
}
|
10242
|
+
arg1 = (memcached_st *)(argp1);
|
10243
|
+
{
|
10244
|
+
arg2 = STR2CSTR(argv[1]);
|
10245
|
+
arg3 = (size_t) RSTRING(argv[1])->len;
|
10246
|
+
}
|
10247
|
+
result = (memcached_server_st *)memcached_server_by_key(arg1,(char const *)arg2,arg3,arg4);
|
10248
|
+
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_memcached_server_st, 0 | 0 );
|
10249
|
+
if (SWIG_IsTmpObj(res4)) {
|
10250
|
+
vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_short((*arg4)));
|
10251
|
+
} else {
|
10252
|
+
int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
|
10253
|
+
vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_memcached_return, new_flags));
|
10254
|
+
}
|
10255
|
+
return vresult;
|
10256
|
+
fail:
|
10257
|
+
return Qnil;
|
10258
|
+
}
|
10259
|
+
|
10260
|
+
|
10261
|
+
SWIGINTERN VALUE
|
10262
|
+
_wrap_memcached_server_create(int argc, VALUE *argv, VALUE self) {
|
10263
|
+
memcached_st *arg1 = (memcached_st *) 0 ;
|
10264
|
+
memcached_server_st *arg2 = (memcached_server_st *) 0 ;
|
10265
|
+
void *argp1 = 0 ;
|
10266
|
+
int res1 = 0 ;
|
10267
|
+
void *argp2 = 0 ;
|
10268
|
+
int res2 = 0 ;
|
10269
|
+
memcached_server_st *result = 0 ;
|
10270
|
+
VALUE vresult = Qnil;
|
10271
|
+
|
10272
|
+
if ((argc < 2) || (argc > 2)) {
|
10273
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
|
10274
|
+
}
|
10275
|
+
res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 | 0 );
|
10276
|
+
if (!SWIG_IsOK(res1)) {
|
10277
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_server_create", 1, argv[0] ));
|
10278
|
+
}
|
10279
|
+
arg1 = (memcached_st *)(argp1);
|
10280
|
+
res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_memcached_server_st, 0 | 0 );
|
10281
|
+
if (!SWIG_IsOK(res2)) {
|
10282
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "memcached_server_st *","memcached_server_create", 2, argv[1] ));
|
10283
|
+
}
|
10284
|
+
arg2 = (memcached_server_st *)(argp2);
|
10285
|
+
result = (memcached_server_st *)memcached_server_create(arg1,arg2);
|
10286
|
+
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_memcached_server_st, 0 | 0 );
|
10287
|
+
return vresult;
|
10288
|
+
fail:
|
10289
|
+
return Qnil;
|
10290
|
+
}
|
10291
|
+
|
10292
|
+
|
10293
|
+
SWIGINTERN VALUE
|
10294
|
+
_wrap_memcached_server_free(int argc, VALUE *argv, VALUE self) {
|
10295
|
+
memcached_server_st *arg1 = (memcached_server_st *) 0 ;
|
10296
|
+
void *argp1 = 0 ;
|
10297
|
+
int res1 = 0 ;
|
10298
|
+
|
10299
|
+
if ((argc < 1) || (argc > 1)) {
|
10300
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
10301
|
+
}
|
10302
|
+
res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_server_st, 0 | 0 );
|
10303
|
+
if (!SWIG_IsOK(res1)) {
|
10304
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_server_st *","memcached_server_free", 1, argv[0] ));
|
10305
|
+
}
|
10306
|
+
arg1 = (memcached_server_st *)(argp1);
|
10307
|
+
memcached_server_free(arg1);
|
10308
|
+
return Qnil;
|
10309
|
+
fail:
|
10310
|
+
return Qnil;
|
10311
|
+
}
|
10312
|
+
|
10313
|
+
|
10314
|
+
SWIGINTERN VALUE
|
10315
|
+
_wrap_memcached_server_clone(int argc, VALUE *argv, VALUE self) {
|
10316
|
+
memcached_server_st *arg1 = (memcached_server_st *) 0 ;
|
10317
|
+
memcached_server_st *arg2 = (memcached_server_st *) 0 ;
|
10318
|
+
void *argp1 = 0 ;
|
10319
|
+
int res1 = 0 ;
|
10320
|
+
void *argp2 = 0 ;
|
10321
|
+
int res2 = 0 ;
|
10322
|
+
memcached_server_st *result = 0 ;
|
10323
|
+
VALUE vresult = Qnil;
|
10324
|
+
|
10325
|
+
if ((argc < 2) || (argc > 2)) {
|
10326
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
|
10327
|
+
}
|
10328
|
+
res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_server_st, 0 | 0 );
|
10329
|
+
if (!SWIG_IsOK(res1)) {
|
10330
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_server_st *","memcached_server_clone", 1, argv[0] ));
|
10331
|
+
}
|
10332
|
+
arg1 = (memcached_server_st *)(argp1);
|
10333
|
+
res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_memcached_server_st, 0 | 0 );
|
10334
|
+
if (!SWIG_IsOK(res2)) {
|
10335
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "memcached_server_st *","memcached_server_clone", 2, argv[1] ));
|
10336
|
+
}
|
10337
|
+
arg2 = (memcached_server_st *)(argp2);
|
10338
|
+
result = (memcached_server_st *)memcached_server_clone(arg1,arg2);
|
10339
|
+
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_memcached_server_st, 0 | 0 );
|
10340
|
+
return vresult;
|
10341
|
+
fail:
|
10342
|
+
return Qnil;
|
10343
|
+
}
|
10344
|
+
|
10345
|
+
|
9345
10346
|
SWIGINTERN VALUE
|
9346
10347
|
_wrap_memcached_get_rvalue(int argc, VALUE *argv, VALUE self) {
|
9347
10348
|
memcached_st *arg1 = (memcached_st *) 0 ;
|
@@ -9606,7 +10607,6 @@ static swig_type_info _swigt__p_size_t = {"_p_size_t", "size_t *", 0, 0, (void*)
|
|
9606
10607
|
static swig_type_info _swigt__p_time_t = {"_p_time_t", "time_t *", 0, 0, (void*)0, 0};
|
9607
10608
|
static swig_type_info _swigt__p_uint32_t = {"_p_uint32_t", "uint32_t *", 0, 0, (void*)0, 0};
|
9608
10609
|
static swig_type_info _swigt__p_uint64_t = {"_p_uint64_t", "uint64_t *", 0, 0, (void*)0, 0};
|
9609
|
-
static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *", 0, 0, (void*)0, 0};
|
9610
10610
|
static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
|
9611
10611
|
|
9612
10612
|
static swig_type_info *swig_type_initial[] = {
|
@@ -9640,7 +10640,6 @@ static swig_type_info *swig_type_initial[] = {
|
|
9640
10640
|
&_swigt__p_time_t,
|
9641
10641
|
&_swigt__p_uint32_t,
|
9642
10642
|
&_swigt__p_uint64_t,
|
9643
|
-
&_swigt__p_unsigned_int,
|
9644
10643
|
&_swigt__p_void,
|
9645
10644
|
};
|
9646
10645
|
|
@@ -9674,7 +10673,6 @@ static swig_cast_info _swigc__p_size_t[] = { {&_swigt__p_size_t, 0, 0, 0},{0, 0
|
|
9674
10673
|
static swig_cast_info _swigc__p_time_t[] = { {&_swigt__p_time_t, 0, 0, 0},{0, 0, 0, 0}};
|
9675
10674
|
static swig_cast_info _swigc__p_uint32_t[] = { {&_swigt__p_uint32_t, 0, 0, 0},{0, 0, 0, 0}};
|
9676
10675
|
static swig_cast_info _swigc__p_uint64_t[] = { {&_swigt__p_uint64_t, 0, 0, 0},{0, 0, 0, 0}};
|
9677
|
-
static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
|
9678
10676
|
static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
|
9679
10677
|
|
9680
10678
|
static swig_cast_info *swig_cast_initial[] = {
|
@@ -9708,7 +10706,6 @@ static swig_cast_info *swig_cast_initial[] = {
|
|
9708
10706
|
_swigc__p_time_t,
|
9709
10707
|
_swigc__p_uint32_t,
|
9710
10708
|
_swigc__p_uint64_t,
|
9711
|
-
_swigc__p_unsigned_int,
|
9712
10709
|
_swigc__p_void,
|
9713
10710
|
};
|
9714
10711
|
|
@@ -9983,7 +10980,7 @@ SWIGEXPORT void Init_rlibmemcached(void) {
|
|
9983
10980
|
cMemcachedContinuumItemSt.mark = 0;
|
9984
10981
|
cMemcachedContinuumItemSt.destroy = (void (*)(void *)) free_memcached_continuum_item_st;
|
9985
10982
|
cMemcachedContinuumItemSt.trackObjects = 0;
|
9986
|
-
rb_define_const(mRlibmemcached, "LIBMEMCACHED_VERSION_STRING", SWIG_FromCharPtr("0.
|
10983
|
+
rb_define_const(mRlibmemcached, "LIBMEMCACHED_VERSION_STRING", SWIG_FromCharPtr("0.25"));
|
9987
10984
|
|
9988
10985
|
cMemcachedStatSt.klass = rb_define_class_under(mRlibmemcached, "MemcachedStatSt", rb_cObject);
|
9989
10986
|
SWIG_TypeClientData(SWIGTYPE_p_memcached_stat_st, (void *) &cMemcachedStatSt);
|
@@ -10075,10 +11072,6 @@ SWIGEXPORT void Init_rlibmemcached(void) {
|
|
10075
11072
|
rb_define_method(cMemcachedSt.klass, "distribution", _wrap_MemcachedSt_distribution_get, -1);
|
10076
11073
|
rb_define_method(cMemcachedSt.klass, "user_data=", _wrap_MemcachedSt_user_data_set, -1);
|
10077
11074
|
rb_define_method(cMemcachedSt.klass, "user_data", _wrap_MemcachedSt_user_data_get, -1);
|
10078
|
-
rb_define_method(cMemcachedSt.klass, "wheel=", _wrap_MemcachedSt_wheel_set, -1);
|
10079
|
-
rb_define_method(cMemcachedSt.klass, "wheel", _wrap_MemcachedSt_wheel_get, -1);
|
10080
|
-
rb_define_method(cMemcachedSt.klass, "wheel_count=", _wrap_MemcachedSt_wheel_count_set, -1);
|
10081
|
-
rb_define_method(cMemcachedSt.klass, "wheel_count", _wrap_MemcachedSt_wheel_count_get, -1);
|
10082
11075
|
rb_define_method(cMemcachedSt.klass, "continuum_count=", _wrap_MemcachedSt_continuum_count_set, -1);
|
10083
11076
|
rb_define_method(cMemcachedSt.klass, "continuum_count", _wrap_MemcachedSt_continuum_count_get, -1);
|
10084
11077
|
rb_define_method(cMemcachedSt.klass, "continuum=", _wrap_MemcachedSt_continuum_set, -1);
|
@@ -10101,6 +11094,22 @@ SWIGEXPORT void Init_rlibmemcached(void) {
|
|
10101
11094
|
rb_define_method(cMemcachedSt.klass, "prefix_key", _wrap_MemcachedSt_prefix_key_get, -1);
|
10102
11095
|
rb_define_method(cMemcachedSt.klass, "prefix_key_length=", _wrap_MemcachedSt_prefix_key_length_set, -1);
|
10103
11096
|
rb_define_method(cMemcachedSt.klass, "prefix_key_length", _wrap_MemcachedSt_prefix_key_length_get, -1);
|
11097
|
+
rb_define_method(cMemcachedSt.klass, "hash_continuum=", _wrap_MemcachedSt_hash_continuum_set, -1);
|
11098
|
+
rb_define_method(cMemcachedSt.klass, "hash_continuum", _wrap_MemcachedSt_hash_continuum_get, -1);
|
11099
|
+
rb_define_method(cMemcachedSt.klass, "continuum_points_counter=", _wrap_MemcachedSt_continuum_points_counter_set, -1);
|
11100
|
+
rb_define_method(cMemcachedSt.klass, "continuum_points_counter", _wrap_MemcachedSt_continuum_points_counter_get, -1);
|
11101
|
+
rb_define_method(cMemcachedSt.klass, "snd_timeout=", _wrap_MemcachedSt_snd_timeout_set, -1);
|
11102
|
+
rb_define_method(cMemcachedSt.klass, "snd_timeout", _wrap_MemcachedSt_snd_timeout_get, -1);
|
11103
|
+
rb_define_method(cMemcachedSt.klass, "rcv_timeout=", _wrap_MemcachedSt_rcv_timeout_set, -1);
|
11104
|
+
rb_define_method(cMemcachedSt.klass, "rcv_timeout", _wrap_MemcachedSt_rcv_timeout_get, -1);
|
11105
|
+
rb_define_method(cMemcachedSt.klass, "server_failure_limit=", _wrap_MemcachedSt_server_failure_limit_set, -1);
|
11106
|
+
rb_define_method(cMemcachedSt.klass, "server_failure_limit", _wrap_MemcachedSt_server_failure_limit_get, -1);
|
11107
|
+
rb_define_method(cMemcachedSt.klass, "io_msg_watermark=", _wrap_MemcachedSt_io_msg_watermark_set, -1);
|
11108
|
+
rb_define_method(cMemcachedSt.klass, "io_msg_watermark", _wrap_MemcachedSt_io_msg_watermark_get, -1);
|
11109
|
+
rb_define_method(cMemcachedSt.klass, "io_bytes_watermark=", _wrap_MemcachedSt_io_bytes_watermark_set, -1);
|
11110
|
+
rb_define_method(cMemcachedSt.klass, "io_bytes_watermark", _wrap_MemcachedSt_io_bytes_watermark_get, -1);
|
11111
|
+
rb_define_method(cMemcachedSt.klass, "purging=", _wrap_MemcachedSt_purging_set, -1);
|
11112
|
+
rb_define_method(cMemcachedSt.klass, "purging", _wrap_MemcachedSt_purging_get, -1);
|
10104
11113
|
cMemcachedSt.mark = 0;
|
10105
11114
|
cMemcachedSt.destroy = (void (*)(void *)) memcached_free;
|
10106
11115
|
cMemcachedSt.trackObjects = 0;
|
@@ -10123,9 +11132,13 @@ SWIGEXPORT void Init_rlibmemcached(void) {
|
|
10123
11132
|
rb_define_module_function(mRlibmemcached, "memcached_server_add_udp", _wrap_memcached_server_add_udp, -1);
|
10124
11133
|
rb_define_module_function(mRlibmemcached, "memcached_server_add_unix_socket", _wrap_memcached_server_add_unix_socket, -1);
|
10125
11134
|
rb_define_module_function(mRlibmemcached, "memcached_server_add", _wrap_memcached_server_add, -1);
|
11135
|
+
rb_define_module_function(mRlibmemcached, "memcached_server_add_udp_with_weight", _wrap_memcached_server_add_udp_with_weight, -1);
|
11136
|
+
rb_define_module_function(mRlibmemcached, "memcached_server_add_unix_socket_with_weight", _wrap_memcached_server_add_unix_socket_with_weight, -1);
|
11137
|
+
rb_define_module_function(mRlibmemcached, "memcached_server_add_with_weight", _wrap_memcached_server_add_with_weight, -1);
|
10126
11138
|
rb_define_module_function(mRlibmemcached, "memcached_server_list_free", _wrap_memcached_server_list_free, -1);
|
10127
11139
|
rb_define_module_function(mRlibmemcached, "memcached_server_push", _wrap_memcached_server_push, -1);
|
10128
11140
|
rb_define_module_function(mRlibmemcached, "memcached_server_list_append", _wrap_memcached_server_list_append, -1);
|
11141
|
+
rb_define_module_function(mRlibmemcached, "memcached_server_list_append_with_weight", _wrap_memcached_server_list_append_with_weight, -1);
|
10129
11142
|
rb_define_module_function(mRlibmemcached, "memcached_server_list_count", _wrap_memcached_server_list_count, -1);
|
10130
11143
|
rb_define_module_function(mRlibmemcached, "memcached_servers_parse", _wrap_memcached_servers_parse, -1);
|
10131
11144
|
rb_define_module_function(mRlibmemcached, "memcached_stat_get_value", _wrap_memcached_stat_get_value, -1);
|
@@ -10134,18 +11147,18 @@ SWIGEXPORT void Init_rlibmemcached(void) {
|
|
10134
11147
|
rb_define_module_function(mRlibmemcached, "memcached_fetch_execute", _wrap_memcached_fetch_execute, -1);
|
10135
11148
|
rb_define_module_function(mRlibmemcached, "memcached_callback_set", _wrap_memcached_callback_set, -1);
|
10136
11149
|
rb_define_module_function(mRlibmemcached, "memcached_callback_get", _wrap_memcached_callback_get, -1);
|
10137
|
-
rb_define_module_function(mRlibmemcached, "memcached_server_cursor", _wrap_memcached_server_cursor, -1);
|
10138
11150
|
rb_define_const(mRlibmemcached, "MEMCACHED_DEFAULT_PORT", SWIG_From_int((int)(11211)));
|
10139
11151
|
rb_define_const(mRlibmemcached, "MEMCACHED_MAX_KEY", SWIG_From_int((int)(251)));
|
10140
11152
|
rb_define_const(mRlibmemcached, "MEMCACHED_MAX_BUFFER", SWIG_From_int((int)(8196)));
|
10141
11153
|
rb_define_const(mRlibmemcached, "MEMCACHED_MAX_HOST_LENGTH", SWIG_From_int((int)(64)));
|
10142
11154
|
rb_define_const(mRlibmemcached, "MEMCACHED_MAX_HOST_SORT_LENGTH", SWIG_From_int((int)(86)));
|
10143
11155
|
rb_define_const(mRlibmemcached, "MEMCACHED_POINTS_PER_SERVER", SWIG_From_int((int)(100)));
|
11156
|
+
rb_define_const(mRlibmemcached, "MEMCACHED_POINTS_PER_SERVER_KETAMA", SWIG_From_int((int)(160)));
|
10144
11157
|
rb_define_const(mRlibmemcached, "MEMCACHED_CONTINUUM_SIZE", SWIG_From_int((int)(100*100)));
|
10145
11158
|
rb_define_const(mRlibmemcached, "MEMCACHED_STRIDE", SWIG_From_int((int)(4)));
|
10146
11159
|
rb_define_const(mRlibmemcached, "MEMCACHED_DEFAULT_TIMEOUT", SWIG_From_int((int)(1000)));
|
10147
11160
|
rb_define_const(mRlibmemcached, "MEMCACHED_CONTINUUM_ADDITION", SWIG_From_int((int)(10)));
|
10148
|
-
rb_define_const(mRlibmemcached, "MEMCACHED_PREFIX_KEY_MAX_SIZE", SWIG_From_int((int)(
|
11161
|
+
rb_define_const(mRlibmemcached, "MEMCACHED_PREFIX_KEY_MAX_SIZE", SWIG_From_int((int)(128)));
|
10149
11162
|
rb_define_const(mRlibmemcached, "MEMCACHED_SUCCESS", SWIG_From_int((int)(MEMCACHED_SUCCESS)));
|
10150
11163
|
rb_define_const(mRlibmemcached, "MEMCACHED_FAILURE", SWIG_From_int((int)(MEMCACHED_FAILURE)));
|
10151
11164
|
rb_define_const(mRlibmemcached, "MEMCACHED_HOST_LOOKUP_FAILURE", SWIG_From_int((int)(MEMCACHED_HOST_LOOKUP_FAILURE)));
|
@@ -10182,8 +11195,8 @@ SWIGEXPORT void Init_rlibmemcached(void) {
|
|
10182
11195
|
rb_define_const(mRlibmemcached, "MEMCACHED_MAXIMUM_RETURN", SWIG_From_int((int)(MEMCACHED_MAXIMUM_RETURN)));
|
10183
11196
|
rb_define_const(mRlibmemcached, "MEMCACHED_DISTRIBUTION_MODULA", SWIG_From_int((int)(MEMCACHED_DISTRIBUTION_MODULA)));
|
10184
11197
|
rb_define_const(mRlibmemcached, "MEMCACHED_DISTRIBUTION_CONSISTENT", SWIG_From_int((int)(MEMCACHED_DISTRIBUTION_CONSISTENT)));
|
10185
|
-
rb_define_const(mRlibmemcached, "MEMCACHED_DISTRIBUTION_CONSISTENT_WHEEL", SWIG_From_int((int)(MEMCACHED_DISTRIBUTION_CONSISTENT_WHEEL)));
|
10186
11198
|
rb_define_const(mRlibmemcached, "MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA", SWIG_From_int((int)(MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA)));
|
11199
|
+
rb_define_const(mRlibmemcached, "MEMCACHED_DISTRIBUTION_RANDOM", SWIG_From_int((int)(MEMCACHED_DISTRIBUTION_RANDOM)));
|
10187
11200
|
rb_define_const(mRlibmemcached, "MEMCACHED_BEHAVIOR_NO_BLOCK", SWIG_From_int((int)(MEMCACHED_BEHAVIOR_NO_BLOCK)));
|
10188
11201
|
rb_define_const(mRlibmemcached, "MEMCACHED_BEHAVIOR_TCP_NODELAY", SWIG_From_int((int)(MEMCACHED_BEHAVIOR_TCP_NODELAY)));
|
10189
11202
|
rb_define_const(mRlibmemcached, "MEMCACHED_BEHAVIOR_HASH", SWIG_From_int((int)(MEMCACHED_BEHAVIOR_HASH)));
|
@@ -10200,6 +11213,15 @@ SWIGEXPORT void Init_rlibmemcached(void) {
|
|
10200
11213
|
rb_define_const(mRlibmemcached, "MEMCACHED_BEHAVIOR_VERIFY_KEY", SWIG_From_int((int)(MEMCACHED_BEHAVIOR_VERIFY_KEY)));
|
10201
11214
|
rb_define_const(mRlibmemcached, "MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT", SWIG_From_int((int)(MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT)));
|
10202
11215
|
rb_define_const(mRlibmemcached, "MEMCACHED_BEHAVIOR_RETRY_TIMEOUT", SWIG_From_int((int)(MEMCACHED_BEHAVIOR_RETRY_TIMEOUT)));
|
11216
|
+
rb_define_const(mRlibmemcached, "MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED", SWIG_From_int((int)(MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED)));
|
11217
|
+
rb_define_const(mRlibmemcached, "MEMCACHED_BEHAVIOR_KETAMA_HASH", SWIG_From_int((int)(MEMCACHED_BEHAVIOR_KETAMA_HASH)));
|
11218
|
+
rb_define_const(mRlibmemcached, "MEMCACHED_BEHAVIOR_BINARY_PROTOCOL", SWIG_From_int((int)(MEMCACHED_BEHAVIOR_BINARY_PROTOCOL)));
|
11219
|
+
rb_define_const(mRlibmemcached, "MEMCACHED_BEHAVIOR_SND_TIMEOUT", SWIG_From_int((int)(MEMCACHED_BEHAVIOR_SND_TIMEOUT)));
|
11220
|
+
rb_define_const(mRlibmemcached, "MEMCACHED_BEHAVIOR_RCV_TIMEOUT", SWIG_From_int((int)(MEMCACHED_BEHAVIOR_RCV_TIMEOUT)));
|
11221
|
+
rb_define_const(mRlibmemcached, "MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT", SWIG_From_int((int)(MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT)));
|
11222
|
+
rb_define_const(mRlibmemcached, "MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK", SWIG_From_int((int)(MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK)));
|
11223
|
+
rb_define_const(mRlibmemcached, "MEMCACHED_BEHAVIOR_IO_BYTES_WATERMARK", SWIG_From_int((int)(MEMCACHED_BEHAVIOR_IO_BYTES_WATERMARK)));
|
11224
|
+
rb_define_const(mRlibmemcached, "MEMCACHED_BEHAVIOR_HASH_WITH_PREFIX_KEY", SWIG_From_int((int)(MEMCACHED_BEHAVIOR_HASH_WITH_PREFIX_KEY)));
|
10203
11225
|
rb_define_const(mRlibmemcached, "MEMCACHED_CALLBACK_PREFIX_KEY", SWIG_From_int((int)(MEMCACHED_CALLBACK_PREFIX_KEY)));
|
10204
11226
|
rb_define_const(mRlibmemcached, "MEMCACHED_CALLBACK_USER_DATA", SWIG_From_int((int)(MEMCACHED_CALLBACK_USER_DATA)));
|
10205
11227
|
rb_define_const(mRlibmemcached, "MEMCACHED_CALLBACK_CLEANUP_FUNCTION", SWIG_From_int((int)(MEMCACHED_CALLBACK_CLEANUP_FUNCTION)));
|
@@ -10218,6 +11240,7 @@ SWIGEXPORT void Init_rlibmemcached(void) {
|
|
10218
11240
|
rb_define_const(mRlibmemcached, "MEMCACHED_HASH_FNV1A_32", SWIG_From_int((int)(MEMCACHED_HASH_FNV1A_32)));
|
10219
11241
|
rb_define_const(mRlibmemcached, "MEMCACHED_HASH_HSIEH", SWIG_From_int((int)(MEMCACHED_HASH_HSIEH)));
|
10220
11242
|
rb_define_const(mRlibmemcached, "MEMCACHED_HASH_MURMUR", SWIG_From_int((int)(MEMCACHED_HASH_MURMUR)));
|
11243
|
+
rb_define_const(mRlibmemcached, "MEMCACHED_HASH_JENKINS", SWIG_From_int((int)(MEMCACHED_HASH_JENKINS)));
|
10221
11244
|
rb_define_const(mRlibmemcached, "MEMCACHED_CONNECTION_UNKNOWN", SWIG_From_int((int)(MEMCACHED_CONNECTION_UNKNOWN)));
|
10222
11245
|
rb_define_const(mRlibmemcached, "MEMCACHED_CONNECTION_TCP", SWIG_From_int((int)(MEMCACHED_CONNECTION_TCP)));
|
10223
11246
|
rb_define_const(mRlibmemcached, "MEMCACHED_CONNECTION_UDP", SWIG_From_int((int)(MEMCACHED_CONNECTION_UDP)));
|
@@ -10278,6 +11301,8 @@ SWIGEXPORT void Init_rlibmemcached(void) {
|
|
10278
11301
|
SWIG_TypeClientData(SWIGTYPE_p_memcached_server_st, (void *) &cMemcachedServerSt);
|
10279
11302
|
rb_define_alloc_func(cMemcachedServerSt.klass, _wrap_MemcachedServerSt_allocate);
|
10280
11303
|
rb_define_method(cMemcachedServerSt.klass, "initialize", _wrap_new_MemcachedServerSt, -1);
|
11304
|
+
rb_define_method(cMemcachedServerSt.klass, "is_allocated=", _wrap_MemcachedServerSt_is_allocated_set, -1);
|
11305
|
+
rb_define_method(cMemcachedServerSt.klass, "is_allocated", _wrap_MemcachedServerSt_is_allocated_get, -1);
|
10281
11306
|
rb_define_method(cMemcachedServerSt.klass, "hostname=", _wrap_MemcachedServerSt_hostname_set, -1);
|
10282
11307
|
rb_define_method(cMemcachedServerSt.klass, "hostname", _wrap_MemcachedServerSt_hostname_get, -1);
|
10283
11308
|
rb_define_method(cMemcachedServerSt.klass, "port=", _wrap_MemcachedServerSt_port_set, -1);
|
@@ -10318,9 +11343,22 @@ SWIGEXPORT void Init_rlibmemcached(void) {
|
|
10318
11343
|
rb_define_method(cMemcachedServerSt.klass, "next_retry", _wrap_MemcachedServerSt_next_retry_get, -1);
|
10319
11344
|
rb_define_method(cMemcachedServerSt.klass, "root=", _wrap_MemcachedServerSt_root_set, -1);
|
10320
11345
|
rb_define_method(cMemcachedServerSt.klass, "root", _wrap_MemcachedServerSt_root_get, -1);
|
11346
|
+
rb_define_method(cMemcachedServerSt.klass, "limit_maxbytes=", _wrap_MemcachedServerSt_limit_maxbytes_set, -1);
|
11347
|
+
rb_define_method(cMemcachedServerSt.klass, "limit_maxbytes", _wrap_MemcachedServerSt_limit_maxbytes_get, -1);
|
11348
|
+
rb_define_method(cMemcachedServerSt.klass, "server_failure_counter=", _wrap_MemcachedServerSt_server_failure_counter_set, -1);
|
11349
|
+
rb_define_method(cMemcachedServerSt.klass, "server_failure_counter", _wrap_MemcachedServerSt_server_failure_counter_get, -1);
|
11350
|
+
rb_define_method(cMemcachedServerSt.klass, "io_bytes_sent=", _wrap_MemcachedServerSt_io_bytes_sent_set, -1);
|
11351
|
+
rb_define_method(cMemcachedServerSt.klass, "io_bytes_sent", _wrap_MemcachedServerSt_io_bytes_sent_get, -1);
|
11352
|
+
rb_define_method(cMemcachedServerSt.klass, "weight=", _wrap_MemcachedServerSt_weight_set, -1);
|
11353
|
+
rb_define_method(cMemcachedServerSt.klass, "weight", _wrap_MemcachedServerSt_weight_get, -1);
|
10321
11354
|
cMemcachedServerSt.mark = 0;
|
10322
11355
|
cMemcachedServerSt.destroy = (void (*)(void *)) free_memcached_server_st;
|
10323
11356
|
cMemcachedServerSt.trackObjects = 0;
|
11357
|
+
rb_define_module_function(mRlibmemcached, "memcached_server_cursor", _wrap_memcached_server_cursor, -1);
|
11358
|
+
rb_define_module_function(mRlibmemcached, "memcached_server_by_key", _wrap_memcached_server_by_key, -1);
|
11359
|
+
rb_define_module_function(mRlibmemcached, "memcached_server_create", _wrap_memcached_server_create, -1);
|
11360
|
+
rb_define_module_function(mRlibmemcached, "memcached_server_free", _wrap_memcached_server_free, -1);
|
11361
|
+
rb_define_module_function(mRlibmemcached, "memcached_server_clone", _wrap_memcached_server_clone, -1);
|
10324
11362
|
rb_define_module_function(mRlibmemcached, "memcached_get_rvalue", _wrap_memcached_get_rvalue, -1);
|
10325
11363
|
rb_define_module_function(mRlibmemcached, "memcached_fetch_rvalue", _wrap_memcached_fetch_rvalue, -1);
|
10326
11364
|
rb_define_module_function(mRlibmemcached, "memcached_stat_get_rvalue", _wrap_memcached_stat_get_rvalue, -1);
|