rice 2.1.0 → 3.0.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 (83) hide show
  1. checksums.yaml +5 -5
  2. data/COPYING +2 -2
  3. data/Doxyfile +4 -16
  4. data/Makefile.am +2 -2
  5. data/Makefile.in +28 -17
  6. data/{README → README.md} +323 -328
  7. data/aclocal.m4 +104 -107
  8. data/ax_cxx_compile_stdcxx.m4 +951 -0
  9. data/configure +549 -238
  10. data/configure.ac +3 -3
  11. data/extconf.rb +11 -10
  12. data/rice/Array.hpp +16 -16
  13. data/rice/Array.ipp +11 -11
  14. data/rice/Class_defn.hpp +1 -0
  15. data/rice/Constructor.hpp +27 -371
  16. data/rice/Data_Object_defn.hpp +3 -3
  17. data/rice/Director.hpp +3 -3
  18. data/rice/Enum.ipp +1 -1
  19. data/rice/Exception.cpp +2 -7
  20. data/rice/Hash.hpp +8 -5
  21. data/rice/Hash.ipp +2 -2
  22. data/rice/Makefile.am +1 -4
  23. data/rice/Makefile.in +80 -35
  24. data/rice/Module_impl.ipp +1 -1
  25. data/rice/Object.cpp +1 -1
  26. data/rice/Object.ipp +15 -1
  27. data/rice/Object_defn.hpp +24 -1
  28. data/rice/String.cpp +2 -7
  29. data/rice/Struct.cpp +2 -2
  30. data/rice/Struct.hpp +1 -1
  31. data/rice/Struct.ipp +1 -1
  32. data/rice/config.hpp +2 -2
  33. data/rice/config.hpp.in +2 -2
  34. data/rice/detail/Arguments.hpp +1 -1
  35. data/rice/detail/Auto_Function_Wrapper.ipp +512 -1025
  36. data/rice/detail/Auto_Member_Function_Wrapper.ipp +272 -545
  37. data/rice/detail/Iterator.hpp +2 -2
  38. data/rice/detail/method_data.cpp +8 -2
  39. data/rice/detail/ruby.hpp +1 -4
  40. data/rice/detail/ruby_version_code.hpp +1 -1
  41. data/rice/detail/wrap_function.hpp +32 -307
  42. data/rice/protect.hpp +3 -57
  43. data/rice/to_from_ruby.ipp +128 -4
  44. data/ruby/Makefile.in +11 -8
  45. data/ruby/lib/Makefile.in +10 -7
  46. data/ruby/lib/version.rb +1 -1
  47. data/sample/Makefile.am +10 -4
  48. data/sample/Makefile.in +20 -11
  49. data/sample/callbacks/extconf.rb +3 -0
  50. data/sample/callbacks/sample_callbacks.cpp +38 -0
  51. data/sample/callbacks/test.rb +28 -0
  52. data/test/Makefile.am +1 -0
  53. data/test/Makefile.in +118 -49
  54. data/test/embed_ruby.cpp +21 -0
  55. data/test/embed_ruby.hpp +4 -0
  56. data/test/ext/Makefile.in +10 -7
  57. data/test/test_Address_Registration_Guard.cpp +2 -1
  58. data/test/test_Array.cpp +2 -1
  59. data/test/test_Builtin_Object.cpp +2 -1
  60. data/test/test_Class.cpp +7 -4
  61. data/test/test_Data_Object.cpp +2 -1
  62. data/test/test_Data_Type.cpp +2 -1
  63. data/test/test_Director.cpp +2 -1
  64. data/test/test_Enum.cpp +24 -3
  65. data/test/test_Exception.cpp +2 -1
  66. data/test/test_Hash.cpp +2 -1
  67. data/test/test_Identifier.cpp +2 -1
  68. data/test/test_Memory_Management.cpp +2 -1
  69. data/test/test_Module.cpp +2 -1
  70. data/test/test_Object.cpp +13 -1
  71. data/test/test_String.cpp +2 -1
  72. data/test/test_Struct.cpp +2 -1
  73. data/test/test_Symbol.cpp +2 -1
  74. data/test/test_To_From_Ruby.cpp +102 -1
  75. data/test/test_global_functions.cpp +2 -1
  76. data/test/test_rice.rb +4 -0
  77. data/test/unittest.cpp +35 -9
  78. metadata +72 -16
  79. data/check_stdcxx_11.ac +0 -142
  80. data/rice/detail/object_call.hpp +0 -69
  81. data/rice/detail/object_call.ipp +0 -131
  82. data/rice/detail/traits.hpp +0 -43
  83. data/rice/detail/wrap_function.ipp +0 -514
data/rice/String.cpp CHANGED
@@ -3,13 +3,8 @@
3
3
  #include "protect.hpp"
4
4
  #include "detail/ruby.hpp"
5
5
 
6
- #ifdef HAVE_STDARG_PROTOTYPES
7
6
  #include <stdarg.h>
8
7
  #define va_init_list(a,b) va_start(a,b)
9
- #else
10
- #include <varargs.h>
11
- #define va_init_list(a,b) va_start(a)
12
- #endif
13
8
 
14
9
  Rice::String::
15
10
  String()
@@ -37,7 +32,7 @@ String(char const * s)
37
32
 
38
33
  Rice::String::
39
34
  String(std::string const & s)
40
- : Builtin_Object<T_STRING>(protect(rb_str_new, s.data(), s.length()))
35
+ : Builtin_Object<T_STRING>(protect(rb_str_new, s.data(), (long)s.length()))
41
36
  {
42
37
  }
43
38
 
@@ -52,7 +47,7 @@ format(char const * fmt, ...)
52
47
  {
53
48
  va_list args;
54
49
  char buf[BUFSIZ];
55
-
50
+
56
51
  va_init_list(args, fmt);
57
52
  vsnprintf(buf, BUFSIZ, fmt, args);
58
53
  buf[BUFSIZ - 1] = '\0';
data/rice/Struct.cpp CHANGED
@@ -59,11 +59,11 @@ define_member(
59
59
  return *this;
60
60
  }
61
61
 
62
- size_t Rice::Struct::
62
+ unsigned long Rice::Struct::
63
63
  offset_of(Identifier name) const
64
64
  {
65
65
  Symbol ruby_name(name);
66
- return from_ruby<size_t>(member_offset_[ruby_name]);
66
+ return from_ruby<unsigned long>(member_offset_[ruby_name]);
67
67
  }
68
68
 
69
69
  void Rice::Struct::
data/rice/Struct.hpp CHANGED
@@ -91,7 +91,7 @@ public:
91
91
  * \param member the name of the desired member.
92
92
  * \return the index of the given member.
93
93
  */
94
- size_t offset_of(Identifier name) const;
94
+ unsigned long offset_of(Identifier name) const;
95
95
 
96
96
  class Instance;
97
97
  friend class Instance;
data/rice/Struct.ipp CHANGED
@@ -12,7 +12,7 @@ template<>
12
12
  inline Object Struct::Instance::
13
13
  operator[]<Identifier>(Identifier member)
14
14
  {
15
- size_t index = type_.offset_of(member);
15
+ unsigned long index = type_.offset_of(member);
16
16
  return (*this)[index];
17
17
  }
18
18
 
data/rice/config.hpp CHANGED
@@ -1,8 +1,8 @@
1
1
  /* rice/config.hpp. Generated from config.hpp.in by configure. */
2
2
  /* rice/config.hpp.in. Generated from configure.ac by autoheader. */
3
3
 
4
- /* define if the compiler supports basic C++11 syntax */
5
- #define HAVE_CXX11 1
4
+ /* define if the compiler supports basic C++14 syntax */
5
+ #define HAVE_CXX14 1
6
6
 
7
7
  /* Define to 1 if you have the <env.h> header file. */
8
8
  /* #undef HAVE_ENV_H */
data/rice/config.hpp.in CHANGED
@@ -1,7 +1,7 @@
1
1
  /* rice/config.hpp.in. Generated from configure.ac by autoheader. */
2
2
 
3
- /* define if the compiler supports basic C++11 syntax */
4
- #undef HAVE_CXX11
3
+ /* define if the compiler supports basic C++14 syntax */
4
+ #undef HAVE_CXX14
5
5
 
6
6
  /* Define to 1 if you have the <env.h> header file. */
7
7
  #undef HAVE_ENV_H
data/rice/detail/Arguments.hpp CHANGED
@@ -38,7 +38,7 @@ namespace Rice {
38
38
  * In the case of no Args (default case), this
39
39
  * method uses the passed in full argument count
40
40
  */
41
- std::string formatString(int fullArgCount)
41
+ std::string formatString(size_t fullArgCount)
42
42
  {
43
43
  std::stringstream s;
44
44
  if(required_ == 0 && optional_ == 0)
data/rice/detail/Auto_Function_Wrapper.ipp CHANGED
@@ -10,7 +10,6 @@
10
10
  #include "method_data.hpp"
11
11
  #include "../ruby_try_catch.hpp"
12
12
  #include "../to_from_ruby.hpp"
13
- #include "traits.hpp"
14
13
  namespace Rice
15
14
  {
16
15
 
@@ -68,74 +67,43 @@ call(int argc, VALUE *argv, VALUE self)
68
67
 
69
68
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
70
69
 
71
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
72
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
73
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
74
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
75
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
76
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
77
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
78
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
79
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
80
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
81
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
82
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
83
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
84
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
85
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
86
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
87
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
88
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
89
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
90
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
91
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
92
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
93
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
94
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
95
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
96
- Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(12, varg12);
97
- typedef typename sanitize< Arg14_T >::Type Arg14_Type;
98
- Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(13, varg13);
99
- typedef typename sanitize< Arg15_T >::Type Arg15_Type;
100
- Arg15_Type arg15 = args->getArgumentOrDefault<Arg15_Type>(14, varg14);
70
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
71
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
72
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
73
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
74
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
75
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
76
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
77
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
78
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
79
+ Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(9, varg9);
80
+ Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(10, varg10);
81
+ Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(11, varg11);
82
+ Arg13_T arg13 = args->getArgumentOrDefault<Arg13_T>(12, varg12);
83
+ Arg14_T arg14 = args->getArgumentOrDefault<Arg14_T>(13, varg13);
84
+ Arg15_T arg15 = args->getArgumentOrDefault<Arg15_T>(14, varg14);
101
85
 
102
86
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15));
103
87
  } else {
104
88
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
105
89
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14, &varg15);
106
90
 
107
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
108
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
109
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
110
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
111
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
112
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
113
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
114
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
115
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
116
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
117
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
118
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
119
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
120
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
121
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
122
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
123
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
124
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
125
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
126
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
127
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
128
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
129
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
130
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
131
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
132
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
133
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
134
- Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
135
- typedef typename sanitize< Arg14_T >::Type Arg14_Type;
136
- Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(14, varg14);
137
- typedef typename sanitize< Arg15_T >::Type Arg15_Type;
138
- Arg15_Type arg15 = args->getArgumentOrDefault<Arg15_Type>(15, varg15);
91
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
92
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
93
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
94
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
95
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
96
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
97
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
98
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
99
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
100
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
101
+ Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(10, varg10);
102
+ Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(11, varg11);
103
+ Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(12, varg12);
104
+ Arg13_T arg13 = args->getArgumentOrDefault<Arg13_T>(13, varg13);
105
+ Arg14_T arg14 = args->getArgumentOrDefault<Arg14_T>(14, varg14);
106
+ Arg15_T arg15 = args->getArgumentOrDefault<Arg15_T>(15, varg15);
139
107
 
140
108
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15));
141
109
  }
@@ -208,36 +176,21 @@ call(int argc, VALUE* argv, VALUE self)
208
176
 
209
177
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
210
178
 
211
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
212
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
213
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
214
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
215
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
216
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
217
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
218
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
219
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
220
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
221
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
222
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
223
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
224
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
225
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
226
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
227
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
228
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
229
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
230
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
231
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
232
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
233
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
234
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
235
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
236
- Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(12, varg12);
237
- typedef typename sanitize< Arg14_T >::Type Arg14_Type;
238
- Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(13, varg13);
239
- typedef typename sanitize< Arg15_T >::Type Arg15_Type;
240
- Arg15_Type arg15 = args->getArgumentOrDefault<Arg15_Type>(14, varg14);
179
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
180
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
181
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
182
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
183
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
184
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
185
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
186
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
187
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
188
+ Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(9, varg9);
189
+ Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(10, varg10);
190
+ Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(11, varg11);
191
+ Arg13_T arg13 = args->getArgumentOrDefault<Arg13_T>(12, varg12);
192
+ Arg14_T arg14 = args->getArgumentOrDefault<Arg14_T>(13, varg13);
193
+ Arg15_T arg15 = args->getArgumentOrDefault<Arg15_T>(14, varg14);
241
194
 
242
195
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15);
243
196
  return Qnil;
@@ -245,38 +198,22 @@ call(int argc, VALUE* argv, VALUE self)
245
198
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
246
199
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14, &varg15);
247
200
 
248
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
249
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
250
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
251
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
252
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
253
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
254
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
255
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
256
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
257
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
258
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
259
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
260
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
261
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
262
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
263
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
264
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
265
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
266
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
267
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
268
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
269
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
270
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
271
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
272
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
273
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
274
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
275
- Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
276
- typedef typename sanitize< Arg14_T >::Type Arg14_Type;
277
- Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(14, varg14);
278
- typedef typename sanitize< Arg15_T >::Type Arg15_Type;
279
- Arg15_Type arg15 = args->getArgumentOrDefault<Arg15_Type>(15, varg15);
201
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
202
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
203
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
204
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
205
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
206
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
207
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
208
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
209
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
210
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
211
+ Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(10, varg10);
212
+ Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(11, varg11);
213
+ Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(12, varg12);
214
+ Arg13_T arg13 = args->getArgumentOrDefault<Arg13_T>(13, varg13);
215
+ Arg14_T arg14 = args->getArgumentOrDefault<Arg14_T>(14, varg14);
216
+ Arg15_T arg15 = args->getArgumentOrDefault<Arg15_T>(15, varg15);
280
217
 
281
218
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15);
282
219
  return Qnil;
@@ -351,70 +288,41 @@ call(int argc, VALUE *argv, VALUE self)
351
288
 
352
289
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
353
290
 
354
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
355
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
356
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
357
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
358
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
359
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
360
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
361
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
362
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
363
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
364
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
365
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
366
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
367
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
368
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
369
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
370
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
371
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
372
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
373
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
374
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
375
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
376
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
377
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
378
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
379
- Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(12, varg12);
380
- typedef typename sanitize< Arg14_T >::Type Arg14_Type;
381
- Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(13, varg13);
291
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
292
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
293
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
294
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
295
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
296
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
297
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
298
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
299
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
300
+ Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(9, varg9);
301
+ Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(10, varg10);
302
+ Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(11, varg11);
303
+ Arg13_T arg13 = args->getArgumentOrDefault<Arg13_T>(12, varg12);
304
+ Arg14_T arg14 = args->getArgumentOrDefault<Arg14_T>(13, varg13);
382
305
 
383
306
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14));
384
307
  } else {
385
308
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
386
309
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14);
387
310
 
388
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
389
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
390
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
391
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
392
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
393
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
394
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
395
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
396
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
397
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
398
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
399
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
400
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
401
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
402
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
403
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
404
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
405
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
406
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
407
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
408
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
409
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
410
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
411
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
412
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
413
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
414
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
415
- Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
416
- typedef typename sanitize< Arg14_T >::Type Arg14_Type;
417
- Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(14, varg14);
311
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
312
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
313
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
314
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
315
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
316
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
317
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
318
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
319
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
320
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
321
+ Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(10, varg10);
322
+ Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(11, varg11);
323
+ Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(12, varg12);
324
+ Arg13_T arg13 = args->getArgumentOrDefault<Arg13_T>(13, varg13);
325
+ Arg14_T arg14 = args->getArgumentOrDefault<Arg14_T>(14, varg14);
418
326
 
419
327
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14));
420
328
  }
@@ -487,34 +395,20 @@ call(int argc, VALUE* argv, VALUE self)
487
395
 
488
396
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
489
397
 
490
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
491
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
492
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
493
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
494
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
495
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
496
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
497
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
498
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
499
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
500
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
501
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
502
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
503
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
504
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
505
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
506
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
507
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
508
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
509
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
510
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
511
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
512
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
513
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
514
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
515
- Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(12, varg12);
516
- typedef typename sanitize< Arg14_T >::Type Arg14_Type;
517
- Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(13, varg13);
398
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
399
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
400
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
401
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
402
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
403
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
404
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
405
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
406
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
407
+ Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(9, varg9);
408
+ Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(10, varg10);
409
+ Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(11, varg11);
410
+ Arg13_T arg13 = args->getArgumentOrDefault<Arg13_T>(12, varg12);
411
+ Arg14_T arg14 = args->getArgumentOrDefault<Arg14_T>(13, varg13);
518
412
 
519
413
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
520
414
  return Qnil;
@@ -522,36 +416,21 @@ call(int argc, VALUE* argv, VALUE self)
522
416
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
523
417
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14);
524
418
 
525
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
526
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
527
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
528
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
529
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
530
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
531
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
532
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
533
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
534
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
535
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
536
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
537
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
538
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
539
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
540
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
541
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
542
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
543
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
544
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
545
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
546
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
547
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
548
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
549
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
550
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
551
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
552
- Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
553
- typedef typename sanitize< Arg14_T >::Type Arg14_Type;
554
- Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(14, varg14);
419
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
420
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
421
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
422
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
423
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
424
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
425
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
426
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
427
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
428
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
429
+ Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(10, varg10);
430
+ Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(11, varg11);
431
+ Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(12, varg12);
432
+ Arg13_T arg13 = args->getArgumentOrDefault<Arg13_T>(13, varg13);
433
+ Arg14_T arg14 = args->getArgumentOrDefault<Arg14_T>(14, varg14);
555
434
 
556
435
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
557
436
  return Qnil;
@@ -626,66 +505,39 @@ call(int argc, VALUE *argv, VALUE self)
626
505
 
627
506
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
628
507
 
629
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
630
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
631
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
632
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
633
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
634
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
635
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
636
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
637
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
638
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
639
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
640
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
641
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
642
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
643
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
644
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
645
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
646
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
647
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
648
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
649
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
650
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
651
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
652
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
653
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
654
- Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(12, varg12);
508
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
509
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
510
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
511
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
512
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
513
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
514
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
515
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
516
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
517
+ Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(9, varg9);
518
+ Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(10, varg10);
519
+ Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(11, varg11);
520
+ Arg13_T arg13 = args->getArgumentOrDefault<Arg13_T>(12, varg12);
655
521
 
656
522
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13));
657
523
  } else {
658
524
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
659
525
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13);
660
526
 
661
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
662
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
663
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
664
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
665
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
666
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
667
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
668
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
669
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
670
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
671
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
672
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
673
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
674
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
675
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
676
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
677
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
678
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
679
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
680
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
681
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
682
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
683
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
684
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
685
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
686
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
687
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
688
- Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
527
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
528
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
529
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
530
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
531
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
532
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
533
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
534
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
535
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
536
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
537
+ Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(10, varg10);
538
+ Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(11, varg11);
539
+ Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(12, varg12);
540
+ Arg13_T arg13 = args->getArgumentOrDefault<Arg13_T>(13, varg13);
689
541
 
690
542
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13));
691
543
  }
@@ -758,32 +610,19 @@ call(int argc, VALUE* argv, VALUE self)
758
610
 
759
611
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
760
612
 
761
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
762
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
763
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
764
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
765
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
766
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
767
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
768
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
769
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
770
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
771
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
772
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
773
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
774
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
775
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
776
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
777
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
778
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
779
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
780
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
781
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
782
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
783
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
784
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
785
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
786
- Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(12, varg12);
613
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
614
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
615
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
616
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
617
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
618
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
619
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
620
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
621
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
622
+ Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(9, varg9);
623
+ Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(10, varg10);
624
+ Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(11, varg11);
625
+ Arg13_T arg13 = args->getArgumentOrDefault<Arg13_T>(12, varg12);
787
626
 
788
627
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
789
628
  return Qnil;
@@ -791,34 +630,20 @@ call(int argc, VALUE* argv, VALUE self)
791
630
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
792
631
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13);
793
632
 
794
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
795
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
796
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
797
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
798
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
799
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
800
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
801
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
802
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
803
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
804
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
805
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
806
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
807
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
808
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
809
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
810
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
811
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
812
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
813
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
814
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
815
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
816
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
817
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
818
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
819
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
820
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
821
- Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
633
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
634
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
635
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
636
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
637
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
638
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
639
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
640
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
641
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
642
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
643
+ Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(10, varg10);
644
+ Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(11, varg11);
645
+ Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(12, varg12);
646
+ Arg13_T arg13 = args->getArgumentOrDefault<Arg13_T>(13, varg13);
822
647
 
823
648
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
824
649
  return Qnil;
@@ -893,62 +718,37 @@ call(int argc, VALUE *argv, VALUE self)
893
718
 
894
719
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
895
720
 
896
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
897
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
898
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
899
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
900
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
901
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
902
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
903
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
904
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
905
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
906
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
907
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
908
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
909
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
910
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
911
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
912
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
913
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
914
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
915
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
916
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
917
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
918
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
919
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
721
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
722
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
723
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
724
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
725
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
726
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
727
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
728
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
729
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
730
+ Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(9, varg9);
731
+ Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(10, varg10);
732
+ Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(11, varg11);
920
733
 
921
734
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12));
922
735
  } else {
923
736
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
924
737
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12);
925
738
 
926
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
927
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
928
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
929
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
930
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
931
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
932
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
933
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
934
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
935
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
936
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
937
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
938
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
939
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
940
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
941
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
942
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
943
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
944
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
945
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
946
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
947
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
948
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
949
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
950
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
951
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
739
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
740
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
741
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
742
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
743
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
744
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
745
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
746
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
747
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
748
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
749
+ Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(10, varg10);
750
+ Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(11, varg11);
751
+ Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(12, varg12);
952
752
 
953
753
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12));
954
754
  }
@@ -1021,30 +821,18 @@ call(int argc, VALUE* argv, VALUE self)
1021
821
 
1022
822
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
1023
823
 
1024
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1025
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1026
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1027
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1028
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1029
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1030
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1031
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1032
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1033
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1034
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1035
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1036
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1037
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1038
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1039
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1040
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1041
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
1042
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1043
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
1044
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
1045
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
1046
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
1047
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
824
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
825
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
826
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
827
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
828
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
829
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
830
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
831
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
832
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
833
+ Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(9, varg9);
834
+ Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(10, varg10);
835
+ Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(11, varg11);
1048
836
 
1049
837
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
1050
838
  return Qnil;
@@ -1052,32 +840,19 @@ call(int argc, VALUE* argv, VALUE self)
1052
840
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
1053
841
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12);
1054
842
 
1055
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1056
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1057
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1058
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1059
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1060
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1061
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1062
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1063
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1064
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1065
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1066
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1067
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1068
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1069
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1070
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1071
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1072
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1073
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1074
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1075
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1076
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
1077
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
1078
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
1079
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
1080
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
843
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
844
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
845
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
846
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
847
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
848
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
849
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
850
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
851
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
852
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
853
+ Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(10, varg10);
854
+ Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(11, varg11);
855
+ Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(12, varg12);
1081
856
 
1082
857
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
1083
858
  return Qnil;
@@ -1152,58 +927,35 @@ call(int argc, VALUE *argv, VALUE self)
1152
927
 
1153
928
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
1154
929
 
1155
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1156
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1157
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1158
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1159
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1160
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1161
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1162
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1163
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1164
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1165
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1166
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1167
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1168
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1169
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1170
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1171
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1172
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
1173
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1174
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
1175
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
1176
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
930
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
931
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
932
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
933
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
934
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
935
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
936
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
937
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
938
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
939
+ Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(9, varg9);
940
+ Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(10, varg10);
1177
941
 
1178
942
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11));
1179
943
  } else {
1180
944
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
1181
945
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11);
1182
946
 
1183
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1184
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1185
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1186
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1187
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1188
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1189
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1190
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1191
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1192
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1193
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1194
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1195
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1196
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1197
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1198
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1199
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1200
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1201
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1202
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1203
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1204
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
1205
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
1206
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
947
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
948
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
949
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
950
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
951
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
952
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
953
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
954
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
955
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
956
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
957
+ Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(10, varg10);
958
+ Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(11, varg11);
1207
959
 
1208
960
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11));
1209
961
  }
@@ -1276,28 +1028,17 @@ call(int argc, VALUE* argv, VALUE self)
1276
1028
 
1277
1029
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
1278
1030
 
1279
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1280
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1281
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1282
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1283
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1284
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1285
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1286
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1287
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1288
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1289
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1290
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1291
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1292
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1293
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1294
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1295
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1296
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
1297
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1298
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
1299
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
1300
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
1031
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
1032
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
1033
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
1034
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
1035
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
1036
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
1037
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
1038
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
1039
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
1040
+ Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(9, varg9);
1041
+ Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(10, varg10);
1301
1042
 
1302
1043
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
1303
1044
  return Qnil;
@@ -1305,30 +1046,18 @@ call(int argc, VALUE* argv, VALUE self)
1305
1046
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
1306
1047
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11);
1307
1048
 
1308
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1309
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1310
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1311
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1312
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1313
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1314
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1315
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1316
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1317
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1318
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1319
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1320
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1321
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1322
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1323
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1324
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1325
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1326
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1327
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1328
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1329
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
1330
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
1331
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
1049
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
1050
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
1051
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
1052
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
1053
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
1054
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
1055
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
1056
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
1057
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
1058
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
1059
+ Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(10, varg10);
1060
+ Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(11, varg11);
1332
1061
 
1333
1062
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
1334
1063
  return Qnil;
@@ -1403,54 +1132,33 @@ call(int argc, VALUE *argv, VALUE self)
1403
1132
 
1404
1133
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
1405
1134
 
1406
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1407
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1408
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1409
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1410
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1411
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1412
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1413
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1414
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1415
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1416
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1417
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1418
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1419
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1420
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1421
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1422
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1423
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
1424
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1425
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
1135
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
1136
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
1137
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
1138
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
1139
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
1140
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
1141
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
1142
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
1143
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
1144
+ Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(9, varg9);
1426
1145
 
1427
1146
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10));
1428
1147
  } else {
1429
1148
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
1430
1149
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10);
1431
1150
 
1432
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1433
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1434
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1435
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1436
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1437
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1438
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1439
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1440
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1441
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1442
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1443
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1444
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1445
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1446
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1447
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1448
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1449
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1450
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1451
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1452
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1453
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
1151
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
1152
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
1153
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
1154
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
1155
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
1156
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
1157
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
1158
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
1159
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
1160
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
1161
+ Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(10, varg10);
1454
1162
 
1455
1163
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10));
1456
1164
  }
@@ -1523,26 +1231,16 @@ call(int argc, VALUE* argv, VALUE self)
1523
1231
 
1524
1232
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
1525
1233
 
1526
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1527
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1528
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1529
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1530
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1531
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1532
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1533
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1534
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1535
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1536
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1537
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1538
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1539
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1540
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1541
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1542
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1543
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
1544
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1545
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
1234
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
1235
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
1236
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
1237
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
1238
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
1239
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
1240
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
1241
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
1242
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
1243
+ Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(9, varg9);
1546
1244
 
1547
1245
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
1548
1246
  return Qnil;
@@ -1550,28 +1248,17 @@ call(int argc, VALUE* argv, VALUE self)
1550
1248
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
1551
1249
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10);
1552
1250
 
1553
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1554
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1555
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1556
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1557
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1558
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1559
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1560
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1561
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1562
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1563
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1564
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1565
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1566
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1567
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1568
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1569
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1570
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1571
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1572
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1573
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1574
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
1251
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
1252
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
1253
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
1254
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
1255
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
1256
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
1257
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
1258
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
1259
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
1260
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
1261
+ Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(10, varg10);
1575
1262
 
1576
1263
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
1577
1264
  return Qnil;
@@ -1646,50 +1333,31 @@ call(int argc, VALUE *argv, VALUE self)
1646
1333
 
1647
1334
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
1648
1335
 
1649
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1650
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1651
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1652
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1653
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1654
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1655
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1656
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1657
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1658
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1659
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1660
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1661
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1662
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1663
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1664
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1665
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1666
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
1336
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
1337
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
1338
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
1339
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
1340
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
1341
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
1342
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
1343
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
1344
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
1667
1345
 
1668
1346
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9));
1669
1347
  } else {
1670
1348
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
1671
1349
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9);
1672
1350
 
1673
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1674
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1675
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1676
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1677
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1678
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1679
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1680
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1681
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1682
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1683
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1684
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1685
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1686
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1687
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1688
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1689
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1690
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1691
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1692
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1351
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
1352
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
1353
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
1354
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
1355
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
1356
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
1357
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
1358
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
1359
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
1360
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
1693
1361
 
1694
1362
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9));
1695
1363
  }
@@ -1762,24 +1430,15 @@ call(int argc, VALUE* argv, VALUE self)
1762
1430
 
1763
1431
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
1764
1432
 
1765
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1766
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1767
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1768
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1769
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1770
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1771
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1772
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1773
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1774
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1775
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1776
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1777
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1778
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1779
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1780
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1781
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1782
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
1433
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
1434
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
1435
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
1436
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
1437
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
1438
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
1439
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
1440
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
1441
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
1783
1442
 
1784
1443
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
1785
1444
  return Qnil;
@@ -1787,26 +1446,16 @@ call(int argc, VALUE* argv, VALUE self)
1787
1446
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
1788
1447
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9);
1789
1448
 
1790
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1791
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1792
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1793
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1794
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1795
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1796
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1797
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1798
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1799
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1800
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1801
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1802
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1803
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1804
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1805
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1806
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1807
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1808
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1809
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1449
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
1450
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
1451
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
1452
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
1453
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
1454
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
1455
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
1456
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
1457
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
1458
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
1810
1459
 
1811
1460
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
1812
1461
  return Qnil;
@@ -1881,46 +1530,29 @@ call(int argc, VALUE *argv, VALUE self)
1881
1530
 
1882
1531
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
1883
1532
 
1884
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1885
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1886
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1887
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1888
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1889
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1890
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1891
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1892
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1893
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1894
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1895
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1896
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1897
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1898
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1899
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1533
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
1534
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
1535
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
1536
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
1537
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
1538
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
1539
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
1540
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
1900
1541
 
1901
1542
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8));
1902
1543
  } else {
1903
1544
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
1904
1545
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8);
1905
1546
 
1906
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1907
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1908
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1909
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1910
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1911
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1912
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1913
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1914
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1915
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1916
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1917
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1918
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1919
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1920
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1921
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1922
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1923
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1547
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
1548
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
1549
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
1550
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
1551
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
1552
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
1553
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
1554
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
1555
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
1924
1556
 
1925
1557
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8));
1926
1558
  }
@@ -1993,22 +1625,14 @@ call(int argc, VALUE* argv, VALUE self)
1993
1625
 
1994
1626
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
1995
1627
 
1996
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1997
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1998
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1999
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2000
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2001
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2002
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2003
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2004
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2005
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
2006
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2007
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
2008
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
2009
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
2010
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
2011
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1628
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
1629
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
1630
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
1631
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
1632
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
1633
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
1634
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
1635
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
2012
1636
 
2013
1637
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
2014
1638
  return Qnil;
@@ -2016,24 +1640,15 @@ call(int argc, VALUE* argv, VALUE self)
2016
1640
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
2017
1641
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8);
2018
1642
 
2019
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2020
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2021
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2022
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2023
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2024
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2025
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2026
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2027
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2028
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2029
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2030
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
2031
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2032
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
2033
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
2034
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
2035
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
2036
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1643
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
1644
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
1645
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
1646
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
1647
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
1648
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
1649
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
1650
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
1651
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
2037
1652
 
2038
1653
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
2039
1654
  return Qnil;
@@ -2108,42 +1723,27 @@ call(int argc, VALUE *argv, VALUE self)
2108
1723
 
2109
1724
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
2110
1725
 
2111
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2112
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2113
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2114
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2115
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2116
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2117
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2118
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2119
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2120
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
2121
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2122
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
2123
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
2124
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1726
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
1727
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
1728
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
1729
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
1730
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
1731
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
1732
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
2125
1733
 
2126
1734
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7));
2127
1735
  } else {
2128
1736
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
2129
1737
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7);
2130
1738
 
2131
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2132
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2133
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2134
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2135
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2136
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2137
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2138
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2139
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2140
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2141
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2142
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
2143
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2144
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
2145
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
2146
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1739
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
1740
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
1741
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
1742
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
1743
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
1744
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
1745
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
1746
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
2147
1747
 
2148
1748
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7));
2149
1749
  }
@@ -2216,20 +1816,13 @@ call(int argc, VALUE* argv, VALUE self)
2216
1816
 
2217
1817
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
2218
1818
 
2219
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2220
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2221
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2222
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2223
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2224
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2225
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2226
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2227
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2228
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
2229
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2230
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
2231
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
2232
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1819
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
1820
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
1821
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
1822
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
1823
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
1824
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
1825
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
2233
1826
 
2234
1827
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
2235
1828
  return Qnil;
@@ -2237,22 +1830,14 @@ call(int argc, VALUE* argv, VALUE self)
2237
1830
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
2238
1831
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7);
2239
1832
 
2240
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2241
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2242
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2243
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2244
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2245
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2246
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2247
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2248
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2249
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2250
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2251
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
2252
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2253
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
2254
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
2255
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1833
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
1834
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
1835
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
1836
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
1837
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
1838
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
1839
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
1840
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
2256
1841
 
2257
1842
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
2258
1843
  return Qnil;
@@ -2327,38 +1912,25 @@ call(int argc, VALUE *argv, VALUE self)
2327
1912
 
2328
1913
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
2329
1914
 
2330
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2331
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2332
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2333
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2334
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2335
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2336
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2337
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2338
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2339
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
2340
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2341
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1915
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
1916
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
1917
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
1918
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
1919
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
1920
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
2342
1921
 
2343
1922
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6));
2344
1923
  } else {
2345
1924
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
2346
1925
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6);
2347
1926
 
2348
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2349
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2350
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2351
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2352
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2353
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2354
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2355
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2356
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2357
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2358
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2359
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
2360
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2361
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1927
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
1928
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
1929
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
1930
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
1931
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
1932
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
1933
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
2362
1934
 
2363
1935
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6));
2364
1936
  }
@@ -2431,18 +2003,12 @@ call(int argc, VALUE* argv, VALUE self)
2431
2003
 
2432
2004
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
2433
2005
 
2434
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2435
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2436
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2437
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2438
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2439
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2440
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2441
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2442
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2443
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
2444
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2445
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
2006
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
2007
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
2008
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
2009
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
2010
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
2011
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
2446
2012
 
2447
2013
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
2448
2014
  return Qnil;
@@ -2450,20 +2016,13 @@ call(int argc, VALUE* argv, VALUE self)
2450
2016
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
2451
2017
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6);
2452
2018
 
2453
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2454
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2455
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2456
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2457
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2458
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2459
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2460
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2461
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2462
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2463
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2464
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
2465
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2466
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
2019
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
2020
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
2021
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
2022
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
2023
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
2024
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
2025
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
2467
2026
 
2468
2027
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
2469
2028
  return Qnil;
@@ -2538,34 +2097,23 @@ call(int argc, VALUE *argv, VALUE self)
2538
2097
 
2539
2098
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
2540
2099
 
2541
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2542
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2543
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2544
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2545
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2546
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2547
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2548
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2549
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2550
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
2100
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
2101
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
2102
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
2103
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
2104
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
2551
2105
 
2552
2106
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5));
2553
2107
  } else {
2554
2108
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
2555
2109
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5);
2556
2110
 
2557
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2558
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2559
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2560
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2561
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2562
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2563
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2564
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2565
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2566
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2567
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2568
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
2111
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
2112
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
2113
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
2114
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
2115
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
2116
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
2569
2117
 
2570
2118
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5));
2571
2119
  }
@@ -2638,16 +2186,11 @@ call(int argc, VALUE* argv, VALUE self)
2638
2186
 
2639
2187
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
2640
2188
 
2641
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2642
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2643
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2644
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2645
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2646
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2647
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2648
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2649
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2650
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
2189
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
2190
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
2191
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
2192
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
2193
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
2651
2194
 
2652
2195
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5);
2653
2196
  return Qnil;
@@ -2655,18 +2198,12 @@ call(int argc, VALUE* argv, VALUE self)
2655
2198
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
2656
2199
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5);
2657
2200
 
2658
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2659
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2660
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2661
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2662
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2663
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2664
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2665
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2666
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2667
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2668
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2669
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
2201
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
2202
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
2203
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
2204
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
2205
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
2206
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
2670
2207
 
2671
2208
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5);
2672
2209
  return Qnil;
@@ -2741,30 +2278,21 @@ call(int argc, VALUE *argv, VALUE self)
2741
2278
 
2742
2279
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
2743
2280
 
2744
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2745
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2746
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2747
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2748
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2749
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2750
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2751
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2281
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
2282
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
2283
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
2284
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
2752
2285
 
2753
2286
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4));
2754
2287
  } else {
2755
2288
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
2756
2289
  , &varg0, &varg1, &varg2, &varg3, &varg4);
2757
2290
 
2758
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2759
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2760
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2761
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2762
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2763
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2764
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2765
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2766
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2767
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2291
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
2292
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
2293
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
2294
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
2295
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
2768
2296
 
2769
2297
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4));
2770
2298
  }
@@ -2837,14 +2365,10 @@ call(int argc, VALUE* argv, VALUE self)
2837
2365
 
2838
2366
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
2839
2367
 
2840
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2841
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2842
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2843
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2844
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2845
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2846
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2847
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2368
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
2369
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
2370
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
2371
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
2848
2372
 
2849
2373
  wrapper->func_(arg0, arg1, arg2, arg3, arg4);
2850
2374
  return Qnil;
@@ -2852,16 +2376,11 @@ call(int argc, VALUE* argv, VALUE self)
2852
2376
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
2853
2377
  , &varg0, &varg1, &varg2, &varg3, &varg4);
2854
2378
 
2855
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2856
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2857
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2858
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2859
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2860
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2861
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2862
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2863
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2864
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2379
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
2380
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
2381
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
2382
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
2383
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
2865
2384
 
2866
2385
  wrapper->func_(arg0, arg1, arg2, arg3, arg4);
2867
2386
  return Qnil;
@@ -2936,26 +2455,19 @@ call(int argc, VALUE *argv, VALUE self)
2936
2455
 
2937
2456
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
2938
2457
 
2939
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2940
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2941
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2942
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2943
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2944
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2458
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
2459
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
2460
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
2945
2461
 
2946
2462
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3));
2947
2463
  } else {
2948
2464
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
2949
2465
  , &varg0, &varg1, &varg2, &varg3);
2950
2466
 
2951
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2952
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2953
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2954
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2955
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2956
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2957
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2958
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2467
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
2468
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
2469
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
2470
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
2959
2471
 
2960
2472
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3));
2961
2473
  }
@@ -3028,12 +2540,9 @@ call(int argc, VALUE* argv, VALUE self)
3028
2540
 
3029
2541
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
3030
2542
 
3031
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3032
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
3033
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
3034
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
3035
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
3036
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2543
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
2544
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
2545
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
3037
2546
 
3038
2547
  wrapper->func_(arg0, arg1, arg2, arg3);
3039
2548
  return Qnil;
@@ -3041,14 +2550,10 @@ call(int argc, VALUE* argv, VALUE self)
3041
2550
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
3042
2551
  , &varg0, &varg1, &varg2, &varg3);
3043
2552
 
3044
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
3045
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
3046
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3047
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
3048
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
3049
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
3050
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
3051
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2553
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
2554
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
2555
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
2556
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
3052
2557
 
3053
2558
  wrapper->func_(arg0, arg1, arg2, arg3);
3054
2559
  return Qnil;
@@ -3123,22 +2628,17 @@ call(int argc, VALUE *argv, VALUE self)
3123
2628
 
3124
2629
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
3125
2630
 
3126
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3127
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
3128
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
3129
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2631
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
2632
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
3130
2633
 
3131
2634
  return to_ruby(wrapper->func_(arg0, arg1, arg2));
3132
2635
  } else {
3133
2636
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
3134
2637
  , &varg0, &varg1, &varg2);
3135
2638
 
3136
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
3137
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
3138
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3139
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
3140
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
3141
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2639
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
2640
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
2641
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
3142
2642
 
3143
2643
  return to_ruby(wrapper->func_(arg0, arg1, arg2));
3144
2644
  }
@@ -3211,10 +2711,8 @@ call(int argc, VALUE* argv, VALUE self)
3211
2711
 
3212
2712
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
3213
2713
 
3214
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3215
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
3216
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
3217
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2714
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
2715
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
3218
2716
 
3219
2717
  wrapper->func_(arg0, arg1, arg2);
3220
2718
  return Qnil;
@@ -3222,12 +2720,9 @@ call(int argc, VALUE* argv, VALUE self)
3222
2720
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
3223
2721
  , &varg0, &varg1, &varg2);
3224
2722
 
3225
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
3226
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
3227
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3228
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
3229
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
3230
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2723
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
2724
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
2725
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
3231
2726
 
3232
2727
  wrapper->func_(arg0, arg1, arg2);
3233
2728
  return Qnil;
@@ -3302,18 +2797,15 @@ call(int argc, VALUE *argv, VALUE self)
3302
2797
 
3303
2798
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
3304
2799
 
3305
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3306
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2800
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
3307
2801
 
3308
2802
  return to_ruby(wrapper->func_(arg0, arg1));
3309
2803
  } else {
3310
2804
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
3311
2805
  , &varg0, &varg1);
3312
2806
 
3313
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
3314
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
3315
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3316
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2807
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
2808
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
3317
2809
 
3318
2810
  return to_ruby(wrapper->func_(arg0, arg1));
3319
2811
  }
@@ -3386,8 +2878,7 @@ call(int argc, VALUE* argv, VALUE self)
3386
2878
 
3387
2879
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
3388
2880
 
3389
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3390
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2881
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
3391
2882
 
3392
2883
  wrapper->func_(arg0, arg1);
3393
2884
  return Qnil;
@@ -3395,10 +2886,8 @@ call(int argc, VALUE* argv, VALUE self)
3395
2886
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
3396
2887
  , &varg0, &varg1);
3397
2888
 
3398
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
3399
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
3400
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3401
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2889
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
2890
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
3402
2891
 
3403
2892
  wrapper->func_(arg0, arg1);
3404
2893
  return Qnil;
@@ -3479,8 +2968,7 @@ call(int argc, VALUE *argv, VALUE self)
3479
2968
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
3480
2969
  , &varg0);
3481
2970
 
3482
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
3483
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2971
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
3484
2972
 
3485
2973
  return to_ruby(wrapper->func_(arg0));
3486
2974
  }
@@ -3560,8 +3048,7 @@ call(int argc, VALUE* argv, VALUE self)
3560
3048
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
3561
3049
  , &varg0);
3562
3050
 
3563
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
3564
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
3051
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
3565
3052
 
3566
3053
  wrapper->func_(arg0);
3567
3054
  return Qnil;