rice 1.3.1 → 1.3.2

Sign up to get free protection for your applications and to get access to all the features.
Files changed (34) hide show
  1. data/Doxyfile +1 -1
  2. data/Makefile.in +58 -142
  3. data/aclocal.m4 +112 -201
  4. data/config.guess +23 -84
  5. data/config.sub +23 -93
  6. data/configure +2727 -2406
  7. data/depcomp +14 -19
  8. data/install-sh +108 -120
  9. data/rice/Constructor.hpp +350 -322
  10. data/rice/Makefile.am +0 -1
  11. data/rice/Makefile.in +69 -119
  12. data/rice/config.hpp +2 -8
  13. data/rice/config.hpp.in +0 -6
  14. data/rice/detail/Auto_Function_Wrapper.hpp +1 -33
  15. data/rice/detail/Auto_Function_Wrapper.ipp +1009 -1060
  16. data/rice/detail/Auto_Member_Function_Wrapper.ipp +608 -672
  17. data/rice/detail/method_data.cpp +0 -4
  18. data/rice/detail/object_call.hpp +31 -48
  19. data/rice/detail/object_call.ipp +45 -61
  20. data/rice/detail/wrap_function.hpp +70 -74
  21. data/rice/detail/wrap_function.ipp +126 -143
  22. data/rice/protect.hpp +30 -30
  23. data/rice/protect.ipp +770 -696
  24. data/ruby.ac +0 -14
  25. data/ruby/Makefile.in +41 -108
  26. data/ruby/lib/Makefile.in +23 -64
  27. data/ruby/lib/version.rb +1 -1
  28. data/sample/Makefile.in +12 -36
  29. data/test/Makefile.in +59 -148
  30. data/test/ext/Makefile.in +12 -36
  31. data/test/test_Constructor.cpp +42 -153
  32. data/test/test_Module.cpp +4 -4
  33. metadata +132 -124
  34. data/rice/generate_code.rb +0 -1328
data/rice/detail/Auto_Member_Function_Wrapper.ipp CHANGED
@@ -45,49 +45,47 @@ call(int argc, VALUE* argv, VALUE self)
45
45
  try
46
46
  {
47
47
  Data_Object<Wrapped_Function> data(detail::method_data());
48
- wrapper =
49
- (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T, Arg14_T, Arg15_T> *)data.get();
48
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T, Arg14_T, Arg15_T> *)data.get();
50
49
  Arguments* args = wrapper->arguments_;
51
50
 
52
51
  VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12, varg13, varg14, varg15;
53
52
 
54
- rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(),
55
- &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14, &varg15);
53
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14, &varg15);
56
54
 
57
55
  Self_T * obj = from_ruby<Self_T *>(self);
58
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
59
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
60
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
61
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
62
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
63
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
64
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
65
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
66
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
67
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
68
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
69
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
70
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
71
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
72
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
73
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
74
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
75
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
76
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
77
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
78
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
79
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
80
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
81
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
82
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
83
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
84
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
85
- Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
86
- typedef typename sanitize< Arg14_T >::Type Arg14_Type;
87
- Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(14, varg14);
88
- typedef typename sanitize< Arg15_T >::Type Arg15_Type;
89
- Arg15_Type arg15 = args->getArgumentOrDefault<Arg15_Type>(15, varg15);
90
56
 
57
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
58
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
59
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
60
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
61
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
62
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
63
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
64
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
65
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
66
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
67
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
68
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
69
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
70
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
71
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
72
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
73
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
74
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
75
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
76
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
77
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
78
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
79
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
80
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
81
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
82
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
83
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
84
+ Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
85
+ typedef typename sanitize< Arg14_T >::Type Arg14_Type;
86
+ Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(14, varg14);
87
+ typedef typename sanitize< Arg15_T >::Type Arg15_Type;
88
+ Arg15_Type arg15 = args->getArgumentOrDefault<Arg15_Type>(15, varg15);
91
89
  Func func = wrapper->func_;
92
90
  return to_ruby((*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15));
93
91
  }
@@ -135,49 +133,47 @@ call(int argc, VALUE* argv, VALUE self)
135
133
  try
136
134
  {
137
135
  Data_Object<Wrapped_Function> data(detail::method_data());
138
- wrapper =
139
- (Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T, Arg14_T, Arg15_T> *)data.get();
136
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T, Arg14_T, Arg15_T> *)data.get();
140
137
  Arguments* args = wrapper->arguments_;
141
138
 
142
139
  VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12, varg13, varg14, varg15;
143
140
 
144
- rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(),
145
- &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14, &varg15);
141
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14, &varg15);
146
142
 
147
143
  Self_T * obj = from_ruby<Self_T *>(self);
148
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
149
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
150
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
151
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
152
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
153
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
154
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
155
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
156
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
157
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
158
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
159
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
160
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
161
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
162
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
163
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
164
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
165
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
166
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
167
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
168
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
169
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
170
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
171
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
172
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
173
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
174
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
175
- Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
176
- typedef typename sanitize< Arg14_T >::Type Arg14_Type;
177
- Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(14, varg14);
178
- typedef typename sanitize< Arg15_T >::Type Arg15_Type;
179
- Arg15_Type arg15 = args->getArgumentOrDefault<Arg15_Type>(15, varg15);
180
144
 
145
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
146
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
147
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
148
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
149
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
150
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
151
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
152
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
153
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
154
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
155
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
156
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
157
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
158
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
159
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
160
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
161
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
162
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
163
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
164
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
165
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
166
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
167
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
168
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
169
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
170
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
171
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
172
+ Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
173
+ typedef typename sanitize< Arg14_T >::Type Arg14_Type;
174
+ Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(14, varg14);
175
+ typedef typename sanitize< Arg15_T >::Type Arg15_Type;
176
+ Arg15_Type arg15 = args->getArgumentOrDefault<Arg15_Type>(15, varg15);
181
177
  Func func = wrapper->func_;
182
178
  (*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15);
183
179
  return Qnil;
@@ -227,47 +223,45 @@ call(int argc, VALUE* argv, VALUE self)
227
223
  try
228
224
  {
229
225
  Data_Object<Wrapped_Function> data(detail::method_data());
230
- wrapper =
231
- (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T, Arg14_T> *)data.get();
226
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T, Arg14_T> *)data.get();
232
227
  Arguments* args = wrapper->arguments_;
233
228
 
234
229
  VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12, varg13, varg14;
235
230
 
236
- rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(),
237
- &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14);
231
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14);
238
232
 
239
233
  Self_T * obj = from_ruby<Self_T *>(self);
240
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
241
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
242
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
243
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
244
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
245
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
246
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
247
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
248
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
249
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
250
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
251
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
252
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
253
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
254
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
255
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
256
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
257
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
258
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
259
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
260
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
261
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
262
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
263
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
264
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
265
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
266
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
267
- Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
268
- typedef typename sanitize< Arg14_T >::Type Arg14_Type;
269
- Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(14, varg14);
270
234
 
235
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
236
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
237
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
238
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
239
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
240
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
241
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
242
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
243
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
244
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
245
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
246
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
247
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
248
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
249
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
250
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
251
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
252
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
253
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
254
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
255
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
256
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
257
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
258
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
259
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
260
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
261
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
262
+ Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
263
+ typedef typename sanitize< Arg14_T >::Type Arg14_Type;
264
+ Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(14, varg14);
271
265
  Func func = wrapper->func_;
272
266
  return to_ruby((*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14));
273
267
  }
@@ -315,47 +309,45 @@ call(int argc, VALUE* argv, VALUE self)
315
309
  try
316
310
  {
317
311
  Data_Object<Wrapped_Function> data(detail::method_data());
318
- wrapper =
319
- (Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T, Arg14_T> *)data.get();
312
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T, Arg14_T> *)data.get();
320
313
  Arguments* args = wrapper->arguments_;
321
314
 
322
315
  VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12, varg13, varg14;
323
316
 
324
- rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(),
325
- &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14);
317
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14);
326
318
 
327
319
  Self_T * obj = from_ruby<Self_T *>(self);
328
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
329
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
330
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
331
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
332
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
333
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
334
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
335
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
336
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
337
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
338
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
339
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
340
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
341
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
342
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
343
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
344
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
345
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
346
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
347
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
348
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
349
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
350
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
351
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
352
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
353
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
354
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
355
- Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
356
- typedef typename sanitize< Arg14_T >::Type Arg14_Type;
357
- Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(14, varg14);
358
320
 
321
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
322
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
323
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
324
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
325
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
326
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
327
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
328
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
329
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
330
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
331
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
332
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
333
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
334
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
335
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
336
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
337
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
338
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
339
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
340
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
341
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
342
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
343
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
344
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
345
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
346
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
347
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
348
+ Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
349
+ typedef typename sanitize< Arg14_T >::Type Arg14_Type;
350
+ Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(14, varg14);
359
351
  Func func = wrapper->func_;
360
352
  (*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
361
353
  return Qnil;
@@ -405,45 +397,43 @@ call(int argc, VALUE* argv, VALUE self)
405
397
  try
406
398
  {
407
399
  Data_Object<Wrapped_Function> data(detail::method_data());
408
- wrapper =
409
- (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T> *)data.get();
400
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T> *)data.get();
410
401
  Arguments* args = wrapper->arguments_;
411
402
 
412
403
  VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12, varg13;
413
404
 
414
- rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(),
415
- &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13);
405
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13);
416
406
 
417
407
  Self_T * obj = from_ruby<Self_T *>(self);
418
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
419
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
420
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
421
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
422
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
423
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
424
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
425
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
426
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
427
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
428
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
429
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
430
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
431
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
432
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
433
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
434
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
435
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
436
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
437
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
438
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
439
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
440
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
441
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
442
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
443
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
444
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
445
- Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
446
408
 
409
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
410
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
411
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
412
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
413
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
414
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
415
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
416
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
417
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
418
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
419
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
420
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
421
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
422
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
423
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
424
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
425
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
426
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
427
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
428
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
429
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
430
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
431
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
432
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
433
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
434
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
435
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
436
+ Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
447
437
  Func func = wrapper->func_;
448
438
  return to_ruby((*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13));
449
439
  }
@@ -491,45 +481,43 @@ call(int argc, VALUE* argv, VALUE self)
491
481
  try
492
482
  {
493
483
  Data_Object<Wrapped_Function> data(detail::method_data());
494
- wrapper =
495
- (Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T> *)data.get();
484
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T> *)data.get();
496
485
  Arguments* args = wrapper->arguments_;
497
486
 
498
487
  VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12, varg13;
499
488
 
500
- rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(),
501
- &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13);
489
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13);
502
490
 
503
491
  Self_T * obj = from_ruby<Self_T *>(self);
504
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
505
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
506
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
507
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
508
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
509
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
510
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
511
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
512
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
513
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
514
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
515
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
516
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
517
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
518
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
519
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
520
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
521
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
522
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
523
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
524
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
525
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
526
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
527
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
528
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
529
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
530
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
531
- Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
532
492
 
493
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
494
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
495
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
496
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
497
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
498
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
499
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
500
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
501
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
502
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
503
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
504
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
505
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
506
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
507
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
508
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
509
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
510
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
511
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
512
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
513
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
514
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
515
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
516
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
517
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
518
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
519
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
520
+ Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
533
521
  Func func = wrapper->func_;
534
522
  (*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
535
523
  return Qnil;
@@ -579,43 +567,41 @@ call(int argc, VALUE* argv, VALUE self)
579
567
  try
580
568
  {
581
569
  Data_Object<Wrapped_Function> data(detail::method_data());
582
- wrapper =
583
- (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T> *)data.get();
570
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T> *)data.get();
584
571
  Arguments* args = wrapper->arguments_;
585
572
 
586
573
  VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12;
587
574
 
588
- rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(),
589
- &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12);
575
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12);
590
576
 
591
577
  Self_T * obj = from_ruby<Self_T *>(self);
592
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
593
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
594
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
595
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
596
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
597
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
598
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
599
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
600
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
601
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
602
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
603
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
604
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
605
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
606
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
607
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
608
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
609
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
610
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
611
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
612
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
613
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
614
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
615
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
616
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
617
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
618
578
 
579
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
580
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
581
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
582
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
583
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
584
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
585
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
586
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
587
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
588
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
589
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
590
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
591
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
592
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
593
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
594
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
595
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
596
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
597
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
598
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
599
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
600
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
601
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
602
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
603
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
604
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
619
605
  Func func = wrapper->func_;
620
606
  return to_ruby((*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12));
621
607
  }
@@ -663,43 +649,41 @@ call(int argc, VALUE* argv, VALUE self)
663
649
  try
664
650
  {
665
651
  Data_Object<Wrapped_Function> data(detail::method_data());
666
- wrapper =
667
- (Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T> *)data.get();
652
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T> *)data.get();
668
653
  Arguments* args = wrapper->arguments_;
669
654
 
670
655
  VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12;
671
656
 
672
- rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(),
673
- &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12);
657
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12);
674
658
 
675
659
  Self_T * obj = from_ruby<Self_T *>(self);
676
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
677
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
678
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
679
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
680
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
681
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
682
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
683
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
684
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
685
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
686
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
687
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
688
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
689
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
690
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
691
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
692
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
693
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
694
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
695
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
696
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
697
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
698
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
699
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
700
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
701
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
702
660
 
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);
703
687
  Func func = wrapper->func_;
704
688
  (*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
705
689
  return Qnil;
@@ -749,41 +733,39 @@ call(int argc, VALUE* argv, VALUE self)
749
733
  try
750
734
  {
751
735
  Data_Object<Wrapped_Function> data(detail::method_data());
752
- wrapper =
753
- (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T> *)data.get();
736
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T> *)data.get();
754
737
  Arguments* args = wrapper->arguments_;
755
738
 
756
739
  VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11;
757
740
 
758
- rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(),
759
- &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11);
741
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11);
760
742
 
761
743
  Self_T * obj = from_ruby<Self_T *>(self);
762
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
763
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
764
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
765
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
766
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
767
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
768
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
769
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
770
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
771
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
772
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
773
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
774
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
775
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
776
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
777
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
778
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
779
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
780
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
781
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
782
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
783
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
784
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
785
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
786
744
 
745
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
746
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
747
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
748
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
749
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
750
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
751
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
752
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
753
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
754
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
755
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
756
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
757
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
758
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
759
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
760
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
761
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
762
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
763
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
764
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
765
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
766
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
767
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
768
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
787
769
  Func func = wrapper->func_;
788
770
  return to_ruby((*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11));
789
771
  }
@@ -831,41 +813,39 @@ call(int argc, VALUE* argv, VALUE self)
831
813
  try
832
814
  {
833
815
  Data_Object<Wrapped_Function> data(detail::method_data());
834
- wrapper =
835
- (Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T> *)data.get();
816
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T> *)data.get();
836
817
  Arguments* args = wrapper->arguments_;
837
818
 
838
819
  VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11;
839
820
 
840
- rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(),
841
- &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11);
821
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11);
842
822
 
843
823
  Self_T * obj = from_ruby<Self_T *>(self);
844
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
845
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
846
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
847
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
848
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
849
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
850
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
851
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
852
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
853
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
854
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
855
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
856
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
857
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
858
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
859
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
860
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
861
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
862
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
863
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
864
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
865
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
866
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
867
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
868
824
 
825
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
826
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
827
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
828
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
829
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
830
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
831
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
832
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
833
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
834
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
835
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
836
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
837
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
838
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
839
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
840
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
841
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
842
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
843
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
844
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
845
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
846
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
847
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
848
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
869
849
  Func func = wrapper->func_;
870
850
  (*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
871
851
  return Qnil;
@@ -915,39 +895,37 @@ call(int argc, VALUE* argv, VALUE self)
915
895
  try
916
896
  {
917
897
  Data_Object<Wrapped_Function> data(detail::method_data());
918
- wrapper =
919
- (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T> *)data.get();
898
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T> *)data.get();
920
899
  Arguments* args = wrapper->arguments_;
921
900
 
922
901
  VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10;
923
902
 
924
- rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(),
925
- &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10);
903
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10);
926
904
 
927
905
  Self_T * obj = from_ruby<Self_T *>(self);
928
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
929
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
930
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
931
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
932
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
933
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
934
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
935
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
936
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
937
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
938
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
939
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
940
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
941
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
942
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
943
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
944
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
945
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
946
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
947
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
948
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
949
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
950
906
 
907
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
908
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
909
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
910
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
911
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
912
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
913
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
914
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
915
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
916
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
917
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
918
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
919
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
920
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
921
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
922
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
923
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
924
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
925
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
926
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
927
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
928
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
951
929
  Func func = wrapper->func_;
952
930
  return to_ruby((*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10));
953
931
  }
@@ -995,39 +973,37 @@ call(int argc, VALUE* argv, VALUE self)
995
973
  try
996
974
  {
997
975
  Data_Object<Wrapped_Function> data(detail::method_data());
998
- wrapper =
999
- (Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T> *)data.get();
976
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T> *)data.get();
1000
977
  Arguments* args = wrapper->arguments_;
1001
978
 
1002
979
  VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10;
1003
980
 
1004
- rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(),
1005
- &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10);
981
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10);
1006
982
 
1007
983
  Self_T * obj = from_ruby<Self_T *>(self);
1008
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1009
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1010
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1011
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1012
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1013
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1014
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1015
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1016
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1017
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1018
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1019
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1020
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1021
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1022
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1023
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1024
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1025
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1026
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1027
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1028
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1029
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
1030
984
 
985
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
986
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
987
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
988
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
989
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
990
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
991
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
992
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
993
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
994
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
995
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
996
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
997
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
998
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
999
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1000
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1001
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1002
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1003
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1004
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1005
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1006
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
1031
1007
  Func func = wrapper->func_;
1032
1008
  (*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
1033
1009
  return Qnil;
@@ -1077,37 +1053,35 @@ call(int argc, VALUE* argv, VALUE self)
1077
1053
  try
1078
1054
  {
1079
1055
  Data_Object<Wrapped_Function> data(detail::method_data());
1080
- wrapper =
1081
- (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T> *)data.get();
1056
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T> *)data.get();
1082
1057
  Arguments* args = wrapper->arguments_;
1083
1058
 
1084
1059
  VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9;
1085
1060
 
1086
- rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(),
1087
- &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9);
1061
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9);
1088
1062
 
1089
1063
  Self_T * obj = from_ruby<Self_T *>(self);
1090
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1091
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1092
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1093
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1094
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1095
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1096
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1097
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1098
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1099
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1100
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1101
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1102
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1103
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1104
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1105
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1106
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1107
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1108
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1109
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1110
1064
 
1065
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1066
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1067
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1068
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1069
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1070
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1071
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1072
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1073
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1074
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1075
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1076
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1077
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1078
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1079
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1080
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1081
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1082
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1083
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1084
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1111
1085
  Func func = wrapper->func_;
1112
1086
  return to_ruby((*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9));
1113
1087
  }
@@ -1155,37 +1129,35 @@ call(int argc, VALUE* argv, VALUE self)
1155
1129
  try
1156
1130
  {
1157
1131
  Data_Object<Wrapped_Function> data(detail::method_data());
1158
- wrapper =
1159
- (Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T> *)data.get();
1132
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T> *)data.get();
1160
1133
  Arguments* args = wrapper->arguments_;
1161
1134
 
1162
1135
  VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9;
1163
1136
 
1164
- rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(),
1165
- &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9);
1137
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9);
1166
1138
 
1167
1139
  Self_T * obj = from_ruby<Self_T *>(self);
1168
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1169
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1170
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1171
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1172
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1173
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1174
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1175
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1176
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1177
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1178
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1179
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1180
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1181
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1182
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1183
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1184
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1185
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1186
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1187
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1188
1140
 
1141
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1142
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1143
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1144
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1145
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1146
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1147
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1148
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1149
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1150
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1151
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1152
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1153
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1154
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1155
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1156
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1157
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1158
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1159
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1160
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1189
1161
  Func func = wrapper->func_;
1190
1162
  (*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
1191
1163
  return Qnil;
@@ -1235,35 +1207,33 @@ call(int argc, VALUE* argv, VALUE self)
1235
1207
  try
1236
1208
  {
1237
1209
  Data_Object<Wrapped_Function> data(detail::method_data());
1238
- wrapper =
1239
- (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T> *)data.get();
1210
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T> *)data.get();
1240
1211
  Arguments* args = wrapper->arguments_;
1241
1212
 
1242
1213
  VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8;
1243
1214
 
1244
- rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(),
1245
- &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8);
1215
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8);
1246
1216
 
1247
1217
  Self_T * obj = from_ruby<Self_T *>(self);
1248
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1249
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1250
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1251
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1252
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1253
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1254
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1255
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1256
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1257
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1258
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1259
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1260
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1261
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1262
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1263
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1264
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1265
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1266
1218
 
1219
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1220
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1221
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1222
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1223
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1224
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1225
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1226
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1227
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1228
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1229
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1230
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1231
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1232
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1233
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1234
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1235
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1236
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1267
1237
  Func func = wrapper->func_;
1268
1238
  return to_ruby((*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8));
1269
1239
  }
@@ -1311,35 +1281,33 @@ call(int argc, VALUE* argv, VALUE self)
1311
1281
  try
1312
1282
  {
1313
1283
  Data_Object<Wrapped_Function> data(detail::method_data());
1314
- wrapper =
1315
- (Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T> *)data.get();
1284
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T> *)data.get();
1316
1285
  Arguments* args = wrapper->arguments_;
1317
1286
 
1318
1287
  VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8;
1319
1288
 
1320
- rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(),
1321
- &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8);
1289
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8);
1322
1290
 
1323
1291
  Self_T * obj = from_ruby<Self_T *>(self);
1324
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1325
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1326
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1327
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1328
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1329
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1330
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1331
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1332
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1333
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1334
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1335
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1336
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1337
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1338
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1339
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1340
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1341
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1342
1292
 
1293
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1294
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1295
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1296
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1297
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1298
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1299
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1300
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1301
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1302
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1303
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1304
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1305
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1306
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1307
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1308
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1309
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1310
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1343
1311
  Func func = wrapper->func_;
1344
1312
  (*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
1345
1313
  return Qnil;
@@ -1389,33 +1357,31 @@ call(int argc, VALUE* argv, VALUE self)
1389
1357
  try
1390
1358
  {
1391
1359
  Data_Object<Wrapped_Function> data(detail::method_data());
1392
- wrapper =
1393
- (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T> *)data.get();
1360
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T> *)data.get();
1394
1361
  Arguments* args = wrapper->arguments_;
1395
1362
 
1396
1363
  VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7;
1397
1364
 
1398
- rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(),
1399
- &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7);
1365
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7);
1400
1366
 
1401
1367
  Self_T * obj = from_ruby<Self_T *>(self);
1402
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1403
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1404
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1405
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1406
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1407
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1408
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1409
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1410
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1411
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1412
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1413
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1414
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1415
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1416
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1417
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1418
1368
 
1369
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1370
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1371
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1372
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1373
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1374
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1375
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1376
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1377
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1378
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1379
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1380
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1381
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1382
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1383
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1384
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1419
1385
  Func func = wrapper->func_;
1420
1386
  return to_ruby((*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7));
1421
1387
  }
@@ -1463,33 +1429,31 @@ call(int argc, VALUE* argv, VALUE self)
1463
1429
  try
1464
1430
  {
1465
1431
  Data_Object<Wrapped_Function> data(detail::method_data());
1466
- wrapper =
1467
- (Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T> *)data.get();
1432
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T> *)data.get();
1468
1433
  Arguments* args = wrapper->arguments_;
1469
1434
 
1470
1435
  VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7;
1471
1436
 
1472
- rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(),
1473
- &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7);
1437
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7);
1474
1438
 
1475
1439
  Self_T * obj = from_ruby<Self_T *>(self);
1476
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1477
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1478
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1479
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1480
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1481
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1482
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1483
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1484
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1485
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1486
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1487
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1488
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1489
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1490
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1491
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1492
1440
 
1441
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1442
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1443
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1444
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1445
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1446
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1447
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1448
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1449
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1450
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1451
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1452
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1453
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1454
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1455
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1456
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1493
1457
  Func func = wrapper->func_;
1494
1458
  (*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
1495
1459
  return Qnil;
@@ -1539,31 +1503,29 @@ call(int argc, VALUE* argv, VALUE self)
1539
1503
  try
1540
1504
  {
1541
1505
  Data_Object<Wrapped_Function> data(detail::method_data());
1542
- wrapper =
1543
- (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T> *)data.get();
1506
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T> *)data.get();
1544
1507
  Arguments* args = wrapper->arguments_;
1545
1508
 
1546
1509
  VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6;
1547
1510
 
1548
- rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(),
1549
- &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6);
1511
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6);
1550
1512
 
1551
1513
  Self_T * obj = from_ruby<Self_T *>(self);
1552
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1553
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1554
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1555
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1556
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1557
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1558
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1559
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1560
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1561
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1562
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1563
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1564
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1565
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1566
1514
 
1515
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1516
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1517
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1518
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1519
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1520
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1521
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1522
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1523
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1524
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1525
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1526
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1527
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1528
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1567
1529
  Func func = wrapper->func_;
1568
1530
  return to_ruby((*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6));
1569
1531
  }
@@ -1611,31 +1573,29 @@ call(int argc, VALUE* argv, VALUE self)
1611
1573
  try
1612
1574
  {
1613
1575
  Data_Object<Wrapped_Function> data(detail::method_data());
1614
- wrapper =
1615
- (Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T> *)data.get();
1576
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T> *)data.get();
1616
1577
  Arguments* args = wrapper->arguments_;
1617
1578
 
1618
1579
  VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6;
1619
1580
 
1620
- rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(),
1621
- &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6);
1581
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6);
1622
1582
 
1623
1583
  Self_T * obj = from_ruby<Self_T *>(self);
1624
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1625
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1626
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1627
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1628
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1629
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1630
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1631
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1632
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1633
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1634
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1635
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1636
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1637
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1638
1584
 
1585
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1586
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1587
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1588
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1589
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1590
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1591
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1592
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1593
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1594
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1595
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1596
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1597
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1598
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1639
1599
  Func func = wrapper->func_;
1640
1600
  (*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
1641
1601
  return Qnil;
@@ -1685,29 +1645,27 @@ call(int argc, VALUE* argv, VALUE self)
1685
1645
  try
1686
1646
  {
1687
1647
  Data_Object<Wrapped_Function> data(detail::method_data());
1688
- wrapper =
1689
- (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T> *)data.get();
1648
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T> *)data.get();
1690
1649
  Arguments* args = wrapper->arguments_;
1691
1650
 
1692
1651
  VALUE varg0, varg1, varg2, varg3, varg4, varg5;
1693
1652
 
1694
- rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(),
1695
- &varg0, &varg1, &varg2, &varg3, &varg4, &varg5);
1653
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2, &varg3, &varg4, &varg5);
1696
1654
 
1697
1655
  Self_T * obj = from_ruby<Self_T *>(self);
1698
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1699
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1700
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1701
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1702
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1703
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1704
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1705
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1706
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1707
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1708
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1709
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1710
1656
 
1657
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1658
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1659
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1660
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1661
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1662
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1663
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1664
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1665
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1666
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1667
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1668
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1711
1669
  Func func = wrapper->func_;
1712
1670
  return to_ruby((*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5));
1713
1671
  }
@@ -1755,29 +1713,27 @@ call(int argc, VALUE* argv, VALUE self)
1755
1713
  try
1756
1714
  {
1757
1715
  Data_Object<Wrapped_Function> data(detail::method_data());
1758
- wrapper =
1759
- (Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T> *)data.get();
1716
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T> *)data.get();
1760
1717
  Arguments* args = wrapper->arguments_;
1761
1718
 
1762
1719
  VALUE varg0, varg1, varg2, varg3, varg4, varg5;
1763
1720
 
1764
- rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(),
1765
- &varg0, &varg1, &varg2, &varg3, &varg4, &varg5);
1721
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2, &varg3, &varg4, &varg5);
1766
1722
 
1767
1723
  Self_T * obj = from_ruby<Self_T *>(self);
1768
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1769
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1770
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1771
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1772
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1773
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1774
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1775
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1776
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1777
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1778
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1779
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1780
1724
 
1725
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1726
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1727
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1728
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1729
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1730
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1731
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1732
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1733
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1734
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1735
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1736
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1781
1737
  Func func = wrapper->func_;
1782
1738
  (*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5);
1783
1739
  return Qnil;
@@ -1827,27 +1783,25 @@ call(int argc, VALUE* argv, VALUE self)
1827
1783
  try
1828
1784
  {
1829
1785
  Data_Object<Wrapped_Function> data(detail::method_data());
1830
- wrapper =
1831
- (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T> *)data.get();
1786
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T> *)data.get();
1832
1787
  Arguments* args = wrapper->arguments_;
1833
1788
 
1834
1789
  VALUE varg0, varg1, varg2, varg3, varg4;
1835
1790
 
1836
- rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(),
1837
- &varg0, &varg1, &varg2, &varg3, &varg4);
1791
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2, &varg3, &varg4);
1838
1792
 
1839
1793
  Self_T * obj = from_ruby<Self_T *>(self);
1840
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1841
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1842
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1843
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1844
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1845
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1846
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1847
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1848
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1849
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1850
1794
 
1795
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1796
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1797
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1798
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1799
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1800
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1801
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1802
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1803
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1804
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1851
1805
  Func func = wrapper->func_;
1852
1806
  return to_ruby((*obj.*func)(arg0, arg1, arg2, arg3, arg4));
1853
1807
  }
@@ -1895,27 +1849,25 @@ call(int argc, VALUE* argv, VALUE self)
1895
1849
  try
1896
1850
  {
1897
1851
  Data_Object<Wrapped_Function> data(detail::method_data());
1898
- wrapper =
1899
- (Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T> *)data.get();
1852
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T> *)data.get();
1900
1853
  Arguments* args = wrapper->arguments_;
1901
1854
 
1902
1855
  VALUE varg0, varg1, varg2, varg3, varg4;
1903
1856
 
1904
- rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(),
1905
- &varg0, &varg1, &varg2, &varg3, &varg4);
1857
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2, &varg3, &varg4);
1906
1858
 
1907
1859
  Self_T * obj = from_ruby<Self_T *>(self);
1908
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1909
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1910
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1911
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1912
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1913
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1914
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1915
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1916
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1917
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1918
1860
 
1861
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1862
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1863
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1864
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1865
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1866
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1867
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1868
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1869
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1870
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1919
1871
  Func func = wrapper->func_;
1920
1872
  (*obj.*func)(arg0, arg1, arg2, arg3, arg4);
1921
1873
  return Qnil;
@@ -1965,25 +1917,23 @@ call(int argc, VALUE* argv, VALUE self)
1965
1917
  try
1966
1918
  {
1967
1919
  Data_Object<Wrapped_Function> data(detail::method_data());
1968
- wrapper =
1969
- (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T> *)data.get();
1920
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T> *)data.get();
1970
1921
  Arguments* args = wrapper->arguments_;
1971
1922
 
1972
1923
  VALUE varg0, varg1, varg2, varg3;
1973
1924
 
1974
- rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(),
1975
- &varg0, &varg1, &varg2, &varg3);
1925
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2, &varg3);
1976
1926
 
1977
1927
  Self_T * obj = from_ruby<Self_T *>(self);
1978
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1979
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1980
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1981
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1982
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1983
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1984
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1985
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1986
1928
 
1929
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1930
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1931
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1932
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1933
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1934
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1935
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1936
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1987
1937
  Func func = wrapper->func_;
1988
1938
  return to_ruby((*obj.*func)(arg0, arg1, arg2, arg3));
1989
1939
  }
@@ -2031,25 +1981,23 @@ call(int argc, VALUE* argv, VALUE self)
2031
1981
  try
2032
1982
  {
2033
1983
  Data_Object<Wrapped_Function> data(detail::method_data());
2034
- wrapper =
2035
- (Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T> *)data.get();
1984
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T> *)data.get();
2036
1985
  Arguments* args = wrapper->arguments_;
2037
1986
 
2038
1987
  VALUE varg0, varg1, varg2, varg3;
2039
1988
 
2040
- rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(),
2041
- &varg0, &varg1, &varg2, &varg3);
1989
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2, &varg3);
2042
1990
 
2043
1991
  Self_T * obj = from_ruby<Self_T *>(self);
2044
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2045
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2046
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2047
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2048
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2049
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2050
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2051
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2052
1992
 
1993
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1994
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1995
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1996
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1997
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1998
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1999
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2000
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2053
2001
  Func func = wrapper->func_;
2054
2002
  (*obj.*func)(arg0, arg1, arg2, arg3);
2055
2003
  return Qnil;
@@ -2099,23 +2047,21 @@ call(int argc, VALUE* argv, VALUE self)
2099
2047
  try
2100
2048
  {
2101
2049
  Data_Object<Wrapped_Function> data(detail::method_data());
2102
- wrapper =
2103
- (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T> *)data.get();
2050
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T> *)data.get();
2104
2051
  Arguments* args = wrapper->arguments_;
2105
2052
 
2106
2053
  VALUE varg0, varg1, varg2;
2107
2054
 
2108
- rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(),
2109
- &varg0, &varg1, &varg2);
2055
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2);
2110
2056
 
2111
2057
  Self_T * obj = from_ruby<Self_T *>(self);
2112
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2113
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2114
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2115
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2116
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2117
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2118
2058
 
2059
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2060
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2061
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2062
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2063
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2064
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2119
2065
  Func func = wrapper->func_;
2120
2066
  return to_ruby((*obj.*func)(arg0, arg1, arg2));
2121
2067
  }
@@ -2163,23 +2109,21 @@ call(int argc, VALUE* argv, VALUE self)
2163
2109
  try
2164
2110
  {
2165
2111
  Data_Object<Wrapped_Function> data(detail::method_data());
2166
- wrapper =
2167
- (Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T> *)data.get();
2112
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T> *)data.get();
2168
2113
  Arguments* args = wrapper->arguments_;
2169
2114
 
2170
2115
  VALUE varg0, varg1, varg2;
2171
2116
 
2172
- rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(),
2173
- &varg0, &varg1, &varg2);
2117
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2);
2174
2118
 
2175
2119
  Self_T * obj = from_ruby<Self_T *>(self);
2176
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2177
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2178
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2179
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2180
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2181
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2182
2120
 
2121
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2122
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2123
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2124
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2125
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2126
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2183
2127
  Func func = wrapper->func_;
2184
2128
  (*obj.*func)(arg0, arg1, arg2);
2185
2129
  return Qnil;
@@ -2229,21 +2173,19 @@ call(int argc, VALUE* argv, VALUE self)
2229
2173
  try
2230
2174
  {
2231
2175
  Data_Object<Wrapped_Function> data(detail::method_data());
2232
- wrapper =
2233
- (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T> *)data.get();
2176
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T> *)data.get();
2234
2177
  Arguments* args = wrapper->arguments_;
2235
2178
 
2236
2179
  VALUE varg0, varg1;
2237
2180
 
2238
- rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(),
2239
- &varg0, &varg1);
2181
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1);
2240
2182
 
2241
2183
  Self_T * obj = from_ruby<Self_T *>(self);
2242
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2243
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2244
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2245
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2246
2184
 
2185
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2186
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2187
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2188
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2247
2189
  Func func = wrapper->func_;
2248
2190
  return to_ruby((*obj.*func)(arg0, arg1));
2249
2191
  }
@@ -2291,21 +2233,19 @@ call(int argc, VALUE* argv, VALUE self)
2291
2233
  try
2292
2234
  {
2293
2235
  Data_Object<Wrapped_Function> data(detail::method_data());
2294
- wrapper =
2295
- (Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T> *)data.get();
2236
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T> *)data.get();
2296
2237
  Arguments* args = wrapper->arguments_;
2297
2238
 
2298
2239
  VALUE varg0, varg1;
2299
2240
 
2300
- rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(),
2301
- &varg0, &varg1);
2241
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1);
2302
2242
 
2303
2243
  Self_T * obj = from_ruby<Self_T *>(self);
2304
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2305
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2306
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2307
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2308
2244
 
2245
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2246
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2247
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2248
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2309
2249
  Func func = wrapper->func_;
2310
2250
  (*obj.*func)(arg0, arg1);
2311
2251
  return Qnil;
@@ -2355,19 +2295,17 @@ call(int argc, VALUE* argv, VALUE self)
2355
2295
  try
2356
2296
  {
2357
2297
  Data_Object<Wrapped_Function> data(detail::method_data());
2358
- wrapper =
2359
- (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T> *)data.get();
2298
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T> *)data.get();
2360
2299
  Arguments* args = wrapper->arguments_;
2361
2300
 
2362
2301
  VALUE varg0;
2363
2302
 
2364
- rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(),
2365
- &varg0);
2303
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0);
2366
2304
 
2367
2305
  Self_T * obj = from_ruby<Self_T *>(self);
2368
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2369
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2370
2306
 
2307
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2308
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2371
2309
  Func func = wrapper->func_;
2372
2310
  return to_ruby((*obj.*func)(arg0));
2373
2311
  }
@@ -2415,19 +2353,17 @@ call(int argc, VALUE* argv, VALUE self)
2415
2353
  try
2416
2354
  {
2417
2355
  Data_Object<Wrapped_Function> data(detail::method_data());
2418
- wrapper =
2419
- (Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T> *)data.get();
2356
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T> *)data.get();
2420
2357
  Arguments* args = wrapper->arguments_;
2421
2358
 
2422
2359
  VALUE varg0;
2423
2360
 
2424
- rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(),
2425
- &varg0);
2361
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0);
2426
2362
 
2427
2363
  Self_T * obj = from_ruby<Self_T *>(self);
2428
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2429
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2430
2364
 
2365
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2366
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2431
2367
  Func func = wrapper->func_;
2432
2368
  (*obj.*func)(arg0);
2433
2369
  return Qnil;