rice 1.3.1 → 1.3.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (34) hide show
  1. data/Doxyfile +1 -1
  2. data/Makefile.in +58 -142
  3. data/aclocal.m4 +112 -201
  4. data/config.guess +23 -84
  5. data/config.sub +23 -93
  6. data/configure +2727 -2406
  7. data/depcomp +14 -19
  8. data/install-sh +108 -120
  9. data/rice/Constructor.hpp +350 -322
  10. data/rice/Makefile.am +0 -1
  11. data/rice/Makefile.in +69 -119
  12. data/rice/config.hpp +2 -8
  13. data/rice/config.hpp.in +0 -6
  14. data/rice/detail/Auto_Function_Wrapper.hpp +1 -33
  15. data/rice/detail/Auto_Function_Wrapper.ipp +1009 -1060
  16. data/rice/detail/Auto_Member_Function_Wrapper.ipp +608 -672
  17. data/rice/detail/method_data.cpp +0 -4
  18. data/rice/detail/object_call.hpp +31 -48
  19. data/rice/detail/object_call.ipp +45 -61
  20. data/rice/detail/wrap_function.hpp +70 -74
  21. data/rice/detail/wrap_function.ipp +126 -143
  22. data/rice/protect.hpp +30 -30
  23. data/rice/protect.ipp +770 -696
  24. data/ruby.ac +0 -14
  25. data/ruby/Makefile.in +41 -108
  26. data/ruby/lib/Makefile.in +23 -64
  27. data/ruby/lib/version.rb +1 -1
  28. data/sample/Makefile.in +12 -36
  29. data/test/Makefile.in +59 -148
  30. data/test/ext/Makefile.in +12 -36
  31. data/test/test_Constructor.cpp +42 -153
  32. data/test/test_Module.cpp +4 -4
  33. metadata +132 -124
  34. data/rice/generate_code.rb +0 -1328
data/rice/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;