rice 1.3.1 → 1.3.2

Sign up to get free protection for your applications and to get access to all the features.
Files changed (34) hide show
  1. data/Doxyfile +1 -1
  2. data/Makefile.in +58 -142
  3. data/aclocal.m4 +112 -201
  4. data/config.guess +23 -84
  5. data/config.sub +23 -93
  6. data/configure +2727 -2406
  7. data/depcomp +14 -19
  8. data/install-sh +108 -120
  9. data/rice/Constructor.hpp +350 -322
  10. data/rice/Makefile.am +0 -1
  11. data/rice/Makefile.in +69 -119
  12. data/rice/config.hpp +2 -8
  13. data/rice/config.hpp.in +0 -6
  14. data/rice/detail/Auto_Function_Wrapper.hpp +1 -33
  15. data/rice/detail/Auto_Function_Wrapper.ipp +1009 -1060
  16. data/rice/detail/Auto_Member_Function_Wrapper.ipp +608 -672
  17. data/rice/detail/method_data.cpp +0 -4
  18. data/rice/detail/object_call.hpp +31 -48
  19. data/rice/detail/object_call.ipp +45 -61
  20. data/rice/detail/wrap_function.hpp +70 -74
  21. data/rice/detail/wrap_function.ipp +126 -143
  22. data/rice/protect.hpp +30 -30
  23. data/rice/protect.ipp +770 -696
  24. data/ruby.ac +0 -14
  25. data/ruby/Makefile.in +41 -108
  26. data/ruby/lib/Makefile.in +23 -64
  27. data/ruby/lib/version.rb +1 -1
  28. data/sample/Makefile.in +12 -36
  29. data/test/Makefile.in +59 -148
  30. data/test/ext/Makefile.in +12 -36
  31. data/test/test_Constructor.cpp +42 -153
  32. data/test/test_Module.cpp +4 -4
  33. metadata +132 -124
  34. data/rice/generate_code.rb +0 -1328
data/rice/config.hpp.in CHANGED
@@ -6,9 +6,6 @@
6
6
  /* Define to 1 if you have the <node.h> header file. */
7
7
  #undef HAVE_NODE_H
8
8
 
9
- /* Define this macro if rb_class_boot is defined */
10
- #undef HAVE_RB_CLASS_BOOT
11
-
12
9
  /* Define to 1 if you have the <ruby.h> header file. */
13
10
  #undef HAVE_RUBY_H
14
11
 
@@ -33,9 +30,6 @@
33
30
  /* Define to the one symbol short name of this package. */
34
31
  #undef PACKAGE_TARNAME
35
32
 
36
- /* Define to the home page for this package. */
37
- #undef PACKAGE_URL
38
-
39
33
  /* Define to the version of this package. */
40
34
  #undef PACKAGE_VERSION
41
35
 
data/rice/detail/Auto_Function_Wrapper.hpp CHANGED
@@ -24,7 +24,6 @@ class Auto_Function_Wrapper
24
24
  : public Wrapped_Function
25
25
  {
26
26
  public:
27
- // typedef Ret_T (*Func)(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);
28
27
  typedef Func_T Func;
29
28
 
30
29
  static const int Num_Args = 16;
@@ -48,7 +47,6 @@ class Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T
48
47
  : public Wrapped_Function
49
48
  {
50
49
  public:
51
- // typedef void (*Func)(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);
52
50
  typedef Func_T Func;
53
51
 
54
52
  static const int Num_Args = 16;
@@ -73,7 +71,6 @@ class Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_
73
71
  : public Wrapped_Function
74
72
  {
75
73
  public:
76
- // typedef Ret_T (*Func)(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);
77
74
  typedef Func_T Func;
78
75
 
79
76
  static const int Num_Args = 15;
@@ -97,7 +94,6 @@ class Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T
97
94
  : public Wrapped_Function
98
95
  {
99
96
  public:
100
- // typedef void (*Func)(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);
101
97
  typedef Func_T Func;
102
98
 
103
99
  static const int Num_Args = 15;
@@ -122,7 +118,6 @@ class Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_
122
118
  : public Wrapped_Function
123
119
  {
124
120
  public:
125
- // typedef Ret_T (*Func)(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);
126
121
  typedef Func_T Func;
127
122
 
128
123
  static const int Num_Args = 14;
@@ -146,7 +141,6 @@ class Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T
146
141
  : public Wrapped_Function
147
142
  {
148
143
  public:
149
- // typedef void (*Func)(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);
150
144
  typedef Func_T Func;
151
145
 
152
146
  static const int Num_Args = 14;
@@ -171,7 +165,6 @@ class Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_
171
165
  : public Wrapped_Function
172
166
  {
173
167
  public:
174
- // typedef Ret_T (*Func)(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);
175
168
  typedef Func_T Func;
176
169
 
177
170
  static const int Num_Args = 13;
@@ -195,7 +188,6 @@ class Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T
195
188
  : public Wrapped_Function
196
189
  {
197
190
  public:
198
- // typedef void (*Func)(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);
199
191
  typedef Func_T Func;
200
192
 
201
193
  static const int Num_Args = 13;
@@ -220,7 +212,6 @@ class Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_
220
212
  : public Wrapped_Function
221
213
  {
222
214
  public:
223
- // typedef Ret_T (*Func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T);
224
215
  typedef Func_T Func;
225
216
 
226
217
  static const int Num_Args = 12;
@@ -244,7 +235,6 @@ class Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T
244
235
  : public Wrapped_Function
245
236
  {
246
237
  public:
247
- // typedef void (*Func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T);
248
238
  typedef Func_T Func;
249
239
 
250
240
  static const int Num_Args = 12;
@@ -269,7 +259,6 @@ class Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_
269
259
  : public Wrapped_Function
270
260
  {
271
261
  public:
272
- // typedef Ret_T (*Func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T);
273
262
  typedef Func_T Func;
274
263
 
275
264
  static const int Num_Args = 11;
@@ -293,7 +282,6 @@ class Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T
293
282
  : public Wrapped_Function
294
283
  {
295
284
  public:
296
- // typedef void (*Func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T);
297
285
  typedef Func_T Func;
298
286
 
299
287
  static const int Num_Args = 11;
@@ -318,7 +306,6 @@ class Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_
318
306
  : public Wrapped_Function
319
307
  {
320
308
  public:
321
- // typedef Ret_T (*Func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T);
322
309
  typedef Func_T Func;
323
310
 
324
311
  static const int Num_Args = 10;
@@ -342,7 +329,6 @@ class Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T
342
329
  : public Wrapped_Function
343
330
  {
344
331
  public:
345
- // typedef void (*Func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T);
346
332
  typedef Func_T Func;
347
333
 
348
334
  static const int Num_Args = 10;
@@ -367,7 +353,6 @@ class Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_
367
353
  : public Wrapped_Function
368
354
  {
369
355
  public:
370
- // typedef Ret_T (*Func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T);
371
356
  typedef Func_T Func;
372
357
 
373
358
  static const int Num_Args = 9;
@@ -391,7 +376,6 @@ class Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T
391
376
  : public Wrapped_Function
392
377
  {
393
378
  public:
394
- // typedef void (*Func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T);
395
379
  typedef Func_T Func;
396
380
 
397
381
  static const int Num_Args = 9;
@@ -416,7 +400,6 @@ class Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_
416
400
  : public Wrapped_Function
417
401
  {
418
402
  public:
419
- // typedef Ret_T (*Func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T);
420
403
  typedef Func_T Func;
421
404
 
422
405
  static const int Num_Args = 8;
@@ -440,7 +423,6 @@ class Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T
440
423
  : public Wrapped_Function
441
424
  {
442
425
  public:
443
- // typedef void (*Func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T);
444
426
  typedef Func_T Func;
445
427
 
446
428
  static const int Num_Args = 8;
@@ -465,7 +447,6 @@ class Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_
465
447
  : public Wrapped_Function
466
448
  {
467
449
  public:
468
- // typedef Ret_T (*Func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T);
469
450
  typedef Func_T Func;
470
451
 
471
452
  static const int Num_Args = 7;
@@ -489,7 +470,6 @@ class Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T
489
470
  : public Wrapped_Function
490
471
  {
491
472
  public:
492
- // typedef void (*Func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T);
493
473
  typedef Func_T Func;
494
474
 
495
475
  static const int Num_Args = 7;
@@ -514,7 +494,6 @@ class Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_
514
494
  : public Wrapped_Function
515
495
  {
516
496
  public:
517
- // typedef Ret_T (*Func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T);
518
497
  typedef Func_T Func;
519
498
 
520
499
  static const int Num_Args = 6;
@@ -538,7 +517,6 @@ class Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T
538
517
  : public Wrapped_Function
539
518
  {
540
519
  public:
541
- // typedef void (*Func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T);
542
520
  typedef Func_T Func;
543
521
 
544
522
  static const int Num_Args = 6;
@@ -563,7 +541,6 @@ class Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_
563
541
  : public Wrapped_Function
564
542
  {
565
543
  public:
566
- // typedef Ret_T (*Func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T);
567
544
  typedef Func_T Func;
568
545
 
569
546
  static const int Num_Args = 5;
@@ -587,7 +564,6 @@ class Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T
587
564
  : public Wrapped_Function
588
565
  {
589
566
  public:
590
- // typedef void (*Func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T);
591
567
  typedef Func_T Func;
592
568
 
593
569
  static const int Num_Args = 5;
@@ -612,7 +588,6 @@ class Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T>
612
588
  : public Wrapped_Function
613
589
  {
614
590
  public:
615
- // typedef Ret_T (*Func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T);
616
591
  typedef Func_T Func;
617
592
 
618
593
  static const int Num_Args = 4;
@@ -636,7 +611,6 @@ class Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T>
636
611
  : public Wrapped_Function
637
612
  {
638
613
  public:
639
- // typedef void (*Func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T);
640
614
  typedef Func_T Func;
641
615
 
642
616
  static const int Num_Args = 4;
@@ -661,7 +635,6 @@ class Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T>
661
635
  : public Wrapped_Function
662
636
  {
663
637
  public:
664
- // typedef Ret_T (*Func)(Arg0_T, Arg1_T, Arg2_T);
665
638
  typedef Func_T Func;
666
639
 
667
640
  static const int Num_Args = 3;
@@ -685,7 +658,6 @@ class Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T>
685
658
  : public Wrapped_Function
686
659
  {
687
660
  public:
688
- // typedef void (*Func)(Arg0_T, Arg1_T, Arg2_T);
689
661
  typedef Func_T Func;
690
662
 
691
663
  static const int Num_Args = 3;
@@ -710,7 +682,6 @@ class Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T>
710
682
  : public Wrapped_Function
711
683
  {
712
684
  public:
713
- // typedef Ret_T (*Func)(Arg0_T, Arg1_T);
714
685
  typedef Func_T Func;
715
686
 
716
687
  static const int Num_Args = 2;
@@ -734,7 +705,6 @@ class Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T>
734
705
  : public Wrapped_Function
735
706
  {
736
707
  public:
737
- // typedef void (*Func)(Arg0_T, Arg1_T);
738
708
  typedef Func_T Func;
739
709
 
740
710
  static const int Num_Args = 2;
@@ -759,7 +729,6 @@ class Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T>
759
729
  : public Wrapped_Function
760
730
  {
761
731
  public:
762
- // typedef Ret_T (*Func)(Arg0_T);
763
732
  typedef Func_T Func;
764
733
 
765
734
  static const int Num_Args = 1;
@@ -783,7 +752,6 @@ class Auto_Function_Wrapper<Func_T, void, Arg0_T>
783
752
  : public Wrapped_Function
784
753
  {
785
754
  public:
786
- // typedef void (*Func)(Arg0_T);
787
755
  typedef Func_T Func;
788
756
 
789
757
  static const int Num_Args = 1;
@@ -803,7 +771,6 @@ private:
803
771
  };
804
772
 
805
773
  // ---------------------------------------------------------------------
806
-
807
774
  template<typename Func_T, typename Ret_T>
808
775
  class Auto_Function_Wrapper<Func_T, Ret_T>
809
776
  : public Wrapped_Function
@@ -849,6 +816,7 @@ private:
849
816
  Data_Object<Exception_Handler> handler_;
850
817
  Arguments* arguments_;
851
818
  };
819
+
852
820
  #endif // DOXYGEN
853
821
 
854
822
  } // namespace detail
data/rice/detail/Auto_Function_Wrapper.ipp CHANGED
@@ -60,75 +60,74 @@ call(int argc, VALUE *argv, VALUE self)
60
60
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14, &varg15);
61
61
 
62
62
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
63
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
64
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
65
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
66
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
67
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
68
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
69
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
70
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
71
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
72
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
73
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
74
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
75
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
76
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
77
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
78
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
79
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
80
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
81
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
82
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
83
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
84
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
85
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
86
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
87
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
88
- Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(12, varg12);
89
- typedef typename sanitize< Arg14_T >::Type Arg14_Type;
90
- Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(13, varg13);
91
- typedef typename sanitize< Arg15_T >::Type Arg15_Type;
92
- Arg15_Type arg15 = args->getArgumentOrDefault<Arg15_Type>(14, varg14);
93
63
 
64
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
65
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
66
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
67
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
68
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
69
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
70
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
71
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
72
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
73
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
74
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
75
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
76
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
77
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
78
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
79
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
80
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
81
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
82
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
83
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
84
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
85
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
86
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
87
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
88
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
89
+ Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(12, varg12);
90
+ typedef typename sanitize< Arg14_T >::Type Arg14_Type;
91
+ Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(13, varg13);
92
+ typedef typename sanitize< Arg15_T >::Type Arg15_Type;
93
+ Arg15_Type arg15 = args->getArgumentOrDefault<Arg15_Type>(14, varg14);
94
94
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15));
95
95
  } else {
96
96
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
97
97
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14, &varg15);
98
98
 
99
99
  typedef typename sanitize< Arg0_T >::Type Arg0_Type;
100
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
101
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
102
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
103
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
104
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
105
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
106
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
107
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
108
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
109
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
110
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
111
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
112
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
113
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
114
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
115
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
116
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
117
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
118
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
119
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
120
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
121
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
122
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
123
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
124
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
125
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
126
- Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
127
- typedef typename sanitize< Arg14_T >::Type Arg14_Type;
128
- Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(14, varg14);
129
- typedef typename sanitize< Arg15_T >::Type Arg15_Type;
130
- Arg15_Type arg15 = args->getArgumentOrDefault<Arg15_Type>(15, varg15);
131
-
100
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
101
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
102
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
103
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
104
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
105
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
106
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
107
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
108
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
109
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
110
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
111
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
112
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
113
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
114
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
115
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
116
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
117
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
118
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
119
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
120
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
121
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
122
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
123
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
124
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
125
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
126
+ Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
127
+ typedef typename sanitize< Arg14_T >::Type Arg14_Type;
128
+ Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(14, varg14);
129
+ typedef typename sanitize< Arg15_T >::Type Arg15_Type;
130
+ Arg15_Type arg15 = args->getArgumentOrDefault<Arg15_Type>(15, varg15);
132
131
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15));
133
132
  }
134
133
  }
@@ -175,8 +174,7 @@ call(int argc, VALUE* argv, VALUE self)
175
174
  try
176
175
  {
177
176
  Data_Object<Wrapped_Function> data(detail::method_data());
178
- wrapper =
179
- (Auto_Function_Wrapper<Func_T, void, 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();
177
+ wrapper = (Auto_Function_Wrapper<Func_T, void, 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();
180
178
  Arguments* args = wrapper->arguments_;
181
179
 
182
180
  bool hasSelf = (self && self != Qnil);
@@ -193,37 +191,37 @@ call(int argc, VALUE* argv, VALUE self)
193
191
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14, &varg15);
194
192
 
195
193
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
196
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
197
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
198
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
199
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
200
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
201
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
202
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
203
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
204
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
205
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
206
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
207
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
208
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
209
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
210
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
211
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
212
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
213
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
214
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
215
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
216
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
217
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
218
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
219
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
220
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
221
- Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(12, varg12);
222
- typedef typename sanitize< Arg14_T >::Type Arg14_Type;
223
- Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(13, varg13);
224
- typedef typename sanitize< Arg15_T >::Type Arg15_Type;
225
- Arg15_Type arg15 = args->getArgumentOrDefault<Arg15_Type>(14, varg14);
226
194
 
195
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
196
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
197
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
198
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
199
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
200
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
201
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
202
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
203
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
204
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
205
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
206
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
207
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
208
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
209
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
210
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
211
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
212
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
213
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
214
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
215
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
216
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
217
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
218
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
219
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
220
+ Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(12, varg12);
221
+ typedef typename sanitize< Arg14_T >::Type Arg14_Type;
222
+ Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(13, varg13);
223
+ typedef typename sanitize< Arg15_T >::Type Arg15_Type;
224
+ Arg15_Type arg15 = args->getArgumentOrDefault<Arg15_Type>(14, varg14);
227
225
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15);
228
226
  return Qnil;
229
227
  } else {
@@ -231,38 +229,37 @@ call(int argc, VALUE* argv, VALUE self)
231
229
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14, &varg15);
232
230
 
233
231
  typedef typename sanitize< Arg0_T >::Type Arg0_Type;
234
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
235
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
236
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
237
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
238
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
239
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
240
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
241
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
242
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
243
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
244
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
245
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
246
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
247
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
248
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
249
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
250
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
251
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
252
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
253
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
254
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
255
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
256
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
257
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
258
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
259
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
260
- Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
261
- typedef typename sanitize< Arg14_T >::Type Arg14_Type;
262
- Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(14, varg14);
263
- typedef typename sanitize< Arg15_T >::Type Arg15_Type;
264
- Arg15_Type arg15 = args->getArgumentOrDefault<Arg15_Type>(15, varg15);
265
-
232
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
233
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
234
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
235
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
236
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
237
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
238
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
239
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
240
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
241
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
242
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
243
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
244
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
245
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
246
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
247
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
248
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
249
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
250
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
251
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
252
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
253
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
254
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
255
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
256
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
257
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
258
+ Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
259
+ typedef typename sanitize< Arg14_T >::Type Arg14_Type;
260
+ Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(14, varg14);
261
+ typedef typename sanitize< Arg15_T >::Type Arg15_Type;
262
+ Arg15_Type arg15 = args->getArgumentOrDefault<Arg15_Type>(15, varg15);
266
263
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15);
267
264
  return Qnil;
268
265
  }
@@ -328,71 +325,70 @@ call(int argc, VALUE *argv, VALUE self)
328
325
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14);
329
326
 
330
327
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
331
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
332
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
333
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
334
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
335
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
336
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
337
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
338
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
339
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
340
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
341
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
342
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
343
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
344
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
345
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
346
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
347
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
348
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
349
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
350
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
351
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
352
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
353
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
354
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
355
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
356
- Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(12, varg12);
357
- typedef typename sanitize< Arg14_T >::Type Arg14_Type;
358
- Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(13, varg13);
359
328
 
329
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
330
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
331
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
332
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
333
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
334
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
335
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
336
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
337
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
338
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
339
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
340
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
341
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
342
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
343
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
344
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
345
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
346
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
347
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
348
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
349
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
350
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
351
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
352
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
353
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
354
+ Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(12, varg12);
355
+ typedef typename sanitize< Arg14_T >::Type Arg14_Type;
356
+ Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(13, varg13);
360
357
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14));
361
358
  } else {
362
359
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
363
360
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14);
364
361
 
365
362
  typedef typename sanitize< Arg0_T >::Type Arg0_Type;
366
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
367
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
368
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
369
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
370
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
371
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
372
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
373
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
374
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
375
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
376
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
377
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
378
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
379
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
380
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
381
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
382
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
383
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
384
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
385
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
386
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
387
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
388
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
389
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
390
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
391
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
392
- Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
393
- typedef typename sanitize< Arg14_T >::Type Arg14_Type;
394
- Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(14, varg14);
395
-
363
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
364
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
365
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
366
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
367
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
368
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
369
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
370
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
371
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
372
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
373
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
374
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
375
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
376
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
377
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
378
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
379
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
380
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
381
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
382
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
383
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
384
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
385
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
386
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
387
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
388
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
389
+ Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
390
+ typedef typename sanitize< Arg14_T >::Type Arg14_Type;
391
+ Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(14, varg14);
396
392
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14));
397
393
  }
398
394
  }
@@ -439,8 +435,7 @@ call(int argc, VALUE* argv, VALUE self)
439
435
  try
440
436
  {
441
437
  Data_Object<Wrapped_Function> data(detail::method_data());
442
- wrapper =
443
- (Auto_Function_Wrapper<Func_T, void, 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();
438
+ wrapper = (Auto_Function_Wrapper<Func_T, void, 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();
444
439
  Arguments* args = wrapper->arguments_;
445
440
 
446
441
  bool hasSelf = (self && self != Qnil);
@@ -457,35 +452,35 @@ call(int argc, VALUE* argv, VALUE self)
457
452
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14);
458
453
 
459
454
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
460
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
461
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
462
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
463
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
464
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
465
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
466
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
467
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
468
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
469
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
470
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
471
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
472
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
473
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
474
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
475
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
476
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
477
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
478
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
479
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
480
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
481
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
482
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
483
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
484
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
485
- Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(12, varg12);
486
- typedef typename sanitize< Arg14_T >::Type Arg14_Type;
487
- Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(13, varg13);
488
455
 
456
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
457
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
458
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
459
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
460
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
461
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
462
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
463
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
464
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
465
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
466
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
467
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
468
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
469
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
470
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
471
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
472
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
473
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
474
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
475
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
476
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
477
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
478
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
479
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
480
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
481
+ Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(12, varg12);
482
+ typedef typename sanitize< Arg14_T >::Type Arg14_Type;
483
+ Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(13, varg13);
489
484
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
490
485
  return Qnil;
491
486
  } else {
@@ -493,36 +488,35 @@ call(int argc, VALUE* argv, VALUE self)
493
488
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14);
494
489
 
495
490
  typedef typename sanitize< Arg0_T >::Type Arg0_Type;
496
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
497
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
498
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
499
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
500
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
501
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
502
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
503
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
504
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
505
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
506
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
507
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
508
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
509
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
510
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
511
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
512
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
513
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
514
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
515
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
516
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
517
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
518
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
519
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
520
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
521
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
522
- Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
523
- typedef typename sanitize< Arg14_T >::Type Arg14_Type;
524
- Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(14, varg14);
525
-
491
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
492
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
493
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
494
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
495
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
496
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
497
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
498
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
499
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
500
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
501
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
502
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
503
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
504
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
505
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
506
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
507
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
508
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
509
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
510
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
511
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
512
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
513
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
514
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
515
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
516
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
517
+ Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
518
+ typedef typename sanitize< Arg14_T >::Type Arg14_Type;
519
+ Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(14, varg14);
526
520
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
527
521
  return Qnil;
528
522
  }
@@ -588,67 +582,66 @@ call(int argc, VALUE *argv, VALUE self)
588
582
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13);
589
583
 
590
584
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
591
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
592
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
593
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
594
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
595
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
596
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
597
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
598
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
599
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
600
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
601
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
602
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
603
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
604
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
605
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
606
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
607
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
608
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
609
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
610
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
611
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
612
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
613
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
614
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
615
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
616
- Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(12, varg12);
617
585
 
586
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
587
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
588
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
589
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
590
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
591
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
592
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
593
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
594
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
595
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
596
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
597
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
598
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
599
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
600
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
601
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
602
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
603
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
604
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
605
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
606
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
607
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
608
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
609
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
610
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
611
+ Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(12, varg12);
618
612
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13));
619
613
  } else {
620
614
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
621
615
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13);
622
616
 
623
617
  typedef typename sanitize< Arg0_T >::Type Arg0_Type;
624
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
625
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
626
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
627
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
628
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
629
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
630
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
631
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
632
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
633
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
634
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
635
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
636
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
637
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
638
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
639
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
640
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
641
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
642
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
643
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
644
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
645
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
646
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
647
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
648
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
649
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
650
- Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
651
-
618
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
619
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
620
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
621
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
622
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
623
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
624
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
625
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
626
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
627
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
628
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
629
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
630
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
631
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
632
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
633
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
634
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
635
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
636
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
637
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
638
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
639
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
640
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
641
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
642
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
643
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
644
+ Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
652
645
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13));
653
646
  }
654
647
  }
@@ -695,8 +688,7 @@ call(int argc, VALUE* argv, VALUE self)
695
688
  try
696
689
  {
697
690
  Data_Object<Wrapped_Function> data(detail::method_data());
698
- wrapper =
699
- (Auto_Function_Wrapper<Func_T, void, 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();
691
+ wrapper = (Auto_Function_Wrapper<Func_T, void, 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();
700
692
  Arguments* args = wrapper->arguments_;
701
693
 
702
694
  bool hasSelf = (self && self != Qnil);
@@ -713,33 +705,33 @@ call(int argc, VALUE* argv, VALUE self)
713
705
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13);
714
706
 
715
707
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
716
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
717
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
718
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
719
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
720
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
721
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
722
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
723
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
724
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
725
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
726
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
727
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
728
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
729
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
730
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
731
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
732
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
733
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
734
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
735
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
736
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
737
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
738
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
739
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
740
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
741
- Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(12, varg12);
742
708
 
709
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
710
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
711
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
712
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
713
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
714
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
715
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
716
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
717
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
718
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
719
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
720
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
721
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
722
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
723
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
724
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
725
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
726
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
727
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
728
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
729
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
730
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
731
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
732
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
733
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
734
+ Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(12, varg12);
743
735
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
744
736
  return Qnil;
745
737
  } else {
@@ -747,34 +739,33 @@ call(int argc, VALUE* argv, VALUE self)
747
739
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13);
748
740
 
749
741
  typedef typename sanitize< Arg0_T >::Type Arg0_Type;
750
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
751
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
752
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
753
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
754
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
755
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
756
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
757
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
758
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
759
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
760
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
761
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
762
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
763
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
764
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
765
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
766
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
767
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
768
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
769
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
770
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
771
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
772
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
773
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
774
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
775
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
776
- Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
777
-
742
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
743
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
744
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
745
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
746
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
747
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
748
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
749
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
750
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
751
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
752
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
753
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
754
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
755
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
756
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
757
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
758
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
759
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
760
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
761
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
762
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
763
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
764
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
765
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
766
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
767
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
768
+ Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
778
769
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
779
770
  return Qnil;
780
771
  }
@@ -840,63 +831,62 @@ call(int argc, VALUE *argv, VALUE self)
840
831
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12);
841
832
 
842
833
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
843
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
844
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
845
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
846
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
847
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
848
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
849
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
850
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
851
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
852
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
853
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
854
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
855
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
856
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
857
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
858
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
859
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
860
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
861
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
862
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
863
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
864
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
865
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
866
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
867
834
 
835
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
836
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
837
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
838
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
839
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
840
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
841
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
842
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
843
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
844
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
845
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
846
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
847
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
848
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
849
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
850
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
851
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
852
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
853
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
854
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
855
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
856
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
857
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
858
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
868
859
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12));
869
860
  } else {
870
861
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
871
862
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12);
872
863
 
873
864
  typedef typename sanitize< Arg0_T >::Type Arg0_Type;
874
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
875
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
876
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
877
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
878
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
879
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
880
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
881
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
882
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
883
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
884
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
885
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
886
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
887
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
888
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
889
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
890
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
891
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
892
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
893
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
894
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
895
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
896
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
897
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
898
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
899
-
865
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
866
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
867
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
868
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
869
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
870
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
871
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
872
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
873
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
874
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
875
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
876
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
877
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
878
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
879
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
880
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
881
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
882
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
883
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
884
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
885
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
886
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
887
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
888
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
889
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
900
890
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12));
901
891
  }
902
892
  }
@@ -943,8 +933,7 @@ call(int argc, VALUE* argv, VALUE self)
943
933
  try
944
934
  {
945
935
  Data_Object<Wrapped_Function> data(detail::method_data());
946
- wrapper =
947
- (Auto_Function_Wrapper<Func_T, void, 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();
936
+ wrapper = (Auto_Function_Wrapper<Func_T, void, 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();
948
937
  Arguments* args = wrapper->arguments_;
949
938
 
950
939
  bool hasSelf = (self && self != Qnil);
@@ -961,31 +950,31 @@ call(int argc, VALUE* argv, VALUE self)
961
950
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12);
962
951
 
963
952
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
964
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
965
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
966
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
967
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
968
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
969
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
970
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
971
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
972
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
973
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
974
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
975
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
976
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
977
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
978
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
979
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
980
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
981
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
982
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
983
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
984
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
985
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
986
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
987
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
988
953
 
954
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
955
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
956
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
957
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
958
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
959
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
960
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
961
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
962
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
963
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
964
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
965
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
966
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
967
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
968
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
969
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
970
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
971
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
972
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
973
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
974
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
975
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
976
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
977
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
989
978
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
990
979
  return Qnil;
991
980
  } else {
@@ -993,32 +982,31 @@ call(int argc, VALUE* argv, VALUE self)
993
982
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12);
994
983
 
995
984
  typedef typename sanitize< Arg0_T >::Type Arg0_Type;
996
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
997
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
998
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
999
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1000
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1001
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1002
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1003
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1004
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1005
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1006
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1007
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1008
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1009
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1010
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1011
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1012
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1013
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1014
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1015
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1016
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
1017
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
1018
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
1019
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
1020
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
1021
-
985
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
986
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
987
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
988
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
989
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
990
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
991
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
992
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
993
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
994
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
995
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
996
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
997
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
998
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
999
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1000
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1001
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1002
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1003
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1004
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1005
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
1006
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
1007
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
1008
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
1009
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
1022
1010
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
1023
1011
  return Qnil;
1024
1012
  }
@@ -1084,59 +1072,58 @@ call(int argc, VALUE *argv, VALUE self)
1084
1072
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11);
1085
1073
 
1086
1074
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
1087
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1088
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1089
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1090
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1091
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1092
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1093
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1094
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1095
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1096
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1097
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1098
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1099
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1100
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1101
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1102
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1103
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1104
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
1105
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1106
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
1107
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
1108
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
1109
1075
 
1076
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1077
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1078
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1079
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1080
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1081
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1082
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1083
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1084
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1085
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1086
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1087
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1088
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1089
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1090
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1091
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1092
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1093
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
1094
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1095
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
1096
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
1097
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
1110
1098
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11));
1111
1099
  } else {
1112
1100
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
1113
1101
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11);
1114
1102
 
1115
1103
  typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1116
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1117
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1118
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1119
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1120
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1121
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1122
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1123
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1124
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1125
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1126
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1127
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1128
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1129
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1130
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1131
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1132
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1133
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1134
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1135
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1136
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
1137
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
1138
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
1139
-
1104
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1105
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1106
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1107
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1108
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1109
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1110
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1111
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1112
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1113
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1114
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1115
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1116
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1117
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1118
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1119
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1120
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1121
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1122
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1123
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1124
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
1125
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
1126
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
1140
1127
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11));
1141
1128
  }
1142
1129
  }
@@ -1183,8 +1170,7 @@ call(int argc, VALUE* argv, VALUE self)
1183
1170
  try
1184
1171
  {
1185
1172
  Data_Object<Wrapped_Function> data(detail::method_data());
1186
- wrapper =
1187
- (Auto_Function_Wrapper<Func_T, void, 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();
1173
+ wrapper = (Auto_Function_Wrapper<Func_T, void, 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();
1188
1174
  Arguments* args = wrapper->arguments_;
1189
1175
 
1190
1176
  bool hasSelf = (self && self != Qnil);
@@ -1201,29 +1187,29 @@ call(int argc, VALUE* argv, VALUE self)
1201
1187
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11);
1202
1188
 
1203
1189
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
1204
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1205
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1206
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1207
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1208
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1209
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1210
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1211
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1212
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1213
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1214
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1215
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1216
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1217
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1218
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1219
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1220
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1221
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
1222
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1223
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
1224
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
1225
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
1226
1190
 
1191
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1192
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1193
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1194
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1195
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1196
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1197
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1198
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1199
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1200
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1201
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1202
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1203
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1204
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1205
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1206
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1207
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1208
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
1209
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1210
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
1211
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
1212
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
1227
1213
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
1228
1214
  return Qnil;
1229
1215
  } else {
@@ -1231,30 +1217,29 @@ call(int argc, VALUE* argv, VALUE self)
1231
1217
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11);
1232
1218
 
1233
1219
  typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1234
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1235
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1236
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1237
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1238
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1239
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1240
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1241
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1242
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1243
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1244
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1245
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1246
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1247
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1248
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1249
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1250
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1251
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1252
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1253
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1254
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
1255
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
1256
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
1257
-
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);
1237
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1238
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1239
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1240
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
1241
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
1242
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
1258
1243
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
1259
1244
  return Qnil;
1260
1245
  }
@@ -1320,55 +1305,54 @@ call(int argc, VALUE *argv, VALUE self)
1320
1305
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10);
1321
1306
 
1322
1307
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
1323
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1324
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1325
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1326
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1327
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1328
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1329
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1330
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1331
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1332
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1333
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1334
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1335
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1336
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1337
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1338
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1339
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1340
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
1341
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1342
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
1343
1308
 
1309
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1310
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1311
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1312
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1313
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1314
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1315
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1316
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1317
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1318
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1319
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1320
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1321
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1322
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1323
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1324
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1325
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1326
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
1327
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1328
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
1344
1329
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10));
1345
1330
  } else {
1346
1331
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
1347
1332
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10);
1348
1333
 
1349
1334
  typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1350
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1351
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1352
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1353
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1354
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1355
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1356
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1357
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1358
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1359
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1360
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1361
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1362
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1363
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1364
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1365
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1366
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1367
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1368
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1369
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1370
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
1371
-
1335
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1336
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1337
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1338
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1339
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1340
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1341
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1342
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1343
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1344
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1345
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1346
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1347
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1348
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1349
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1350
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1351
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1352
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1353
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1354
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1355
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
1372
1356
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10));
1373
1357
  }
1374
1358
  }
@@ -1415,8 +1399,7 @@ call(int argc, VALUE* argv, VALUE self)
1415
1399
  try
1416
1400
  {
1417
1401
  Data_Object<Wrapped_Function> data(detail::method_data());
1418
- wrapper =
1419
- (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T> *)data.get();
1402
+ wrapper = (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T> *)data.get();
1420
1403
  Arguments* args = wrapper->arguments_;
1421
1404
 
1422
1405
  bool hasSelf = (self && self != Qnil);
@@ -1433,27 +1416,27 @@ call(int argc, VALUE* argv, VALUE self)
1433
1416
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10);
1434
1417
 
1435
1418
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
1436
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1437
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1438
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1439
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1440
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1441
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1442
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1443
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1444
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1445
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1446
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1447
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1448
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1449
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1450
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1451
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1452
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1453
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
1454
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1455
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
1456
1419
 
1420
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1421
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1422
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1423
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1424
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1425
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1426
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1427
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1428
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1429
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1430
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1431
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1432
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1433
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1434
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1435
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1436
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1437
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
1438
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1439
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
1457
1440
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
1458
1441
  return Qnil;
1459
1442
  } else {
@@ -1461,28 +1444,27 @@ call(int argc, VALUE* argv, VALUE self)
1461
1444
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10);
1462
1445
 
1463
1446
  typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1464
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1465
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1466
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1467
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1468
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1469
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1470
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1471
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1472
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1473
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1474
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1475
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1476
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1477
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1478
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1479
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1480
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1481
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1482
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1483
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1484
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
1485
-
1447
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1448
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1449
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1450
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1451
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1452
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1453
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1454
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1455
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1456
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1457
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1458
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1459
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1460
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1461
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1462
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1463
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1464
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1465
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1466
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1467
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
1486
1468
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
1487
1469
  return Qnil;
1488
1470
  }
@@ -1548,51 +1530,50 @@ call(int argc, VALUE *argv, VALUE self)
1548
1530
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9);
1549
1531
 
1550
1532
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
1551
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1552
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1553
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1554
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1555
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1556
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1557
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1558
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1559
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1560
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1561
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1562
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1563
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1564
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1565
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1566
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1567
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1568
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
1569
1533
 
1534
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1535
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1536
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1537
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1538
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1539
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1540
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1541
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1542
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1543
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1544
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1545
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1546
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1547
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1548
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1549
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1550
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1551
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
1570
1552
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9));
1571
1553
  } else {
1572
1554
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
1573
1555
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9);
1574
1556
 
1575
1557
  typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1576
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1577
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1578
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1579
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1580
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1581
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1582
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1583
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1584
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1585
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1586
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1587
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1588
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1589
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1590
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1591
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1592
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1593
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1594
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1595
-
1558
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1559
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1560
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1561
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1562
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1563
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1564
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1565
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1566
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1567
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1568
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1569
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1570
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1571
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1572
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1573
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1574
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1575
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1576
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1596
1577
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9));
1597
1578
  }
1598
1579
  }
@@ -1639,8 +1620,7 @@ call(int argc, VALUE* argv, VALUE self)
1639
1620
  try
1640
1621
  {
1641
1622
  Data_Object<Wrapped_Function> data(detail::method_data());
1642
- wrapper =
1643
- (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T> *)data.get();
1623
+ wrapper = (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T> *)data.get();
1644
1624
  Arguments* args = wrapper->arguments_;
1645
1625
 
1646
1626
  bool hasSelf = (self && self != Qnil);
@@ -1657,25 +1637,25 @@ call(int argc, VALUE* argv, VALUE self)
1657
1637
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9);
1658
1638
 
1659
1639
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
1660
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1661
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1662
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1663
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1664
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1665
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1666
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1667
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1668
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1669
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1670
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1671
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1672
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1673
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1674
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1675
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1676
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1677
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
1678
1640
 
1641
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1642
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1643
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1644
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1645
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1646
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1647
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1648
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1649
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1650
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1651
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1652
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1653
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1654
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1655
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1656
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1657
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1658
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
1679
1659
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
1680
1660
  return Qnil;
1681
1661
  } else {
@@ -1683,26 +1663,25 @@ call(int argc, VALUE* argv, VALUE self)
1683
1663
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9);
1684
1664
 
1685
1665
  typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1686
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1687
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1688
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1689
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1690
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1691
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1692
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1693
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1694
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1695
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1696
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1697
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1698
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1699
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1700
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1701
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1702
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1703
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1704
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1705
-
1666
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1667
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1668
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1669
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1670
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1671
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1672
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1673
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1674
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1675
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1676
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1677
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1678
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1679
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1680
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1681
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1682
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1683
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1684
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1706
1685
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
1707
1686
  return Qnil;
1708
1687
  }
@@ -1768,47 +1747,46 @@ call(int argc, VALUE *argv, VALUE self)
1768
1747
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8);
1769
1748
 
1770
1749
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
1771
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1772
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1773
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1774
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1775
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1776
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1777
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1778
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1779
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1780
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1781
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1782
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1783
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1784
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1785
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1786
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1787
1750
 
1751
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1752
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1753
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1754
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1755
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1756
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1757
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1758
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1759
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1760
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1761
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1762
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1763
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1764
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1765
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1766
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1788
1767
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8));
1789
1768
  } else {
1790
1769
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
1791
1770
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8);
1792
1771
 
1793
1772
  typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1794
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1795
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1796
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1797
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1798
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1799
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1800
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1801
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1802
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1803
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1804
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1805
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1806
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1807
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1808
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1809
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1810
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1811
-
1773
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1774
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1775
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1776
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1777
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1778
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1779
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1780
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1781
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1782
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1783
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1784
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1785
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1786
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1787
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1788
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1789
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1812
1790
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8));
1813
1791
  }
1814
1792
  }
@@ -1855,8 +1833,7 @@ call(int argc, VALUE* argv, VALUE self)
1855
1833
  try
1856
1834
  {
1857
1835
  Data_Object<Wrapped_Function> data(detail::method_data());
1858
- wrapper =
1859
- (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T> *)data.get();
1836
+ wrapper = (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T> *)data.get();
1860
1837
  Arguments* args = wrapper->arguments_;
1861
1838
 
1862
1839
  bool hasSelf = (self && self != Qnil);
@@ -1873,23 +1850,23 @@ call(int argc, VALUE* argv, VALUE self)
1873
1850
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8);
1874
1851
 
1875
1852
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
1876
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1877
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1878
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1879
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1880
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1881
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1882
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1883
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1884
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1885
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1886
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1887
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1888
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1889
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1890
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1891
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1892
1853
 
1854
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1855
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1856
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1857
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1858
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1859
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1860
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1861
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1862
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1863
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1864
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1865
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1866
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1867
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1868
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1869
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1893
1870
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
1894
1871
  return Qnil;
1895
1872
  } else {
@@ -1897,24 +1874,23 @@ call(int argc, VALUE* argv, VALUE self)
1897
1874
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8);
1898
1875
 
1899
1876
  typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1900
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1901
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1902
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1903
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1904
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1905
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1906
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1907
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1908
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1909
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1910
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1911
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1912
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1913
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1914
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1915
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1916
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1917
-
1877
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1878
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1879
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1880
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1881
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1882
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1883
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1884
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1885
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1886
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1887
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1888
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1889
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1890
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1891
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1892
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1893
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1918
1894
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
1919
1895
  return Qnil;
1920
1896
  }
@@ -1980,43 +1956,42 @@ call(int argc, VALUE *argv, VALUE self)
1980
1956
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7);
1981
1957
 
1982
1958
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
1983
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1984
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1985
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1986
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1987
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1988
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1989
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1990
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1991
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1992
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1993
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1994
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1995
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1996
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1997
1959
 
1960
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1961
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1962
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1963
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1964
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1965
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1966
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1967
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1968
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1969
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1970
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1971
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1972
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1973
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1998
1974
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7));
1999
1975
  } else {
2000
1976
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
2001
1977
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7);
2002
1978
 
2003
1979
  typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2004
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2005
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2006
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2007
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2008
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2009
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2010
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2011
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2012
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2013
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2014
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
2015
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2016
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
2017
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
2018
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
2019
-
1980
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1981
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1982
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1983
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1984
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1985
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1986
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1987
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1988
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1989
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1990
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1991
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1992
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1993
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1994
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
2020
1995
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7));
2021
1996
  }
2022
1997
  }
@@ -2063,8 +2038,7 @@ call(int argc, VALUE* argv, VALUE self)
2063
2038
  try
2064
2039
  {
2065
2040
  Data_Object<Wrapped_Function> data(detail::method_data());
2066
- wrapper =
2067
- (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T> *)data.get();
2041
+ wrapper = (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T> *)data.get();
2068
2042
  Arguments* args = wrapper->arguments_;
2069
2043
 
2070
2044
  bool hasSelf = (self && self != Qnil);
@@ -2081,21 +2055,21 @@ call(int argc, VALUE* argv, VALUE self)
2081
2055
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7);
2082
2056
 
2083
2057
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
2084
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2085
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2086
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2087
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2088
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2089
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2090
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2091
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2092
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2093
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
2094
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2095
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
2096
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
2097
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
2098
2058
 
2059
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2060
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2061
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2062
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2063
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2064
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2065
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2066
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2067
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2068
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
2069
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2070
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
2071
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
2072
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
2099
2073
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
2100
2074
  return Qnil;
2101
2075
  } else {
@@ -2103,22 +2077,21 @@ call(int argc, VALUE* argv, VALUE self)
2103
2077
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7);
2104
2078
 
2105
2079
  typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2106
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2107
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2108
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2109
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2110
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2111
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2112
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2113
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2114
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2115
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2116
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
2117
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2118
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
2119
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
2120
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
2121
-
2080
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2081
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2082
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2083
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2084
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2085
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2086
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2087
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2088
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2089
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2090
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
2091
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2092
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
2093
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
2094
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
2122
2095
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
2123
2096
  return Qnil;
2124
2097
  }
@@ -2184,39 +2157,38 @@ call(int argc, VALUE *argv, VALUE self)
2184
2157
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6);
2185
2158
 
2186
2159
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
2187
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2188
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2189
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2190
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2191
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2192
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2193
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2194
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2195
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2196
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
2197
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2198
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
2199
2160
 
2161
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2162
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2163
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2164
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2165
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2166
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2167
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2168
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2169
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2170
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
2171
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2172
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
2200
2173
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6));
2201
2174
  } else {
2202
2175
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
2203
2176
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6);
2204
2177
 
2205
2178
  typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2206
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2207
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2208
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2209
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2210
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2211
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2212
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2213
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2214
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2215
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2216
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
2217
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2218
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
2219
-
2179
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2180
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2181
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2182
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2183
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2184
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2185
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2186
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2187
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2188
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2189
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
2190
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2191
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
2220
2192
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6));
2221
2193
  }
2222
2194
  }
@@ -2263,8 +2235,7 @@ call(int argc, VALUE* argv, VALUE self)
2263
2235
  try
2264
2236
  {
2265
2237
  Data_Object<Wrapped_Function> data(detail::method_data());
2266
- wrapper =
2267
- (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T> *)data.get();
2238
+ wrapper = (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T> *)data.get();
2268
2239
  Arguments* args = wrapper->arguments_;
2269
2240
 
2270
2241
  bool hasSelf = (self && self != Qnil);
@@ -2281,19 +2252,19 @@ call(int argc, VALUE* argv, VALUE self)
2281
2252
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6);
2282
2253
 
2283
2254
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
2284
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2285
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2286
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2287
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2288
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2289
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2290
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2291
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2292
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2293
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
2294
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2295
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
2296
2255
 
2256
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2257
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2258
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2259
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2260
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2261
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2262
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2263
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2264
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2265
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
2266
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2267
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
2297
2268
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
2298
2269
  return Qnil;
2299
2270
  } else {
@@ -2301,20 +2272,19 @@ call(int argc, VALUE* argv, VALUE self)
2301
2272
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6);
2302
2273
 
2303
2274
  typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2304
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2305
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2306
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2307
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2308
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2309
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2310
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2311
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2312
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2313
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2314
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
2315
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2316
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
2317
-
2275
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2276
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2277
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2278
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2279
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2280
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2281
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2282
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2283
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2284
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2285
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
2286
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2287
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
2318
2288
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
2319
2289
  return Qnil;
2320
2290
  }
@@ -2380,35 +2350,34 @@ call(int argc, VALUE *argv, VALUE self)
2380
2350
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5);
2381
2351
 
2382
2352
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
2383
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2384
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2385
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2386
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2387
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2388
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2389
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2390
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2391
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2392
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
2393
2353
 
2354
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2355
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2356
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2357
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2358
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2359
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2360
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2361
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2362
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2363
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
2394
2364
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5));
2395
2365
  } else {
2396
2366
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
2397
2367
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5);
2398
2368
 
2399
2369
  typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2400
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2401
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2402
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2403
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2404
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2405
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2406
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2407
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2408
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2409
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2410
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
2411
-
2370
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2371
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2372
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2373
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2374
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2375
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2376
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2377
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2378
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2379
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2380
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
2412
2381
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5));
2413
2382
  }
2414
2383
  }
@@ -2455,8 +2424,7 @@ call(int argc, VALUE* argv, VALUE self)
2455
2424
  try
2456
2425
  {
2457
2426
  Data_Object<Wrapped_Function> data(detail::method_data());
2458
- wrapper =
2459
- (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T> *)data.get();
2427
+ wrapper = (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T> *)data.get();
2460
2428
  Arguments* args = wrapper->arguments_;
2461
2429
 
2462
2430
  bool hasSelf = (self && self != Qnil);
@@ -2473,17 +2441,17 @@ call(int argc, VALUE* argv, VALUE self)
2473
2441
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5);
2474
2442
 
2475
2443
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
2476
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2477
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2478
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2479
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2480
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2481
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2482
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2483
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2484
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2485
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
2486
2444
 
2445
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2446
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2447
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2448
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2449
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2450
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2451
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2452
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2453
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2454
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
2487
2455
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5);
2488
2456
  return Qnil;
2489
2457
  } else {
@@ -2491,18 +2459,17 @@ call(int argc, VALUE* argv, VALUE self)
2491
2459
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5);
2492
2460
 
2493
2461
  typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2494
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2495
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2496
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2497
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2498
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2499
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2500
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2501
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2502
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2503
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2504
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
2505
-
2462
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2463
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2464
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2465
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2466
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2467
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2468
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2469
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2470
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2471
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2472
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
2506
2473
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5);
2507
2474
  return Qnil;
2508
2475
  }
@@ -2568,31 +2535,30 @@ call(int argc, VALUE *argv, VALUE self)
2568
2535
  , &varg0, &varg1, &varg2, &varg3, &varg4);
2569
2536
 
2570
2537
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
2571
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2572
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2573
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2574
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2575
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2576
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2577
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2578
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2579
2538
 
2539
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2540
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2541
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2542
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2543
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2544
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2545
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2546
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2580
2547
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4));
2581
2548
  } else {
2582
2549
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
2583
2550
  , &varg0, &varg1, &varg2, &varg3, &varg4);
2584
2551
 
2585
2552
  typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2586
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2587
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2588
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2589
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2590
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2591
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2592
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2593
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2594
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2595
-
2553
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2554
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2555
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2556
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2557
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2558
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2559
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2560
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2561
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2596
2562
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4));
2597
2563
  }
2598
2564
  }
@@ -2639,8 +2605,7 @@ call(int argc, VALUE* argv, VALUE self)
2639
2605
  try
2640
2606
  {
2641
2607
  Data_Object<Wrapped_Function> data(detail::method_data());
2642
- wrapper =
2643
- (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T> *)data.get();
2608
+ wrapper = (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T> *)data.get();
2644
2609
  Arguments* args = wrapper->arguments_;
2645
2610
 
2646
2611
  bool hasSelf = (self && self != Qnil);
@@ -2657,15 +2622,15 @@ call(int argc, VALUE* argv, VALUE self)
2657
2622
  , &varg0, &varg1, &varg2, &varg3, &varg4);
2658
2623
 
2659
2624
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
2660
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2661
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2662
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2663
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2664
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2665
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2666
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2667
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2668
2625
 
2626
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2627
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2628
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2629
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2630
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2631
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2632
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2633
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2669
2634
  wrapper->func_(arg0, arg1, arg2, arg3, arg4);
2670
2635
  return Qnil;
2671
2636
  } else {
@@ -2673,16 +2638,15 @@ call(int argc, VALUE* argv, VALUE self)
2673
2638
  , &varg0, &varg1, &varg2, &varg3, &varg4);
2674
2639
 
2675
2640
  typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2676
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2677
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2678
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2679
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2680
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2681
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2682
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2683
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2684
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2685
-
2641
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2642
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2643
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2644
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2645
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2646
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2647
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2648
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2649
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2686
2650
  wrapper->func_(arg0, arg1, arg2, arg3, arg4);
2687
2651
  return Qnil;
2688
2652
  }
@@ -2748,27 +2712,26 @@ call(int argc, VALUE *argv, VALUE self)
2748
2712
  , &varg0, &varg1, &varg2, &varg3);
2749
2713
 
2750
2714
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
2751
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2752
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2753
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2754
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2755
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2756
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2757
2715
 
2716
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2717
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2718
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2719
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2720
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2721
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2758
2722
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3));
2759
2723
  } else {
2760
2724
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
2761
2725
  , &varg0, &varg1, &varg2, &varg3);
2762
2726
 
2763
2727
  typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2764
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2765
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2766
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2767
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2768
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2769
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2770
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2771
-
2728
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2729
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2730
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2731
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2732
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2733
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2734
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2772
2735
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3));
2773
2736
  }
2774
2737
  }
@@ -2815,8 +2778,7 @@ call(int argc, VALUE* argv, VALUE self)
2815
2778
  try
2816
2779
  {
2817
2780
  Data_Object<Wrapped_Function> data(detail::method_data());
2818
- wrapper =
2819
- (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T> *)data.get();
2781
+ wrapper = (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T> *)data.get();
2820
2782
  Arguments* args = wrapper->arguments_;
2821
2783
 
2822
2784
  bool hasSelf = (self && self != Qnil);
@@ -2833,13 +2795,13 @@ call(int argc, VALUE* argv, VALUE self)
2833
2795
  , &varg0, &varg1, &varg2, &varg3);
2834
2796
 
2835
2797
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
2836
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2837
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2838
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2839
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2840
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2841
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2842
2798
 
2799
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2800
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2801
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2802
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2803
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2804
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2843
2805
  wrapper->func_(arg0, arg1, arg2, arg3);
2844
2806
  return Qnil;
2845
2807
  } else {
@@ -2847,14 +2809,13 @@ call(int argc, VALUE* argv, VALUE self)
2847
2809
  , &varg0, &varg1, &varg2, &varg3);
2848
2810
 
2849
2811
  typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2850
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2851
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2852
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2853
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2854
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2855
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2856
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2857
-
2812
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2813
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2814
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2815
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2816
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2817
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2818
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2858
2819
  wrapper->func_(arg0, arg1, arg2, arg3);
2859
2820
  return Qnil;
2860
2821
  }
@@ -2920,23 +2881,22 @@ call(int argc, VALUE *argv, VALUE self)
2920
2881
  , &varg0, &varg1, &varg2);
2921
2882
 
2922
2883
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
2923
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2924
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2925
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2926
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2927
2884
 
2885
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2886
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2887
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2888
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2928
2889
  return to_ruby(wrapper->func_(arg0, arg1, arg2));
2929
2890
  } else {
2930
2891
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
2931
2892
  , &varg0, &varg1, &varg2);
2932
2893
 
2933
2894
  typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2934
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2935
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2936
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2937
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2938
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2939
-
2895
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2896
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2897
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2898
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2899
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2940
2900
  return to_ruby(wrapper->func_(arg0, arg1, arg2));
2941
2901
  }
2942
2902
  }
@@ -2983,8 +2943,7 @@ call(int argc, VALUE* argv, VALUE self)
2983
2943
  try
2984
2944
  {
2985
2945
  Data_Object<Wrapped_Function> data(detail::method_data());
2986
- wrapper =
2987
- (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T> *)data.get();
2946
+ wrapper = (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T> *)data.get();
2988
2947
  Arguments* args = wrapper->arguments_;
2989
2948
 
2990
2949
  bool hasSelf = (self && self != Qnil);
@@ -3001,11 +2960,11 @@ call(int argc, VALUE* argv, VALUE self)
3001
2960
  , &varg0, &varg1, &varg2);
3002
2961
 
3003
2962
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
3004
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3005
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
3006
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
3007
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
3008
2963
 
2964
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2965
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2966
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2967
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
3009
2968
  wrapper->func_(arg0, arg1, arg2);
3010
2969
  return Qnil;
3011
2970
  } else {
@@ -3013,12 +2972,11 @@ call(int argc, VALUE* argv, VALUE self)
3013
2972
  , &varg0, &varg1, &varg2);
3014
2973
 
3015
2974
  typedef typename sanitize< Arg0_T >::Type Arg0_Type;
3016
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
3017
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3018
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
3019
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
3020
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
3021
-
2975
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2976
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2977
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2978
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2979
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
3022
2980
  wrapper->func_(arg0, arg1, arg2);
3023
2981
  return Qnil;
3024
2982
  }
@@ -3084,19 +3042,18 @@ call(int argc, VALUE *argv, VALUE self)
3084
3042
  , &varg0, &varg1);
3085
3043
 
3086
3044
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
3087
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3088
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
3089
3045
 
3046
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3047
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
3090
3048
  return to_ruby(wrapper->func_(arg0, arg1));
3091
3049
  } else {
3092
3050
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
3093
3051
  , &varg0, &varg1);
3094
3052
 
3095
3053
  typedef typename sanitize< Arg0_T >::Type Arg0_Type;
3096
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
3097
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3098
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
3099
-
3054
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
3055
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3056
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
3100
3057
  return to_ruby(wrapper->func_(arg0, arg1));
3101
3058
  }
3102
3059
  }
@@ -3143,8 +3100,7 @@ call(int argc, VALUE* argv, VALUE self)
3143
3100
  try
3144
3101
  {
3145
3102
  Data_Object<Wrapped_Function> data(detail::method_data());
3146
- wrapper =
3147
- (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T> *)data.get();
3103
+ wrapper = (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T> *)data.get();
3148
3104
  Arguments* args = wrapper->arguments_;
3149
3105
 
3150
3106
  bool hasSelf = (self && self != Qnil);
@@ -3161,9 +3117,9 @@ call(int argc, VALUE* argv, VALUE self)
3161
3117
  , &varg0, &varg1);
3162
3118
 
3163
3119
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
3164
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3165
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
3166
3120
 
3121
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3122
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
3167
3123
  wrapper->func_(arg0, arg1);
3168
3124
  return Qnil;
3169
3125
  } else {
@@ -3171,10 +3127,9 @@ call(int argc, VALUE* argv, VALUE self)
3171
3127
  , &varg0, &varg1);
3172
3128
 
3173
3129
  typedef typename sanitize< Arg0_T >::Type Arg0_Type;
3174
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
3175
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3176
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
3177
-
3130
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
3131
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3132
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
3178
3133
  wrapper->func_(arg0, arg1);
3179
3134
  return Qnil;
3180
3135
  }
@@ -3240,7 +3195,6 @@ call(int argc, VALUE *argv, VALUE self)
3240
3195
  , &varg0);
3241
3196
 
3242
3197
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
3243
-
3244
3198
 
3245
3199
  return to_ruby(wrapper->func_(arg0));
3246
3200
  } else {
@@ -3248,8 +3202,7 @@ call(int argc, VALUE *argv, VALUE self)
3248
3202
  , &varg0);
3249
3203
 
3250
3204
  typedef typename sanitize< Arg0_T >::Type Arg0_Type;
3251
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
3252
-
3205
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
3253
3206
  return to_ruby(wrapper->func_(arg0));
3254
3207
  }
3255
3208
  }
@@ -3296,8 +3249,7 @@ call(int argc, VALUE* argv, VALUE self)
3296
3249
  try
3297
3250
  {
3298
3251
  Data_Object<Wrapped_Function> data(detail::method_data());
3299
- wrapper =
3300
- (Auto_Function_Wrapper<Func_T, void, Arg0_T> *)data.get();
3252
+ wrapper = (Auto_Function_Wrapper<Func_T, void, Arg0_T> *)data.get();
3301
3253
  Arguments* args = wrapper->arguments_;
3302
3254
 
3303
3255
  bool hasSelf = (self && self != Qnil);
@@ -3314,7 +3266,6 @@ call(int argc, VALUE* argv, VALUE self)
3314
3266
  , &varg0);
3315
3267
 
3316
3268
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
3317
-
3318
3269
 
3319
3270
  wrapper->func_(arg0);
3320
3271
  return Qnil;
@@ -3323,8 +3274,7 @@ call(int argc, VALUE* argv, VALUE self)
3323
3274
  , &varg0);
3324
3275
 
3325
3276
  typedef typename sanitize< Arg0_T >::Type Arg0_Type;
3326
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
3327
-
3277
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
3328
3278
  wrapper->func_(arg0);
3329
3279
  return Qnil;
3330
3280
  }
@@ -3410,8 +3360,7 @@ call()
3410
3360
  try
3411
3361
  {
3412
3362
  Data_Object<Wrapped_Function> data(detail::method_data());
3413
- wrapper =
3414
- (Auto_Function_Wrapper<Func_T, void> *)data.get();
3363
+ wrapper = (Auto_Function_Wrapper<Func_T, void> *)data.get();
3415
3364
 
3416
3365
  wrapper->func_();
3417
3366
  return Qnil;