rice 1.2.0 → 1.3.0

Sign up to get free protection for your applications and to get access to all the features.
Files changed (65) hide show
  1. data/Doxyfile +1 -1
  2. data/Makefile.in +130 -52
  3. data/README +45 -79
  4. data/Rakefile +1 -36
  5. data/aclocal.m4 +133 -61
  6. data/config.guess +43 -8
  7. data/config.sub +41 -13
  8. data/configure +1370 -1898
  9. data/configure.ac +2 -2
  10. data/doxygen.ac +1 -1
  11. data/extconf.rb +3 -1
  12. data/rice/Arg_impl.hpp +2 -2
  13. data/rice/Data_Type.cpp +34 -1
  14. data/rice/Data_Type.ipp +14 -5
  15. data/rice/Data_Type_defn.hpp +28 -1
  16. data/rice/Director.cpp +0 -6
  17. data/rice/Director.hpp +0 -8
  18. data/rice/Hash.hpp +1 -1
  19. data/rice/Makefile.am +2 -12
  20. data/rice/Makefile.in +111 -88
  21. data/rice/Object.cpp +8 -1
  22. data/rice/Object.ipp +1 -1
  23. data/rice/Object_defn.hpp +8 -0
  24. data/rice/config.hpp +3 -0
  25. data/rice/config.hpp.in +3 -0
  26. data/rice/detail/Auto_Function_Wrapper.ipp +1025 -512
  27. data/rice/detail/Auto_Member_Function_Wrapper.ipp +545 -272
  28. data/rice/detail/cfp.hpp +24 -0
  29. data/rice/detail/cfp.ipp +51 -0
  30. data/rice/detail/method_data.cpp +107 -336
  31. data/rice/detail/node.hpp +13 -13
  32. data/rice/detail/ruby.hpp +4 -0
  33. data/rice/detail/rubysig.hpp +19 -19
  34. data/rice/detail/traits.hpp +43 -0
  35. data/rice/generate_code.rb +37 -16
  36. data/rice/protect.hpp +1 -1
  37. data/rice/protect.ipp +448 -192
  38. data/rice/to_from_ruby.ipp +4 -12
  39. data/rice/to_from_ruby_defn.hpp +2 -2
  40. data/ruby/Makefile.in +99 -32
  41. data/ruby/lib/Makefile.in +61 -21
  42. data/ruby/lib/mkmf-rice.rb.in +9 -2
  43. data/ruby/lib/version.rb +1 -1
  44. data/sample/Makefile.in +33 -10
  45. data/test/Makefile.am +27 -0
  46. data/test/Makefile.in +270 -59
  47. data/test/ext/Makefile.am +43 -0
  48. data/test/ext/Makefile.in +399 -0
  49. data/test/ext/t1/Foo.hpp +10 -0
  50. data/test/ext/t1/extconf.rb +2 -0
  51. data/test/ext/t1/t1.cpp +15 -0
  52. data/test/ext/t2/extconf.rb +2 -0
  53. data/test/ext/t2/t2.cpp +11 -0
  54. data/test/test_Allocation_Strategies.cpp +1 -1
  55. data/test/test_Class.cpp +79 -0
  56. data/test/test_Data_Type.cpp +2 -2
  57. data/test/test_Director.cpp +114 -38
  58. data/test/test_Module.cpp +27 -2
  59. data/test/test_To_From_Ruby.cpp +4 -4
  60. data/test/test_rice.rb +9 -1
  61. metadata +23 -8
  62. data/rice/detail/method_data.cpp.rpp +0 -301
  63. data/rice/detail/mininode.cpp.rpp +0 -62
  64. data/rice/detail/mininode.hpp.rpp +0 -119
  65. data/rice/detail/remove_const.hpp +0 -21
data/rice/Object.cpp CHANGED
@@ -93,7 +93,14 @@ Rice::Object Rice::Object::
93
93
  iv_get(
94
94
  Identifier name) const
95
95
  {
96
- return protect(rb_iv_get, *this, name.c_str());
96
+ return protect(rb_ivar_get, *this, name.id());
97
+ }
98
+
99
+ Rice::Object Rice::Object::
100
+ attr_get(
101
+ Identifier name) const
102
+ {
103
+ return protect(rb_attr_get, *this, name.id());
97
104
  }
98
105
 
99
106
  Rice::Object Rice::Object::
data/rice/Object.ipp CHANGED
@@ -12,7 +12,7 @@ iv_set(
12
12
  Identifier name,
13
13
  T const & value)
14
14
  {
15
- protect(rb_iv_set, *this, name.c_str(), to_ruby(value));
15
+ protect(rb_ivar_set, *this, name.id(), to_ruby(value));
16
16
  }
17
17
 
18
18
  #endif // Rice__Object__ipp_
data/rice/Object_defn.hpp CHANGED
@@ -143,6 +143,14 @@ public:
143
143
  Object iv_get(
144
144
  Identifier name) const;
145
145
 
146
+ //! Get the value of an instance variable, but don't warn if it is
147
+ //unset.
148
+ /*! \param name the name of the instance variable to get
149
+ * \return the value of the instance variable
150
+ */
151
+ Object attr_get(
152
+ Identifier name) const;
153
+
146
154
  #include "detail/object_call.hpp"
147
155
 
148
156
  //! Vectorized call.
data/rice/config.hpp CHANGED
@@ -34,6 +34,9 @@
34
34
  /* Define to the one symbol short name of this package. */
35
35
  #define PACKAGE_TARNAME "rice"
36
36
 
37
+ /* Define to the home page for this package. */
38
+ #define PACKAGE_URL ""
39
+
37
40
  /* Define to the version of this package. */
38
41
  #define PACKAGE_VERSION "1.1"
39
42
 
data/rice/config.hpp.in CHANGED
@@ -33,6 +33,9 @@
33
33
  /* Define to the one symbol short name of this package. */
34
34
  #undef PACKAGE_TARNAME
35
35
 
36
+ /* Define to the home page for this package. */
37
+ #undef PACKAGE_URL
38
+
36
39
  /* Define to the version of this package. */
37
40
  #undef PACKAGE_VERSION
38
41
 
data/rice/detail/Auto_Function_Wrapper.ipp CHANGED
@@ -10,6 +10,7 @@
10
10
  #include "method_data.hpp"
11
11
  #include "../ruby_try_catch.hpp"
12
12
  #include "../to_from_ruby.hpp"
13
+ #include "traits.hpp"
13
14
  namespace Rice
14
15
  {
15
16
 
@@ -59,43 +60,74 @@ call(int argc, VALUE *argv, VALUE self)
59
60
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14, &varg15);
60
61
 
61
62
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
62
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
63
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
64
- Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
65
- Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
66
- Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
67
- Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
68
- Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
69
- Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
70
- Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
71
- Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(9, varg9);
72
- Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(10, varg10);
73
- Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(11, varg11);
74
- Arg13_T arg13 = args->getArgumentOrDefault<Arg13_T>(12, varg12);
75
- Arg14_T arg14 = args->getArgumentOrDefault<Arg14_T>(13, varg13);
76
- Arg15_T arg15 = args->getArgumentOrDefault<Arg15_T>(14, varg14);
63
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
64
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
65
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
66
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
67
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
68
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
69
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
70
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
71
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
72
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
73
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
74
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
75
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
76
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
77
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
78
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
79
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
80
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
81
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
82
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
83
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
84
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
85
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
86
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
87
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
88
+ Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(12, varg12);
89
+ typedef typename sanitize< Arg14_T >::Type Arg14_Type;
90
+ Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(13, varg13);
91
+ typedef typename sanitize< Arg15_T >::Type Arg15_Type;
92
+ Arg15_Type arg15 = args->getArgumentOrDefault<Arg15_Type>(14, varg14);
77
93
 
78
94
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15));
79
95
  } else {
80
96
  rb_scan_args(argc, argv, args->formatString(Num_Args)
81
97
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14, &varg15);
82
98
 
83
- Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
84
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
85
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
86
- Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
87
- Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
88
- Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
89
- Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
90
- Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
91
- Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
92
- Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
93
- Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(10, varg10);
94
- Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(11, varg11);
95
- Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(12, varg12);
96
- Arg13_T arg13 = args->getArgumentOrDefault<Arg13_T>(13, varg13);
97
- Arg14_T arg14 = args->getArgumentOrDefault<Arg14_T>(14, varg14);
98
- Arg15_T arg15 = args->getArgumentOrDefault<Arg15_T>(15, varg15);
99
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
100
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
101
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
102
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
103
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
104
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
105
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
106
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
107
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
108
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
109
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
110
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
111
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
112
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
113
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
114
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
115
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
116
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
117
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
118
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
119
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
120
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
121
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
122
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
123
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
124
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
125
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
126
+ Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
127
+ typedef typename sanitize< Arg14_T >::Type Arg14_Type;
128
+ Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(14, varg14);
129
+ typedef typename sanitize< Arg15_T >::Type Arg15_Type;
130
+ Arg15_Type arg15 = args->getArgumentOrDefault<Arg15_Type>(15, varg15);
99
131
 
100
132
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15));
101
133
  }
@@ -161,21 +193,36 @@ call(int argc, VALUE* argv, VALUE self)
161
193
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14, &varg15);
162
194
 
163
195
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
164
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
165
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
166
- Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
167
- Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
168
- Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
169
- Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
170
- Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
171
- Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
172
- Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
173
- Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(9, varg9);
174
- Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(10, varg10);
175
- Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(11, varg11);
176
- Arg13_T arg13 = args->getArgumentOrDefault<Arg13_T>(12, varg12);
177
- Arg14_T arg14 = args->getArgumentOrDefault<Arg14_T>(13, varg13);
178
- Arg15_T arg15 = args->getArgumentOrDefault<Arg15_T>(14, varg14);
196
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
197
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
198
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
199
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
200
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
201
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
202
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
203
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
204
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
205
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
206
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
207
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
208
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
209
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
210
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
211
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
212
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
213
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
214
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
215
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
216
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
217
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
218
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
219
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
220
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
221
+ Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(12, varg12);
222
+ typedef typename sanitize< Arg14_T >::Type Arg14_Type;
223
+ Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(13, varg13);
224
+ typedef typename sanitize< Arg15_T >::Type Arg15_Type;
225
+ Arg15_Type arg15 = args->getArgumentOrDefault<Arg15_Type>(14, varg14);
179
226
 
180
227
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15);
181
228
  return Qnil;
@@ -183,22 +230,38 @@ call(int argc, VALUE* argv, VALUE self)
183
230
  rb_scan_args(argc, argv, args->formatString(Num_Args)
184
231
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14, &varg15);
185
232
 
186
- Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
187
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
188
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
189
- Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
190
- Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
191
- Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
192
- Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
193
- Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
194
- Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
195
- Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
196
- Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(10, varg10);
197
- Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(11, varg11);
198
- Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(12, varg12);
199
- Arg13_T arg13 = args->getArgumentOrDefault<Arg13_T>(13, varg13);
200
- Arg14_T arg14 = args->getArgumentOrDefault<Arg14_T>(14, varg14);
201
- Arg15_T arg15 = args->getArgumentOrDefault<Arg15_T>(15, varg15);
233
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
234
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
235
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
236
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
237
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
238
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
239
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
240
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
241
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
242
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
243
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
244
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
245
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
246
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
247
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
248
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
249
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
250
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
251
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
252
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
253
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
254
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
255
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
256
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
257
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
258
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
259
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
260
+ Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
261
+ typedef typename sanitize< Arg14_T >::Type Arg14_Type;
262
+ Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(14, varg14);
263
+ typedef typename sanitize< Arg15_T >::Type Arg15_Type;
264
+ Arg15_Type arg15 = args->getArgumentOrDefault<Arg15_Type>(15, varg15);
202
265
 
203
266
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15);
204
267
  return Qnil;
@@ -265,41 +328,70 @@ call(int argc, VALUE *argv, VALUE self)
265
328
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14);
266
329
 
267
330
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
268
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
269
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
270
- Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
271
- Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
272
- Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
273
- Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
274
- Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
275
- Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
276
- Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
277
- Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(9, varg9);
278
- Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(10, varg10);
279
- Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(11, varg11);
280
- Arg13_T arg13 = args->getArgumentOrDefault<Arg13_T>(12, varg12);
281
- Arg14_T arg14 = args->getArgumentOrDefault<Arg14_T>(13, varg13);
331
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
332
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
333
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
334
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
335
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
336
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
337
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
338
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
339
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
340
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
341
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
342
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
343
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
344
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
345
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
346
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
347
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
348
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
349
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
350
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
351
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
352
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
353
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
354
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
355
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
356
+ Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(12, varg12);
357
+ typedef typename sanitize< Arg14_T >::Type Arg14_Type;
358
+ Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(13, varg13);
282
359
 
283
360
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14));
284
361
  } else {
285
362
  rb_scan_args(argc, argv, args->formatString(Num_Args)
286
363
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14);
287
364
 
288
- Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
289
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
290
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
291
- Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
292
- Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
293
- Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
294
- Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
295
- Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
296
- Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
297
- Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
298
- Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(10, varg10);
299
- Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(11, varg11);
300
- Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(12, varg12);
301
- Arg13_T arg13 = args->getArgumentOrDefault<Arg13_T>(13, varg13);
302
- Arg14_T arg14 = args->getArgumentOrDefault<Arg14_T>(14, varg14);
365
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
366
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
367
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
368
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
369
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
370
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
371
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
372
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
373
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
374
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
375
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
376
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
377
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
378
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
379
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
380
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
381
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
382
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
383
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
384
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
385
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
386
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
387
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
388
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
389
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
390
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
391
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
392
+ Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
393
+ typedef typename sanitize< Arg14_T >::Type Arg14_Type;
394
+ Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(14, varg14);
303
395
 
304
396
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14));
305
397
  }
@@ -365,20 +457,34 @@ call(int argc, VALUE* argv, VALUE self)
365
457
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14);
366
458
 
367
459
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
368
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
369
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
370
- Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
371
- Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
372
- Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
373
- Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
374
- Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
375
- Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
376
- Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
377
- Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(9, varg9);
378
- Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(10, varg10);
379
- Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(11, varg11);
380
- Arg13_T arg13 = args->getArgumentOrDefault<Arg13_T>(12, varg12);
381
- Arg14_T arg14 = args->getArgumentOrDefault<Arg14_T>(13, varg13);
460
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
461
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
462
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
463
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
464
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
465
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
466
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
467
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
468
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
469
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
470
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
471
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
472
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
473
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
474
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
475
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
476
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
477
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
478
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
479
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
480
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
481
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
482
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
483
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
484
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
485
+ Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(12, varg12);
486
+ typedef typename sanitize< Arg14_T >::Type Arg14_Type;
487
+ Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(13, varg13);
382
488
 
383
489
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
384
490
  return Qnil;
@@ -386,21 +492,36 @@ call(int argc, VALUE* argv, VALUE self)
386
492
  rb_scan_args(argc, argv, args->formatString(Num_Args)
387
493
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14);
388
494
 
389
- Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
390
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
391
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
392
- Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
393
- Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
394
- Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
395
- Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
396
- Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
397
- Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
398
- Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
399
- Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(10, varg10);
400
- Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(11, varg11);
401
- Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(12, varg12);
402
- Arg13_T arg13 = args->getArgumentOrDefault<Arg13_T>(13, varg13);
403
- Arg14_T arg14 = args->getArgumentOrDefault<Arg14_T>(14, varg14);
495
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
496
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
497
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
498
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
499
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
500
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
501
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
502
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
503
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
504
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
505
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
506
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
507
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
508
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
509
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
510
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
511
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
512
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
513
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
514
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
515
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
516
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
517
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
518
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
519
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
520
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
521
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
522
+ Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
523
+ typedef typename sanitize< Arg14_T >::Type Arg14_Type;
524
+ Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(14, varg14);
404
525
 
405
526
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
406
527
  return Qnil;
@@ -467,39 +588,66 @@ call(int argc, VALUE *argv, VALUE self)
467
588
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13);
468
589
 
469
590
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
470
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
471
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
472
- Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
473
- Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
474
- Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
475
- Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
476
- Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
477
- Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
478
- Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
479
- Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(9, varg9);
480
- Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(10, varg10);
481
- Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(11, varg11);
482
- Arg13_T arg13 = args->getArgumentOrDefault<Arg13_T>(12, varg12);
591
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
592
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
593
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
594
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
595
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
596
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
597
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
598
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
599
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
600
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
601
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
602
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
603
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
604
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
605
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
606
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
607
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
608
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
609
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
610
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
611
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
612
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
613
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
614
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
615
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
616
+ Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(12, varg12);
483
617
 
484
618
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13));
485
619
  } else {
486
620
  rb_scan_args(argc, argv, args->formatString(Num_Args)
487
621
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13);
488
622
 
489
- Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
490
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
491
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
492
- Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
493
- Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
494
- Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
495
- Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
496
- Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
497
- Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
498
- Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
499
- Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(10, varg10);
500
- Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(11, varg11);
501
- Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(12, varg12);
502
- Arg13_T arg13 = args->getArgumentOrDefault<Arg13_T>(13, varg13);
623
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
624
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
625
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
626
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
627
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
628
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
629
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
630
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
631
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
632
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
633
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
634
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
635
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
636
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
637
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
638
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
639
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
640
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
641
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
642
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
643
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
644
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
645
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
646
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
647
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
648
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
649
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
650
+ Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
503
651
 
504
652
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13));
505
653
  }
@@ -565,19 +713,32 @@ call(int argc, VALUE* argv, VALUE self)
565
713
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13);
566
714
 
567
715
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
568
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
569
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
570
- Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
571
- Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
572
- Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
573
- Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
574
- Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
575
- Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
576
- Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
577
- Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(9, varg9);
578
- Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(10, varg10);
579
- Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(11, varg11);
580
- Arg13_T arg13 = args->getArgumentOrDefault<Arg13_T>(12, varg12);
716
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
717
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
718
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
719
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
720
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
721
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
722
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
723
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
724
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
725
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
726
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
727
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
728
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
729
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
730
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
731
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
732
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
733
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
734
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
735
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
736
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
737
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
738
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
739
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
740
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
741
+ Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(12, varg12);
581
742
 
582
743
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
583
744
  return Qnil;
@@ -585,20 +746,34 @@ call(int argc, VALUE* argv, VALUE self)
585
746
  rb_scan_args(argc, argv, args->formatString(Num_Args)
586
747
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13);
587
748
 
588
- Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
589
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
590
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
591
- Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
592
- Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
593
- Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
594
- Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
595
- Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
596
- Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
597
- Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
598
- Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(10, varg10);
599
- Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(11, varg11);
600
- Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(12, varg12);
601
- Arg13_T arg13 = args->getArgumentOrDefault<Arg13_T>(13, varg13);
749
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
750
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
751
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
752
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
753
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
754
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
755
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
756
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
757
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
758
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
759
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
760
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
761
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
762
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
763
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
764
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
765
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
766
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
767
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
768
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
769
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
770
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
771
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
772
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
773
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
774
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
775
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
776
+ Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
602
777
 
603
778
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
604
779
  return Qnil;
@@ -665,37 +840,62 @@ call(int argc, VALUE *argv, VALUE self)
665
840
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12);
666
841
 
667
842
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
668
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
669
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
670
- Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
671
- Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
672
- Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
673
- Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
674
- Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
675
- Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
676
- Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
677
- Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(9, varg9);
678
- Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(10, varg10);
679
- Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(11, varg11);
843
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
844
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
845
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
846
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
847
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
848
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
849
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
850
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
851
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
852
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
853
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
854
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
855
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
856
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
857
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
858
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
859
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
860
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
861
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
862
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
863
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
864
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
865
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
866
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
680
867
 
681
868
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12));
682
869
  } else {
683
870
  rb_scan_args(argc, argv, args->formatString(Num_Args)
684
871
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12);
685
872
 
686
- Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
687
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
688
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
689
- Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
690
- Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
691
- Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
692
- Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
693
- Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
694
- Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
695
- Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
696
- Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(10, varg10);
697
- Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(11, varg11);
698
- Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(12, varg12);
873
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
874
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
875
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
876
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
877
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
878
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
879
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
880
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
881
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
882
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
883
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
884
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
885
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
886
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
887
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
888
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
889
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
890
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
891
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
892
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
893
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
894
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
895
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
896
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
897
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
898
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
699
899
 
700
900
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12));
701
901
  }
@@ -761,18 +961,30 @@ call(int argc, VALUE* argv, VALUE self)
761
961
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12);
762
962
 
763
963
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
764
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
765
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
766
- Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
767
- Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
768
- Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
769
- Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
770
- Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
771
- Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
772
- Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
773
- Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(9, varg9);
774
- Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(10, varg10);
775
- Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(11, varg11);
964
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
965
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
966
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
967
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
968
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
969
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
970
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
971
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
972
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
973
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
974
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
975
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
976
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
977
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
978
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
979
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
980
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
981
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
982
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
983
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
984
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
985
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
986
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
987
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
776
988
 
777
989
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
778
990
  return Qnil;
@@ -780,19 +992,32 @@ call(int argc, VALUE* argv, VALUE self)
780
992
  rb_scan_args(argc, argv, args->formatString(Num_Args)
781
993
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12);
782
994
 
783
- Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
784
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
785
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
786
- Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
787
- Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
788
- Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
789
- Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
790
- Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
791
- Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
792
- Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
793
- Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(10, varg10);
794
- Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(11, varg11);
795
- Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(12, varg12);
995
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
996
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
997
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
998
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
999
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1000
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1001
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1002
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1003
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1004
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1005
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1006
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1007
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1008
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1009
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1010
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1011
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1012
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1013
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1014
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1015
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1016
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
1017
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
1018
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
1019
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
1020
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
796
1021
 
797
1022
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
798
1023
  return Qnil;
@@ -859,35 +1084,58 @@ call(int argc, VALUE *argv, VALUE self)
859
1084
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11);
860
1085
 
861
1086
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
862
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
863
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
864
- Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
865
- Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
866
- Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
867
- Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
868
- Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
869
- Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
870
- Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
871
- Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(9, varg9);
872
- Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(10, varg10);
1087
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1088
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1089
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1090
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1091
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1092
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1093
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1094
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1095
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1096
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1097
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1098
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1099
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1100
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1101
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1102
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1103
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1104
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
1105
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1106
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
1107
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
1108
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
873
1109
 
874
1110
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11));
875
1111
  } else {
876
1112
  rb_scan_args(argc, argv, args->formatString(Num_Args)
877
1113
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11);
878
1114
 
879
- Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
880
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
881
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
882
- Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
883
- Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
884
- Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
885
- Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
886
- Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
887
- Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
888
- Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
889
- Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(10, varg10);
890
- Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(11, varg11);
1115
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1116
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1117
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1118
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1119
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1120
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1121
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1122
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1123
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1124
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1125
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1126
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1127
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1128
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1129
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1130
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1131
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1132
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1133
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1134
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1135
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1136
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
1137
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
1138
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
891
1139
 
892
1140
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11));
893
1141
  }
@@ -953,17 +1201,28 @@ call(int argc, VALUE* argv, VALUE self)
953
1201
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11);
954
1202
 
955
1203
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
956
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
957
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
958
- Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
959
- Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
960
- Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
961
- Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
962
- Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
963
- Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
964
- Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
965
- Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(9, varg9);
966
- Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(10, varg10);
1204
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1205
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1206
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1207
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1208
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1209
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1210
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1211
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1212
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1213
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1214
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1215
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1216
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1217
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1218
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1219
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1220
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1221
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
1222
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1223
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
1224
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
1225
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
967
1226
 
968
1227
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
969
1228
  return Qnil;
@@ -971,18 +1230,30 @@ call(int argc, VALUE* argv, VALUE self)
971
1230
  rb_scan_args(argc, argv, args->formatString(Num_Args)
972
1231
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11);
973
1232
 
974
- Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
975
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
976
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
977
- Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
978
- Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
979
- Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
980
- Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
981
- Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
982
- Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
983
- Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
984
- Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(10, varg10);
985
- Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(11, varg11);
1233
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1234
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1235
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1236
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1237
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1238
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1239
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1240
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1241
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1242
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1243
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1244
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1245
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1246
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1247
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1248
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1249
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1250
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1251
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1252
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1253
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1254
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
1255
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
1256
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
986
1257
 
987
1258
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
988
1259
  return Qnil;
@@ -1049,33 +1320,54 @@ call(int argc, VALUE *argv, VALUE self)
1049
1320
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10);
1050
1321
 
1051
1322
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
1052
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
1053
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
1054
- Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
1055
- Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
1056
- Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
1057
- Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
1058
- Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
1059
- Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
1060
- Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
1061
- Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(9, varg9);
1323
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1324
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1325
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1326
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1327
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1328
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1329
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1330
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1331
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1332
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1333
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1334
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1335
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1336
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1337
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1338
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1339
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1340
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
1341
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1342
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
1062
1343
 
1063
1344
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10));
1064
1345
  } else {
1065
1346
  rb_scan_args(argc, argv, args->formatString(Num_Args)
1066
1347
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10);
1067
1348
 
1068
- Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
1069
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
1070
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
1071
- Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
1072
- Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
1073
- Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
1074
- Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
1075
- Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
1076
- Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
1077
- Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
1078
- Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(10, varg10);
1349
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1350
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1351
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1352
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1353
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1354
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1355
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1356
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1357
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1358
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1359
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1360
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1361
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1362
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1363
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1364
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1365
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1366
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1367
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1368
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1369
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1370
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
1079
1371
 
1080
1372
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10));
1081
1373
  }
@@ -1141,16 +1433,26 @@ call(int argc, VALUE* argv, VALUE self)
1141
1433
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10);
1142
1434
 
1143
1435
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
1144
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
1145
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
1146
- Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
1147
- Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
1148
- Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
1149
- Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
1150
- Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
1151
- Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
1152
- Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
1153
- Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(9, varg9);
1436
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1437
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1438
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1439
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1440
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1441
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1442
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1443
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1444
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1445
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1446
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1447
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1448
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1449
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1450
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1451
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1452
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1453
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
1454
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1455
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
1154
1456
 
1155
1457
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
1156
1458
  return Qnil;
@@ -1158,17 +1460,28 @@ call(int argc, VALUE* argv, VALUE self)
1158
1460
  rb_scan_args(argc, argv, args->formatString(Num_Args)
1159
1461
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10);
1160
1462
 
1161
- Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
1162
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
1163
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
1164
- Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
1165
- Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
1166
- Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
1167
- Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
1168
- Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
1169
- Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
1170
- Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
1171
- Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(10, varg10);
1463
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1464
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1465
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1466
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1467
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1468
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1469
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1470
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1471
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1472
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1473
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1474
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1475
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1476
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1477
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1478
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1479
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1480
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1481
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1482
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1483
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1484
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
1172
1485
 
1173
1486
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
1174
1487
  return Qnil;
@@ -1235,31 +1548,50 @@ call(int argc, VALUE *argv, VALUE self)
1235
1548
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9);
1236
1549
 
1237
1550
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
1238
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
1239
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
1240
- Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
1241
- Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
1242
- Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
1243
- Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
1244
- Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
1245
- Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
1246
- Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
1551
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1552
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1553
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1554
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1555
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1556
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1557
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1558
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1559
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1560
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1561
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1562
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1563
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1564
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1565
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1566
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1567
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1568
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
1247
1569
 
1248
1570
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9));
1249
1571
  } else {
1250
1572
  rb_scan_args(argc, argv, args->formatString(Num_Args)
1251
1573
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9);
1252
1574
 
1253
- Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
1254
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
1255
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
1256
- Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
1257
- Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
1258
- Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
1259
- Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
1260
- Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
1261
- Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
1262
- Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
1575
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1576
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1577
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1578
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1579
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1580
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1581
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1582
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1583
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1584
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1585
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1586
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1587
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1588
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1589
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1590
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1591
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1592
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1593
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1594
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1263
1595
 
1264
1596
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9));
1265
1597
  }
@@ -1325,15 +1657,24 @@ call(int argc, VALUE* argv, VALUE self)
1325
1657
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9);
1326
1658
 
1327
1659
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
1328
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
1329
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
1330
- Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
1331
- Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
1332
- Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
1333
- Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
1334
- Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
1335
- Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
1336
- Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
1660
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1661
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1662
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1663
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1664
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1665
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1666
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1667
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1668
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1669
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1670
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1671
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1672
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1673
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1674
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1675
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1676
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1677
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
1337
1678
 
1338
1679
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
1339
1680
  return Qnil;
@@ -1341,16 +1682,26 @@ call(int argc, VALUE* argv, VALUE self)
1341
1682
  rb_scan_args(argc, argv, args->formatString(Num_Args)
1342
1683
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9);
1343
1684
 
1344
- Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
1345
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
1346
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
1347
- Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
1348
- Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
1349
- Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
1350
- Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
1351
- Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
1352
- Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
1353
- Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
1685
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1686
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1687
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1688
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1689
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1690
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1691
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1692
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1693
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1694
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1695
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1696
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1697
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1698
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1699
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1700
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1701
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1702
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1703
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1704
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1354
1705
 
1355
1706
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
1356
1707
  return Qnil;
@@ -1417,29 +1768,46 @@ call(int argc, VALUE *argv, VALUE self)
1417
1768
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8);
1418
1769
 
1419
1770
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
1420
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
1421
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
1422
- Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
1423
- Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
1424
- Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
1425
- Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
1426
- Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
1427
- Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
1771
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1772
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1773
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1774
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1775
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1776
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1777
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1778
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1779
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1780
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1781
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1782
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1783
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1784
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1785
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1786
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1428
1787
 
1429
1788
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8));
1430
1789
  } else {
1431
1790
  rb_scan_args(argc, argv, args->formatString(Num_Args)
1432
1791
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8);
1433
1792
 
1434
- Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
1435
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
1436
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
1437
- Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
1438
- Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
1439
- Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
1440
- Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
1441
- Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
1442
- Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
1793
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1794
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1795
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1796
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1797
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1798
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1799
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1800
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1801
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1802
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1803
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1804
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1805
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1806
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1807
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1808
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1809
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1810
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1443
1811
 
1444
1812
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8));
1445
1813
  }
@@ -1505,14 +1873,22 @@ call(int argc, VALUE* argv, VALUE self)
1505
1873
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8);
1506
1874
 
1507
1875
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
1508
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
1509
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
1510
- Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
1511
- Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
1512
- Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
1513
- Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
1514
- Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
1515
- Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
1876
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1877
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1878
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1879
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1880
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1881
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1882
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1883
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1884
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1885
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1886
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1887
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1888
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1889
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1890
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1891
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1516
1892
 
1517
1893
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
1518
1894
  return Qnil;
@@ -1520,15 +1896,24 @@ call(int argc, VALUE* argv, VALUE self)
1520
1896
  rb_scan_args(argc, argv, args->formatString(Num_Args)
1521
1897
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8);
1522
1898
 
1523
- Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
1524
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
1525
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
1526
- Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
1527
- Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
1528
- Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
1529
- Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
1530
- Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
1531
- Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
1899
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1900
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1901
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1902
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1903
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1904
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1905
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1906
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1907
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1908
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1909
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1910
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1911
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1912
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1913
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1914
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1915
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1916
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1532
1917
 
1533
1918
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
1534
1919
  return Qnil;
@@ -1595,27 +1980,42 @@ call(int argc, VALUE *argv, VALUE self)
1595
1980
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7);
1596
1981
 
1597
1982
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
1598
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
1599
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
1600
- Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
1601
- Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
1602
- Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
1603
- Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
1604
- Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
1983
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1984
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1985
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1986
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1987
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1988
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1989
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1990
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1991
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1992
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1993
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1994
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1995
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1996
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1605
1997
 
1606
1998
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7));
1607
1999
  } else {
1608
2000
  rb_scan_args(argc, argv, args->formatString(Num_Args)
1609
2001
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7);
1610
2002
 
1611
- Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
1612
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
1613
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
1614
- Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
1615
- Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
1616
- Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
1617
- Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
1618
- Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
2003
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2004
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2005
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2006
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2007
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2008
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2009
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2010
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2011
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2012
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2013
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2014
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
2015
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2016
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
2017
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
2018
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1619
2019
 
1620
2020
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7));
1621
2021
  }
@@ -1681,13 +2081,20 @@ call(int argc, VALUE* argv, VALUE self)
1681
2081
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7);
1682
2082
 
1683
2083
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
1684
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
1685
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
1686
- Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
1687
- Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
1688
- Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
1689
- Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
1690
- Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
2084
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2085
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2086
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2087
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2088
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2089
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2090
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2091
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2092
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2093
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
2094
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2095
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
2096
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
2097
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1691
2098
 
1692
2099
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
1693
2100
  return Qnil;
@@ -1695,14 +2102,22 @@ call(int argc, VALUE* argv, VALUE self)
1695
2102
  rb_scan_args(argc, argv, args->formatString(Num_Args)
1696
2103
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7);
1697
2104
 
1698
- Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
1699
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
1700
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
1701
- Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
1702
- Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
1703
- Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
1704
- Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
1705
- Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
2105
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2106
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2107
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2108
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2109
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2110
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2111
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2112
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2113
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2114
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2115
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2116
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
2117
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2118
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
2119
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
2120
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1706
2121
 
1707
2122
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
1708
2123
  return Qnil;
@@ -1769,25 +2184,38 @@ call(int argc, VALUE *argv, VALUE self)
1769
2184
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6);
1770
2185
 
1771
2186
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
1772
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
1773
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
1774
- Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
1775
- Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
1776
- Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
1777
- Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
2187
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2188
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2189
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2190
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2191
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2192
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2193
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2194
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2195
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2196
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
2197
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2198
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1778
2199
 
1779
2200
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6));
1780
2201
  } else {
1781
2202
  rb_scan_args(argc, argv, args->formatString(Num_Args)
1782
2203
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6);
1783
2204
 
1784
- Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
1785
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
1786
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
1787
- Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
1788
- Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
1789
- Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
1790
- Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
2205
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2206
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2207
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2208
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2209
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2210
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2211
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2212
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2213
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2214
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2215
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2216
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
2217
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2218
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1791
2219
 
1792
2220
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6));
1793
2221
  }
@@ -1853,12 +2281,18 @@ call(int argc, VALUE* argv, VALUE self)
1853
2281
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6);
1854
2282
 
1855
2283
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
1856
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
1857
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
1858
- Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
1859
- Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
1860
- Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
1861
- Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
2284
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2285
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2286
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2287
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2288
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2289
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2290
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2291
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2292
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2293
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
2294
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2295
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1862
2296
 
1863
2297
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
1864
2298
  return Qnil;
@@ -1866,13 +2300,20 @@ call(int argc, VALUE* argv, VALUE self)
1866
2300
  rb_scan_args(argc, argv, args->formatString(Num_Args)
1867
2301
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6);
1868
2302
 
1869
- Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
1870
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
1871
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
1872
- Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
1873
- Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
1874
- Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
1875
- Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
2303
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2304
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2305
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2306
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2307
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2308
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2309
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2310
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2311
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2312
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2313
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2314
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
2315
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2316
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1876
2317
 
1877
2318
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
1878
2319
  return Qnil;
@@ -1939,23 +2380,34 @@ call(int argc, VALUE *argv, VALUE self)
1939
2380
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5);
1940
2381
 
1941
2382
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
1942
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
1943
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
1944
- Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
1945
- Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
1946
- Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
2383
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2384
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2385
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2386
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2387
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2388
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2389
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2390
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2391
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2392
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1947
2393
 
1948
2394
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5));
1949
2395
  } else {
1950
2396
  rb_scan_args(argc, argv, args->formatString(Num_Args)
1951
2397
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5);
1952
2398
 
1953
- Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
1954
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
1955
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
1956
- Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
1957
- Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
1958
- Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
2399
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2400
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2401
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2402
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2403
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2404
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2405
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2406
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2407
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2408
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2409
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2410
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1959
2411
 
1960
2412
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5));
1961
2413
  }
@@ -2021,11 +2473,16 @@ call(int argc, VALUE* argv, VALUE self)
2021
2473
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5);
2022
2474
 
2023
2475
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
2024
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
2025
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
2026
- Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
2027
- Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
2028
- Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
2476
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2477
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2478
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2479
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2480
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2481
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2482
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2483
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2484
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2485
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
2029
2486
 
2030
2487
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5);
2031
2488
  return Qnil;
@@ -2033,12 +2490,18 @@ call(int argc, VALUE* argv, VALUE self)
2033
2490
  rb_scan_args(argc, argv, args->formatString(Num_Args)
2034
2491
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5);
2035
2492
 
2036
- Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
2037
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
2038
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
2039
- Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
2040
- Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
2041
- Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
2493
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2494
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2495
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2496
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2497
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2498
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2499
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2500
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2501
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2502
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2503
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2504
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
2042
2505
 
2043
2506
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5);
2044
2507
  return Qnil;
@@ -2105,21 +2568,30 @@ call(int argc, VALUE *argv, VALUE self)
2105
2568
  , &varg0, &varg1, &varg2, &varg3, &varg4);
2106
2569
 
2107
2570
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
2108
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
2109
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
2110
- Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
2111
- Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
2571
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2572
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2573
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2574
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2575
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2576
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2577
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2578
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2112
2579
 
2113
2580
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4));
2114
2581
  } else {
2115
2582
  rb_scan_args(argc, argv, args->formatString(Num_Args)
2116
2583
  , &varg0, &varg1, &varg2, &varg3, &varg4);
2117
2584
 
2118
- Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
2119
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
2120
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
2121
- Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
2122
- Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
2585
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2586
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2587
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2588
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2589
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2590
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2591
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2592
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2593
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2594
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2123
2595
 
2124
2596
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4));
2125
2597
  }
@@ -2185,10 +2657,14 @@ call(int argc, VALUE* argv, VALUE self)
2185
2657
  , &varg0, &varg1, &varg2, &varg3, &varg4);
2186
2658
 
2187
2659
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
2188
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
2189
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
2190
- Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
2191
- Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
2660
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2661
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2662
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2663
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2664
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2665
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2666
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2667
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2192
2668
 
2193
2669
  wrapper->func_(arg0, arg1, arg2, arg3, arg4);
2194
2670
  return Qnil;
@@ -2196,11 +2672,16 @@ call(int argc, VALUE* argv, VALUE self)
2196
2672
  rb_scan_args(argc, argv, args->formatString(Num_Args)
2197
2673
  , &varg0, &varg1, &varg2, &varg3, &varg4);
2198
2674
 
2199
- Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
2200
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
2201
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
2202
- Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
2203
- Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
2675
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2676
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2677
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2678
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2679
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2680
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2681
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2682
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2683
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2684
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2204
2685
 
2205
2686
  wrapper->func_(arg0, arg1, arg2, arg3, arg4);
2206
2687
  return Qnil;
@@ -2267,19 +2748,26 @@ call(int argc, VALUE *argv, VALUE self)
2267
2748
  , &varg0, &varg1, &varg2, &varg3);
2268
2749
 
2269
2750
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
2270
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
2271
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
2272
- Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
2751
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2752
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2753
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2754
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2755
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2756
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2273
2757
 
2274
2758
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3));
2275
2759
  } else {
2276
2760
  rb_scan_args(argc, argv, args->formatString(Num_Args)
2277
2761
  , &varg0, &varg1, &varg2, &varg3);
2278
2762
 
2279
- Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
2280
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
2281
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
2282
- Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
2763
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2764
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2765
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2766
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2767
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2768
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2769
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2770
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2283
2771
 
2284
2772
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3));
2285
2773
  }
@@ -2345,9 +2833,12 @@ call(int argc, VALUE* argv, VALUE self)
2345
2833
  , &varg0, &varg1, &varg2, &varg3);
2346
2834
 
2347
2835
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
2348
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
2349
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
2350
- Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
2836
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2837
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2838
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2839
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2840
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2841
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2351
2842
 
2352
2843
  wrapper->func_(arg0, arg1, arg2, arg3);
2353
2844
  return Qnil;
@@ -2355,10 +2846,14 @@ call(int argc, VALUE* argv, VALUE self)
2355
2846
  rb_scan_args(argc, argv, args->formatString(Num_Args)
2356
2847
  , &varg0, &varg1, &varg2, &varg3);
2357
2848
 
2358
- Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
2359
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
2360
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
2361
- Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
2849
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2850
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2851
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2852
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2853
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2854
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2855
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2856
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2362
2857
 
2363
2858
  wrapper->func_(arg0, arg1, arg2, arg3);
2364
2859
  return Qnil;
@@ -2425,17 +2920,22 @@ call(int argc, VALUE *argv, VALUE self)
2425
2920
  , &varg0, &varg1, &varg2);
2426
2921
 
2427
2922
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
2428
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
2429
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
2923
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2924
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2925
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2926
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2430
2927
 
2431
2928
  return to_ruby(wrapper->func_(arg0, arg1, arg2));
2432
2929
  } else {
2433
2930
  rb_scan_args(argc, argv, args->formatString(Num_Args)
2434
2931
  , &varg0, &varg1, &varg2);
2435
2932
 
2436
- Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
2437
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
2438
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
2933
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2934
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2935
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2936
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2937
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2938
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2439
2939
 
2440
2940
  return to_ruby(wrapper->func_(arg0, arg1, arg2));
2441
2941
  }
@@ -2501,8 +3001,10 @@ call(int argc, VALUE* argv, VALUE self)
2501
3001
  , &varg0, &varg1, &varg2);
2502
3002
 
2503
3003
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
2504
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
2505
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
3004
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3005
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
3006
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
3007
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2506
3008
 
2507
3009
  wrapper->func_(arg0, arg1, arg2);
2508
3010
  return Qnil;
@@ -2510,9 +3012,12 @@ call(int argc, VALUE* argv, VALUE self)
2510
3012
  rb_scan_args(argc, argv, args->formatString(Num_Args)
2511
3013
  , &varg0, &varg1, &varg2);
2512
3014
 
2513
- Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
2514
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
2515
- Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
3015
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
3016
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
3017
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3018
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
3019
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
3020
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2516
3021
 
2517
3022
  wrapper->func_(arg0, arg1, arg2);
2518
3023
  return Qnil;
@@ -2579,15 +3084,18 @@ call(int argc, VALUE *argv, VALUE self)
2579
3084
  , &varg0, &varg1);
2580
3085
 
2581
3086
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
2582
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
3087
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3088
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2583
3089
 
2584
3090
  return to_ruby(wrapper->func_(arg0, arg1));
2585
3091
  } else {
2586
3092
  rb_scan_args(argc, argv, args->formatString(Num_Args)
2587
3093
  , &varg0, &varg1);
2588
3094
 
2589
- Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
2590
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
3095
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
3096
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
3097
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3098
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2591
3099
 
2592
3100
  return to_ruby(wrapper->func_(arg0, arg1));
2593
3101
  }
@@ -2653,7 +3161,8 @@ call(int argc, VALUE* argv, VALUE self)
2653
3161
  , &varg0, &varg1);
2654
3162
 
2655
3163
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
2656
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
3164
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3165
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2657
3166
 
2658
3167
  wrapper->func_(arg0, arg1);
2659
3168
  return Qnil;
@@ -2661,8 +3170,10 @@ call(int argc, VALUE* argv, VALUE self)
2661
3170
  rb_scan_args(argc, argv, args->formatString(Num_Args)
2662
3171
  , &varg0, &varg1);
2663
3172
 
2664
- Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
2665
- Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
3173
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
3174
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
3175
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3176
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2666
3177
 
2667
3178
  wrapper->func_(arg0, arg1);
2668
3179
  return Qnil;
@@ -2736,7 +3247,8 @@ call(int argc, VALUE *argv, VALUE self)
2736
3247
  rb_scan_args(argc, argv, args->formatString(Num_Args)
2737
3248
  , &varg0);
2738
3249
 
2739
- Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
3250
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
3251
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2740
3252
 
2741
3253
  return to_ruby(wrapper->func_(arg0));
2742
3254
  }
@@ -2810,7 +3322,8 @@ call(int argc, VALUE* argv, VALUE self)
2810
3322
  rb_scan_args(argc, argv, args->formatString(Num_Args)
2811
3323
  , &varg0);
2812
3324
 
2813
- Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
3325
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
3326
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2814
3327
 
2815
3328
  wrapper->func_(arg0);
2816
3329
  return Qnil;