rice 1.3.1 → 1.3.2

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