rice 1.2.0 → 1.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
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;