rice 1.4.3 → 1.5.0

Sign up to get free protection for your applications and to get access to all the features.
Files changed (54) hide show
  1. data/COPYING +2 -2
  2. data/Doxyfile +1 -1
  3. data/Makefile.in +296 -166
  4. data/README +18 -13
  5. data/Rakefile +3 -2
  6. data/aclocal.m4 +375 -248
  7. data/config.guess +296 -261
  8. data/config.sub +268 -94
  9. data/configure +2789 -3054
  10. data/configure.ac +1 -1
  11. data/depcomp +403 -197
  12. data/extconf.rb +14 -3
  13. data/install-sh +139 -119
  14. data/missing +154 -306
  15. data/rice/Builtin_Object_defn.hpp +0 -1
  16. data/rice/Constructor.hpp +31 -30
  17. data/rice/Data_Object_defn.hpp +8 -2
  18. data/rice/Hash.hpp +26 -9
  19. data/rice/Hash.ipp +52 -60
  20. data/rice/Makefile.am +0 -1
  21. data/rice/Makefile.in +278 -152
  22. data/rice/Module_impl.ipp +1 -1
  23. data/rice/VM.cpp +1 -11
  24. data/rice/config.hpp +3 -0
  25. data/rice/config.hpp.in +3 -0
  26. data/rice/detail/Auto_Function_Wrapper.hpp +69 -0
  27. data/rice/detail/Auto_Function_Wrapper.ipp +815 -512
  28. data/rice/detail/Auto_Member_Function_Wrapper.hpp +69 -0
  29. data/rice/detail/Auto_Member_Function_Wrapper.ipp +543 -272
  30. data/rice/detail/object_call.hpp +1 -0
  31. data/rice/detail/ruby.hpp +0 -9
  32. data/rice/detail/ruby_version_code.hpp +1 -1
  33. data/rice/detail/st.hpp +0 -38
  34. data/rice/protect.hpp +1 -0
  35. data/rice/protect.ipp +1 -0
  36. data/rice/to_from_ruby.ipp +1 -1
  37. data/ruby.ac +2 -2
  38. data/ruby/Makefile.in +221 -134
  39. data/ruby/lib/Makefile.in +133 -44
  40. data/ruby/lib/mkmf-rice.rb.in +1 -4
  41. data/ruby/lib/version.rb +1 -1
  42. data/sample/Makefile.in +96 -31
  43. data/test/Makefile.am +0 -1
  44. data/test/Makefile.in +617 -219
  45. data/test/ext/Makefile.in +96 -31
  46. data/test/test_Class.cpp +2 -2
  47. data/test/test_Data_Object.cpp +11 -11
  48. data/test/test_Hash.cpp +7 -4
  49. data/test/test_Module.cpp +17 -1
  50. data/test/test_To_From_Ruby.cpp +44 -0
  51. data/test/test_rice.rb +2 -2
  52. metadata +29 -43
  53. data/rice/Allocation_Strategies.hpp +0 -37
  54. data/test/test_Allocation_Strategies.cpp +0 -77
data/rice/Module_impl.ipp CHANGED
@@ -155,7 +155,7 @@ define_singleton_method(
155
155
  Arguments* arguments)
156
156
  {
157
157
  detail::define_method_and_auto_wrap(
158
- rb_class_of(*this), name, func, this->handler(), arguments);
158
+ rb_singleton_class(*this), name, func, this->handler(), arguments);
159
159
  return (Derived_T &)*this;
160
160
  }
161
161
 
data/rice/VM.cpp CHANGED
@@ -1,6 +1,6 @@
1
1
  #include "VM.hpp"
2
2
  #include "detail/ruby.hpp"
3
- #include "detail/env.hpp"
3
+ #include "detail/env.hpp"
4
4
  #include "detail/ruby_version_code.hpp"
5
5
 
6
6
  #include <stdexcept>
@@ -33,20 +33,10 @@ Rice::VM::
33
33
  init_stack();
34
34
  }
35
35
 
36
- #if RICE__RUBY_VERSION_CODE < 186
37
- extern "C"
38
- void Init_stack(VALUE *);
39
- #endif
40
-
41
36
  void Rice::VM::
42
37
  init_stack()
43
38
  {
44
- #if RICE__RUBY_VERSION_CODE >= 186
45
39
  RUBY_INIT_STACK;
46
- #else
47
- VALUE v;
48
- Init_stack(&v);
49
- #endif
50
40
  }
51
41
 
52
42
  void Rice::VM::
data/rice/config.hpp CHANGED
@@ -31,6 +31,9 @@
31
31
  /* Define to the one symbol short name of this package. */
32
32
  #define PACKAGE_TARNAME "rice"
33
33
 
34
+ /* Define to the home page for this package. */
35
+ #define PACKAGE_URL ""
36
+
34
37
  /* Define to the version of this package. */
35
38
  #define PACKAGE_VERSION "1.1"
36
39
 
data/rice/config.hpp.in CHANGED
@@ -30,6 +30,9 @@
30
30
  /* Define to the one symbol short name of this package. */
31
31
  #undef PACKAGE_TARNAME
32
32
 
33
+ /* Define to the home page for this package. */
34
+ #undef PACKAGE_URL
35
+
33
36
  /* Define to the version of this package. */
34
37
  #undef PACKAGE_VERSION
35
38
 
data/rice/detail/Auto_Function_Wrapper.hpp CHANGED
@@ -33,6 +33,8 @@ public:
33
33
  Data_Object<Exception_Handler> handler,
34
34
  Arguments* arguments = 0);
35
35
 
36
+ ~Auto_Function_Wrapper();
37
+
36
38
  static VALUE call(int argc, VALUE* args, VALUE self);
37
39
 
38
40
  private:
@@ -56,6 +58,8 @@ public:
56
58
  Data_Object<Exception_Handler> handler,
57
59
  Arguments* arguments = 0);
58
60
 
61
+ ~Auto_Function_Wrapper();
62
+
59
63
  static VALUE call(int argc, VALUE* args, VALUE self);
60
64
 
61
65
  private:
@@ -80,6 +84,8 @@ public:
80
84
  Data_Object<Exception_Handler> handler,
81
85
  Arguments* arguments = 0);
82
86
 
87
+ ~Auto_Function_Wrapper();
88
+
83
89
  static VALUE call(int argc, VALUE* args, VALUE self);
84
90
 
85
91
  private:
@@ -103,6 +109,8 @@ public:
103
109
  Data_Object<Exception_Handler> handler,
104
110
  Arguments* arguments = 0);
105
111
 
112
+ ~Auto_Function_Wrapper();
113
+
106
114
  static VALUE call(int argc, VALUE* args, VALUE self);
107
115
 
108
116
  private:
@@ -127,6 +135,8 @@ public:
127
135
  Data_Object<Exception_Handler> handler,
128
136
  Arguments* arguments = 0);
129
137
 
138
+ ~Auto_Function_Wrapper();
139
+
130
140
  static VALUE call(int argc, VALUE* args, VALUE self);
131
141
 
132
142
  private:
@@ -150,6 +160,8 @@ public:
150
160
  Data_Object<Exception_Handler> handler,
151
161
  Arguments* arguments = 0);
152
162
 
163
+ ~Auto_Function_Wrapper();
164
+
153
165
  static VALUE call(int argc, VALUE* args, VALUE self);
154
166
 
155
167
  private:
@@ -174,6 +186,8 @@ public:
174
186
  Data_Object<Exception_Handler> handler,
175
187
  Arguments* arguments = 0);
176
188
 
189
+ ~Auto_Function_Wrapper();
190
+
177
191
  static VALUE call(int argc, VALUE* args, VALUE self);
178
192
 
179
193
  private:
@@ -197,6 +211,8 @@ public:
197
211
  Data_Object<Exception_Handler> handler,
198
212
  Arguments* arguments = 0);
199
213
 
214
+ ~Auto_Function_Wrapper();
215
+
200
216
  static VALUE call(int argc, VALUE* args, VALUE self);
201
217
 
202
218
  private:
@@ -221,6 +237,8 @@ public:
221
237
  Data_Object<Exception_Handler> handler,
222
238
  Arguments* arguments = 0);
223
239
 
240
+ ~Auto_Function_Wrapper();
241
+
224
242
  static VALUE call(int argc, VALUE* args, VALUE self);
225
243
 
226
244
  private:
@@ -244,6 +262,8 @@ public:
244
262
  Data_Object<Exception_Handler> handler,
245
263
  Arguments* arguments = 0);
246
264
 
265
+ ~Auto_Function_Wrapper();
266
+
247
267
  static VALUE call(int argc, VALUE* args, VALUE self);
248
268
 
249
269
  private:
@@ -268,6 +288,8 @@ public:
268
288
  Data_Object<Exception_Handler> handler,
269
289
  Arguments* arguments = 0);
270
290
 
291
+ ~Auto_Function_Wrapper();
292
+
271
293
  static VALUE call(int argc, VALUE* args, VALUE self);
272
294
 
273
295
  private:
@@ -291,6 +313,8 @@ public:
291
313
  Data_Object<Exception_Handler> handler,
292
314
  Arguments* arguments = 0);
293
315
 
316
+ ~Auto_Function_Wrapper();
317
+
294
318
  static VALUE call(int argc, VALUE* args, VALUE self);
295
319
 
296
320
  private:
@@ -315,6 +339,8 @@ public:
315
339
  Data_Object<Exception_Handler> handler,
316
340
  Arguments* arguments = 0);
317
341
 
342
+ ~Auto_Function_Wrapper();
343
+
318
344
  static VALUE call(int argc, VALUE* args, VALUE self);
319
345
 
320
346
  private:
@@ -338,6 +364,8 @@ public:
338
364
  Data_Object<Exception_Handler> handler,
339
365
  Arguments* arguments = 0);
340
366
 
367
+ ~Auto_Function_Wrapper();
368
+
341
369
  static VALUE call(int argc, VALUE* args, VALUE self);
342
370
 
343
371
  private:
@@ -362,6 +390,8 @@ public:
362
390
  Data_Object<Exception_Handler> handler,
363
391
  Arguments* arguments = 0);
364
392
 
393
+ ~Auto_Function_Wrapper();
394
+
365
395
  static VALUE call(int argc, VALUE* args, VALUE self);
366
396
 
367
397
  private:
@@ -385,6 +415,8 @@ public:
385
415
  Data_Object<Exception_Handler> handler,
386
416
  Arguments* arguments = 0);
387
417
 
418
+ ~Auto_Function_Wrapper();
419
+
388
420
  static VALUE call(int argc, VALUE* args, VALUE self);
389
421
 
390
422
  private:
@@ -409,6 +441,8 @@ public:
409
441
  Data_Object<Exception_Handler> handler,
410
442
  Arguments* arguments = 0);
411
443
 
444
+ ~Auto_Function_Wrapper();
445
+
412
446
  static VALUE call(int argc, VALUE* args, VALUE self);
413
447
 
414
448
  private:
@@ -432,6 +466,8 @@ public:
432
466
  Data_Object<Exception_Handler> handler,
433
467
  Arguments* arguments = 0);
434
468
 
469
+ ~Auto_Function_Wrapper();
470
+
435
471
  static VALUE call(int argc, VALUE* args, VALUE self);
436
472
 
437
473
  private:
@@ -456,6 +492,8 @@ public:
456
492
  Data_Object<Exception_Handler> handler,
457
493
  Arguments* arguments = 0);
458
494
 
495
+ ~Auto_Function_Wrapper();
496
+
459
497
  static VALUE call(int argc, VALUE* args, VALUE self);
460
498
 
461
499
  private:
@@ -479,6 +517,8 @@ public:
479
517
  Data_Object<Exception_Handler> handler,
480
518
  Arguments* arguments = 0);
481
519
 
520
+ ~Auto_Function_Wrapper();
521
+
482
522
  static VALUE call(int argc, VALUE* args, VALUE self);
483
523
 
484
524
  private:
@@ -503,6 +543,8 @@ public:
503
543
  Data_Object<Exception_Handler> handler,
504
544
  Arguments* arguments = 0);
505
545
 
546
+ ~Auto_Function_Wrapper();
547
+
506
548
  static VALUE call(int argc, VALUE* args, VALUE self);
507
549
 
508
550
  private:
@@ -526,6 +568,8 @@ public:
526
568
  Data_Object<Exception_Handler> handler,
527
569
  Arguments* arguments = 0);
528
570
 
571
+ ~Auto_Function_Wrapper();
572
+
529
573
  static VALUE call(int argc, VALUE* args, VALUE self);
530
574
 
531
575
  private:
@@ -550,6 +594,8 @@ public:
550
594
  Data_Object<Exception_Handler> handler,
551
595
  Arguments* arguments = 0);
552
596
 
597
+ ~Auto_Function_Wrapper();
598
+
553
599
  static VALUE call(int argc, VALUE* args, VALUE self);
554
600
 
555
601
  private:
@@ -573,6 +619,8 @@ public:
573
619
  Data_Object<Exception_Handler> handler,
574
620
  Arguments* arguments = 0);
575
621
 
622
+ ~Auto_Function_Wrapper();
623
+
576
624
  static VALUE call(int argc, VALUE* args, VALUE self);
577
625
 
578
626
  private:
@@ -597,6 +645,8 @@ public:
597
645
  Data_Object<Exception_Handler> handler,
598
646
  Arguments* arguments = 0);
599
647
 
648
+ ~Auto_Function_Wrapper();
649
+
600
650
  static VALUE call(int argc, VALUE* args, VALUE self);
601
651
 
602
652
  private:
@@ -620,6 +670,8 @@ public:
620
670
  Data_Object<Exception_Handler> handler,
621
671
  Arguments* arguments = 0);
622
672
 
673
+ ~Auto_Function_Wrapper();
674
+
623
675
  static VALUE call(int argc, VALUE* args, VALUE self);
624
676
 
625
677
  private:
@@ -644,6 +696,8 @@ public:
644
696
  Data_Object<Exception_Handler> handler,
645
697
  Arguments* arguments = 0);
646
698
 
699
+ ~Auto_Function_Wrapper();
700
+
647
701
  static VALUE call(int argc, VALUE* args, VALUE self);
648
702
 
649
703
  private:
@@ -667,6 +721,8 @@ public:
667
721
  Data_Object<Exception_Handler> handler,
668
722
  Arguments* arguments = 0);
669
723
 
724
+ ~Auto_Function_Wrapper();
725
+
670
726
  static VALUE call(int argc, VALUE* args, VALUE self);
671
727
 
672
728
  private:
@@ -691,6 +747,8 @@ public:
691
747
  Data_Object<Exception_Handler> handler,
692
748
  Arguments* arguments = 0);
693
749
 
750
+ ~Auto_Function_Wrapper();
751
+
694
752
  static VALUE call(int argc, VALUE* args, VALUE self);
695
753
 
696
754
  private:
@@ -714,6 +772,8 @@ public:
714
772
  Data_Object<Exception_Handler> handler,
715
773
  Arguments* arguments = 0);
716
774
 
775
+ ~Auto_Function_Wrapper();
776
+
717
777
  static VALUE call(int argc, VALUE* args, VALUE self);
718
778
 
719
779
  private:
@@ -738,6 +798,8 @@ public:
738
798
  Data_Object<Exception_Handler> handler,
739
799
  Arguments* arguments = 0);
740
800
 
801
+ ~Auto_Function_Wrapper();
802
+
741
803
  static VALUE call(int argc, VALUE* args, VALUE self);
742
804
 
743
805
  private:
@@ -761,6 +823,8 @@ public:
761
823
  Data_Object<Exception_Handler> handler,
762
824
  Arguments* arguments = 0);
763
825
 
826
+ ~Auto_Function_Wrapper();
827
+
764
828
  static VALUE call(int argc, VALUE* args, VALUE self);
765
829
 
766
830
  private:
@@ -771,6 +835,7 @@ private:
771
835
  };
772
836
 
773
837
  // ---------------------------------------------------------------------
838
+
774
839
  template<typename Func_T, typename Ret_T>
775
840
  class Auto_Function_Wrapper<Func_T, Ret_T>
776
841
  : public Wrapped_Function
@@ -786,6 +851,8 @@ public:
786
851
  Data_Object<Exception_Handler> handler,
787
852
  Arguments* arguments = new Arguments());
788
853
 
854
+ ~Auto_Function_Wrapper();
855
+
789
856
  static VALUE call();
790
857
 
791
858
  private:
@@ -809,6 +876,8 @@ public:
809
876
  Data_Object<Exception_Handler> handler,
810
877
  Arguments* arguments = new Arguments());
811
878
 
879
+ ~Auto_Function_Wrapper();
880
+
812
881
  static VALUE call();
813
882
 
814
883
  private:
data/rice/detail/Auto_Function_Wrapper.ipp CHANGED
@@ -35,6 +35,13 @@ Auto_Function_Wrapper(
35
35
  }
36
36
  }
37
37
 
38
+ template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T, typename Arg13_T, typename Arg14_T, typename Arg15_T>
39
+ Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T, Arg14_T, Arg15_T>::
40
+ ~Auto_Function_Wrapper()
41
+ {
42
+ if(arguments_) { delete arguments_; }
43
+ }
44
+
38
45
  template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T, typename Arg13_T, typename Arg14_T, typename Arg15_T>
39
46
  VALUE Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T, Arg14_T, Arg15_T>::
40
47
  call(int argc, VALUE *argv, VALUE self)
@@ -61,73 +68,75 @@ call(int argc, VALUE *argv, VALUE self)
61
68
 
62
69
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
63
70
 
64
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
71
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
65
72
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
66
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
73
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
67
74
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
68
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
75
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
69
76
  Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
70
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
77
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
71
78
  Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
72
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
79
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
73
80
  Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
74
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
81
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
75
82
  Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
76
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
83
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
77
84
  Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
78
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
85
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
79
86
  Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
80
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
87
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
81
88
  Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
82
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
89
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
83
90
  Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
84
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
91
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
85
92
  Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
86
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
93
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
87
94
  Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
88
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
95
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
89
96
  Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(12, varg12);
90
- typedef typename sanitize< Arg14_T >::Type Arg14_Type;
97
+ typedef typename sanitize< Arg14_T >::Type Arg14_Type;
91
98
  Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(13, varg13);
92
- typedef typename sanitize< Arg15_T >::Type Arg15_Type;
99
+ typedef typename sanitize< Arg15_T >::Type Arg15_Type;
93
100
  Arg15_Type arg15 = args->getArgumentOrDefault<Arg15_Type>(14, varg14);
101
+
94
102
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15));
95
103
  } else {
96
104
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
97
105
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14, &varg15);
98
106
 
99
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
107
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
100
108
  Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
101
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
109
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
102
110
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
103
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
111
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
104
112
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
105
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
113
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
106
114
  Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
107
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
115
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
108
116
  Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
109
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
117
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
110
118
  Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
111
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
119
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
112
120
  Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
113
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
121
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
114
122
  Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
115
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
123
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
116
124
  Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
117
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
125
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
118
126
  Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
119
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
127
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
120
128
  Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
121
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
129
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
122
130
  Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
123
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
131
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
124
132
  Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
125
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
133
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
126
134
  Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
127
- typedef typename sanitize< Arg14_T >::Type Arg14_Type;
135
+ typedef typename sanitize< Arg14_T >::Type Arg14_Type;
128
136
  Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(14, varg14);
129
- typedef typename sanitize< Arg15_T >::Type Arg15_Type;
137
+ typedef typename sanitize< Arg15_T >::Type Arg15_Type;
130
138
  Arg15_Type arg15 = args->getArgumentOrDefault<Arg15_Type>(15, varg15);
139
+
131
140
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15));
132
141
  }
133
142
  }
@@ -166,6 +175,13 @@ Auto_Function_Wrapper(
166
175
  }
167
176
  }
168
177
 
178
+ template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T, typename Arg13_T, typename Arg14_T, typename Arg15_T>
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>::
180
+ ~Auto_Function_Wrapper()
181
+ {
182
+ if(arguments_) { delete arguments_; }
183
+ }
184
+
169
185
  template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T, typename Arg13_T, typename Arg14_T, typename Arg15_T>
170
186
  VALUE 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>::
171
187
  call(int argc, VALUE* argv, VALUE self)
@@ -192,74 +208,76 @@ call(int argc, VALUE* argv, VALUE self)
192
208
 
193
209
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
194
210
 
195
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
211
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
196
212
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
197
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
213
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
198
214
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
199
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
215
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
200
216
  Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
201
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
217
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
202
218
  Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
203
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
219
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
204
220
  Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
205
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
221
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
206
222
  Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
207
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
223
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
208
224
  Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
209
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
225
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
210
226
  Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
211
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
227
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
212
228
  Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
213
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
229
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
214
230
  Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
215
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
231
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
216
232
  Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
217
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
233
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
218
234
  Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
219
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
235
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
220
236
  Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(12, varg12);
221
- typedef typename sanitize< Arg14_T >::Type Arg14_Type;
237
+ typedef typename sanitize< Arg14_T >::Type Arg14_Type;
222
238
  Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(13, varg13);
223
- typedef typename sanitize< Arg15_T >::Type Arg15_Type;
239
+ typedef typename sanitize< Arg15_T >::Type Arg15_Type;
224
240
  Arg15_Type arg15 = args->getArgumentOrDefault<Arg15_Type>(14, varg14);
241
+
225
242
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15);
226
243
  return Qnil;
227
244
  } else {
228
245
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
229
246
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14, &varg15);
230
247
 
231
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
248
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
232
249
  Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
233
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
250
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
234
251
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
235
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
252
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
236
253
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
237
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
254
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
238
255
  Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
239
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
256
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
240
257
  Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
241
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
258
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
242
259
  Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
243
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
260
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
244
261
  Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
245
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
262
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
246
263
  Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
247
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
264
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
248
265
  Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
249
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
266
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
250
267
  Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
251
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
268
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
252
269
  Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
253
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
270
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
254
271
  Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
255
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
272
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
256
273
  Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
257
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
274
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
258
275
  Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
259
- typedef typename sanitize< Arg14_T >::Type Arg14_Type;
276
+ typedef typename sanitize< Arg14_T >::Type Arg14_Type;
260
277
  Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(14, varg14);
261
- typedef typename sanitize< Arg15_T >::Type Arg15_Type;
278
+ typedef typename sanitize< Arg15_T >::Type Arg15_Type;
262
279
  Arg15_Type arg15 = args->getArgumentOrDefault<Arg15_Type>(15, varg15);
280
+
263
281
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15);
264
282
  return Qnil;
265
283
  }
@@ -300,6 +318,13 @@ Auto_Function_Wrapper(
300
318
  }
301
319
  }
302
320
 
321
+ template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T, typename Arg13_T, typename Arg14_T>
322
+ Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T, Arg14_T>::
323
+ ~Auto_Function_Wrapper()
324
+ {
325
+ if(arguments_) { delete arguments_; }
326
+ }
327
+
303
328
  template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T, typename Arg13_T, typename Arg14_T>
304
329
  VALUE Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T, Arg14_T>::
305
330
  call(int argc, VALUE *argv, VALUE self)
@@ -326,69 +351,71 @@ call(int argc, VALUE *argv, VALUE self)
326
351
 
327
352
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
328
353
 
329
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
354
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
330
355
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
331
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
356
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
332
357
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
333
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
358
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
334
359
  Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
335
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
360
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
336
361
  Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
337
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
362
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
338
363
  Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
339
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
364
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
340
365
  Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
341
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
366
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
342
367
  Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
343
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
368
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
344
369
  Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
345
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
370
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
346
371
  Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
347
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
372
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
348
373
  Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
349
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
374
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
350
375
  Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
351
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
376
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
352
377
  Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
353
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
378
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
354
379
  Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(12, varg12);
355
- typedef typename sanitize< Arg14_T >::Type Arg14_Type;
380
+ typedef typename sanitize< Arg14_T >::Type Arg14_Type;
356
381
  Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(13, varg13);
382
+
357
383
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14));
358
384
  } else {
359
385
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
360
386
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14);
361
387
 
362
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
388
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
363
389
  Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
364
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
390
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
365
391
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
366
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
392
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
367
393
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
368
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
394
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
369
395
  Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
370
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
396
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
371
397
  Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
372
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
398
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
373
399
  Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
374
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
400
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
375
401
  Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
376
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
402
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
377
403
  Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
378
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
404
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
379
405
  Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
380
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
406
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
381
407
  Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
382
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
408
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
383
409
  Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
384
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
410
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
385
411
  Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
386
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
412
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
387
413
  Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
388
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
414
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
389
415
  Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
390
- typedef typename sanitize< Arg14_T >::Type Arg14_Type;
416
+ typedef typename sanitize< Arg14_T >::Type Arg14_Type;
391
417
  Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(14, varg14);
418
+
392
419
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14));
393
420
  }
394
421
  }
@@ -427,6 +454,13 @@ Auto_Function_Wrapper(
427
454
  }
428
455
  }
429
456
 
457
+ template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T, typename Arg13_T, typename Arg14_T>
458
+ 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>::
459
+ ~Auto_Function_Wrapper()
460
+ {
461
+ if(arguments_) { delete arguments_; }
462
+ }
463
+
430
464
  template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T, typename Arg13_T, typename Arg14_T>
431
465
  VALUE 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>::
432
466
  call(int argc, VALUE* argv, VALUE self)
@@ -453,70 +487,72 @@ call(int argc, VALUE* argv, VALUE self)
453
487
 
454
488
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
455
489
 
456
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
490
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
457
491
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
458
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
492
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
459
493
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
460
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
494
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
461
495
  Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
462
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
496
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
463
497
  Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
464
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
498
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
465
499
  Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
466
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
500
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
467
501
  Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
468
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
502
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
469
503
  Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
470
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
504
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
471
505
  Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
472
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
506
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
473
507
  Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
474
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
508
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
475
509
  Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
476
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
510
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
477
511
  Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
478
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
512
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
479
513
  Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
480
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
514
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
481
515
  Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(12, varg12);
482
- typedef typename sanitize< Arg14_T >::Type Arg14_Type;
516
+ typedef typename sanitize< Arg14_T >::Type Arg14_Type;
483
517
  Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(13, varg13);
518
+
484
519
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
485
520
  return Qnil;
486
521
  } else {
487
522
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
488
523
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14);
489
524
 
490
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
525
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
491
526
  Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
492
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
527
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
493
528
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
494
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
529
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
495
530
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
496
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
531
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
497
532
  Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
498
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
533
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
499
534
  Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
500
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
535
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
501
536
  Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
502
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
537
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
503
538
  Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
504
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
539
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
505
540
  Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
506
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
541
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
507
542
  Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
508
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
543
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
509
544
  Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
510
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
545
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
511
546
  Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
512
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
547
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
513
548
  Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
514
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
549
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
515
550
  Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
516
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
551
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
517
552
  Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
518
- typedef typename sanitize< Arg14_T >::Type Arg14_Type;
553
+ typedef typename sanitize< Arg14_T >::Type Arg14_Type;
519
554
  Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(14, varg14);
555
+
520
556
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
521
557
  return Qnil;
522
558
  }
@@ -557,6 +593,13 @@ Auto_Function_Wrapper(
557
593
  }
558
594
  }
559
595
 
596
+ template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T, typename Arg13_T>
597
+ Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T>::
598
+ ~Auto_Function_Wrapper()
599
+ {
600
+ if(arguments_) { delete arguments_; }
601
+ }
602
+
560
603
  template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T, typename Arg13_T>
561
604
  VALUE Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T>::
562
605
  call(int argc, VALUE *argv, VALUE self)
@@ -583,65 +626,67 @@ call(int argc, VALUE *argv, VALUE self)
583
626
 
584
627
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
585
628
 
586
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
629
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
587
630
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
588
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
631
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
589
632
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
590
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
633
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
591
634
  Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
592
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
635
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
593
636
  Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
594
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
637
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
595
638
  Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
596
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
639
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
597
640
  Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
598
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
641
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
599
642
  Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
600
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
643
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
601
644
  Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
602
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
645
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
603
646
  Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
604
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
647
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
605
648
  Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
606
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
649
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
607
650
  Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
608
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
651
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
609
652
  Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
610
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
653
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
611
654
  Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(12, varg12);
655
+
612
656
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13));
613
657
  } else {
614
658
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
615
659
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13);
616
660
 
617
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
661
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
618
662
  Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
619
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
663
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
620
664
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
621
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
665
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
622
666
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
623
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
667
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
624
668
  Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
625
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
669
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
626
670
  Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
627
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
671
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
628
672
  Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
629
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
673
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
630
674
  Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
631
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
675
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
632
676
  Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
633
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
677
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
634
678
  Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
635
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
679
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
636
680
  Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
637
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
681
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
638
682
  Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
639
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
683
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
640
684
  Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
641
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
685
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
642
686
  Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
643
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
687
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
644
688
  Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
689
+
645
690
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13));
646
691
  }
647
692
  }
@@ -680,6 +725,13 @@ Auto_Function_Wrapper(
680
725
  }
681
726
  }
682
727
 
728
+ template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T, typename Arg13_T>
729
+ 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>::
730
+ ~Auto_Function_Wrapper()
731
+ {
732
+ if(arguments_) { delete arguments_; }
733
+ }
734
+
683
735
  template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T, typename Arg13_T>
684
736
  VALUE 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>::
685
737
  call(int argc, VALUE* argv, VALUE self)
@@ -706,66 +758,68 @@ call(int argc, VALUE* argv, VALUE self)
706
758
 
707
759
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
708
760
 
709
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
761
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
710
762
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
711
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
763
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
712
764
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
713
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
765
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
714
766
  Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
715
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
767
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
716
768
  Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
717
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
769
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
718
770
  Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
719
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
771
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
720
772
  Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
721
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
773
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
722
774
  Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
723
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
775
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
724
776
  Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
725
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
777
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
726
778
  Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
727
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
779
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
728
780
  Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
729
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
781
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
730
782
  Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
731
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
783
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
732
784
  Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
733
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
785
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
734
786
  Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(12, varg12);
787
+
735
788
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
736
789
  return Qnil;
737
790
  } else {
738
791
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
739
792
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13);
740
793
 
741
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
794
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
742
795
  Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
743
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
796
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
744
797
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
745
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
798
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
746
799
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
747
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
800
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
748
801
  Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
749
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
802
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
750
803
  Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
751
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
804
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
752
805
  Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
753
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
806
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
754
807
  Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
755
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
808
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
756
809
  Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
757
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
810
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
758
811
  Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
759
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
812
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
760
813
  Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
761
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
814
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
762
815
  Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
763
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
816
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
764
817
  Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
765
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
818
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
766
819
  Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
767
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
820
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
768
821
  Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
822
+
769
823
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
770
824
  return Qnil;
771
825
  }
@@ -806,6 +860,13 @@ Auto_Function_Wrapper(
806
860
  }
807
861
  }
808
862
 
863
+ template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T>
864
+ Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T>::
865
+ ~Auto_Function_Wrapper()
866
+ {
867
+ if(arguments_) { delete arguments_; }
868
+ }
869
+
809
870
  template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T>
810
871
  VALUE Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T>::
811
872
  call(int argc, VALUE *argv, VALUE self)
@@ -832,61 +893,63 @@ call(int argc, VALUE *argv, VALUE self)
832
893
 
833
894
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
834
895
 
835
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
896
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
836
897
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
837
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
898
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
838
899
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
839
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
900
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
840
901
  Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
841
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
902
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
842
903
  Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
843
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
904
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
844
905
  Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
845
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
906
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
846
907
  Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
847
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
908
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
848
909
  Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
849
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
910
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
850
911
  Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
851
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
912
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
852
913
  Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
853
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
914
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
854
915
  Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
855
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
916
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
856
917
  Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
857
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
918
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
858
919
  Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
920
+
859
921
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12));
860
922
  } else {
861
923
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
862
924
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12);
863
925
 
864
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
926
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
865
927
  Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
866
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
928
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
867
929
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
868
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
930
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
869
931
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
870
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
932
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
871
933
  Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
872
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
934
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
873
935
  Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
874
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
936
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
875
937
  Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
876
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
938
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
877
939
  Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
878
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
940
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
879
941
  Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
880
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
942
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
881
943
  Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
882
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
944
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
883
945
  Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
884
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
946
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
885
947
  Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
886
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
948
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
887
949
  Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
888
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
950
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
889
951
  Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
952
+
890
953
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12));
891
954
  }
892
955
  }
@@ -925,6 +988,13 @@ Auto_Function_Wrapper(
925
988
  }
926
989
  }
927
990
 
991
+ template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T>
992
+ 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>::
993
+ ~Auto_Function_Wrapper()
994
+ {
995
+ if(arguments_) { delete arguments_; }
996
+ }
997
+
928
998
  template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T>
929
999
  VALUE 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>::
930
1000
  call(int argc, VALUE* argv, VALUE self)
@@ -951,62 +1021,64 @@ call(int argc, VALUE* argv, VALUE self)
951
1021
 
952
1022
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
953
1023
 
954
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1024
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
955
1025
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
956
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1026
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
957
1027
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
958
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1028
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
959
1029
  Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
960
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1030
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
961
1031
  Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
962
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1032
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
963
1033
  Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
964
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1034
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
965
1035
  Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
966
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1036
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
967
1037
  Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
968
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1038
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
969
1039
  Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
970
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1040
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
971
1041
  Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
972
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1042
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
973
1043
  Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
974
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
1044
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
975
1045
  Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
976
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
1046
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
977
1047
  Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
1048
+
978
1049
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
979
1050
  return Qnil;
980
1051
  } else {
981
1052
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
982
1053
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12);
983
1054
 
984
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1055
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
985
1056
  Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
986
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1057
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
987
1058
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
988
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1059
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
989
1060
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
990
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1061
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
991
1062
  Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
992
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1063
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
993
1064
  Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
994
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1065
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
995
1066
  Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
996
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1067
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
997
1068
  Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
998
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1069
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
999
1070
  Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1000
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1071
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1001
1072
  Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1002
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1073
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1003
1074
  Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1004
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1075
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1005
1076
  Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
1006
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
1077
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
1007
1078
  Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
1008
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
1079
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
1009
1080
  Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
1081
+
1010
1082
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
1011
1083
  return Qnil;
1012
1084
  }
@@ -1047,6 +1119,13 @@ Auto_Function_Wrapper(
1047
1119
  }
1048
1120
  }
1049
1121
 
1122
+ template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T>
1123
+ Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T>::
1124
+ ~Auto_Function_Wrapper()
1125
+ {
1126
+ if(arguments_) { delete arguments_; }
1127
+ }
1128
+
1050
1129
  template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T>
1051
1130
  VALUE Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T>::
1052
1131
  call(int argc, VALUE *argv, VALUE self)
@@ -1073,57 +1152,59 @@ call(int argc, VALUE *argv, VALUE self)
1073
1152
 
1074
1153
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
1075
1154
 
1076
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1155
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1077
1156
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1078
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1157
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1079
1158
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1080
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1159
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1081
1160
  Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1082
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1161
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1083
1162
  Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1084
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1163
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1085
1164
  Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1086
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1165
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1087
1166
  Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1088
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1167
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1089
1168
  Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1090
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1169
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1091
1170
  Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1092
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1171
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1093
1172
  Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
1094
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1173
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1095
1174
  Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
1096
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
1175
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
1097
1176
  Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
1177
+
1098
1178
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11));
1099
1179
  } else {
1100
1180
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
1101
1181
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11);
1102
1182
 
1103
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1183
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1104
1184
  Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1105
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1185
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1106
1186
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1107
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1187
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1108
1188
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1109
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1189
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1110
1190
  Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1111
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1191
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1112
1192
  Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1113
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1193
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1114
1194
  Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1115
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1195
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1116
1196
  Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1117
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1197
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1118
1198
  Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1119
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1199
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1120
1200
  Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1121
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1201
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1122
1202
  Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1123
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1203
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1124
1204
  Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
1125
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
1205
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
1126
1206
  Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
1207
+
1127
1208
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11));
1128
1209
  }
1129
1210
  }
@@ -1162,6 +1243,13 @@ Auto_Function_Wrapper(
1162
1243
  }
1163
1244
  }
1164
1245
 
1246
+ template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T>
1247
+ 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>::
1248
+ ~Auto_Function_Wrapper()
1249
+ {
1250
+ if(arguments_) { delete arguments_; }
1251
+ }
1252
+
1165
1253
  template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T>
1166
1254
  VALUE 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>::
1167
1255
  call(int argc, VALUE* argv, VALUE self)
@@ -1188,58 +1276,60 @@ call(int argc, VALUE* argv, VALUE self)
1188
1276
 
1189
1277
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
1190
1278
 
1191
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1279
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1192
1280
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1193
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1281
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1194
1282
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1195
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1283
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1196
1284
  Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1197
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1285
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1198
1286
  Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1199
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1287
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1200
1288
  Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1201
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1289
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1202
1290
  Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1203
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1291
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1204
1292
  Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1205
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1293
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1206
1294
  Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1207
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1295
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1208
1296
  Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
1209
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1297
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1210
1298
  Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
1211
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
1299
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
1212
1300
  Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
1301
+
1213
1302
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
1214
1303
  return Qnil;
1215
1304
  } else {
1216
1305
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
1217
1306
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11);
1218
1307
 
1219
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1308
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1220
1309
  Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1221
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1310
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1222
1311
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1223
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1312
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1224
1313
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1225
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1314
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1226
1315
  Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1227
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1316
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1228
1317
  Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1229
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1318
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1230
1319
  Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1231
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1320
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1232
1321
  Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1233
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1322
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1234
1323
  Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1235
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1324
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1236
1325
  Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1237
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1326
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1238
1327
  Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1239
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1328
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1240
1329
  Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
1241
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
1330
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
1242
1331
  Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
1332
+
1243
1333
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
1244
1334
  return Qnil;
1245
1335
  }
@@ -1280,6 +1370,13 @@ Auto_Function_Wrapper(
1280
1370
  }
1281
1371
  }
1282
1372
 
1373
+ template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T>
1374
+ Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T>::
1375
+ ~Auto_Function_Wrapper()
1376
+ {
1377
+ if(arguments_) { delete arguments_; }
1378
+ }
1379
+
1283
1380
  template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T>
1284
1381
  VALUE Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T>::
1285
1382
  call(int argc, VALUE *argv, VALUE self)
@@ -1306,53 +1403,55 @@ call(int argc, VALUE *argv, VALUE self)
1306
1403
 
1307
1404
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
1308
1405
 
1309
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1406
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1310
1407
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1311
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1408
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1312
1409
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1313
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1410
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1314
1411
  Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1315
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1412
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1316
1413
  Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1317
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1414
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1318
1415
  Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1319
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1416
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1320
1417
  Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1321
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1418
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1322
1419
  Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1323
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1420
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1324
1421
  Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1325
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1422
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1326
1423
  Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
1327
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1424
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1328
1425
  Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
1426
+
1329
1427
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10));
1330
1428
  } else {
1331
1429
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
1332
1430
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10);
1333
1431
 
1334
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1432
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1335
1433
  Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1336
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1434
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1337
1435
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1338
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1436
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1339
1437
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1340
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1438
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1341
1439
  Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1342
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1440
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1343
1441
  Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1344
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1442
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1345
1443
  Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1346
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1444
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1347
1445
  Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1348
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1446
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1349
1447
  Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1350
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1448
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1351
1449
  Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1352
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1450
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1353
1451
  Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1354
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1452
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1355
1453
  Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
1454
+
1356
1455
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10));
1357
1456
  }
1358
1457
  }
@@ -1391,6 +1490,13 @@ Auto_Function_Wrapper(
1391
1490
  }
1392
1491
  }
1393
1492
 
1493
+ template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T>
1494
+ 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>::
1495
+ ~Auto_Function_Wrapper()
1496
+ {
1497
+ if(arguments_) { delete arguments_; }
1498
+ }
1499
+
1394
1500
  template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T>
1395
1501
  VALUE 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>::
1396
1502
  call(int argc, VALUE* argv, VALUE self)
@@ -1417,54 +1523,56 @@ call(int argc, VALUE* argv, VALUE self)
1417
1523
 
1418
1524
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
1419
1525
 
1420
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1526
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1421
1527
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1422
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1528
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1423
1529
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1424
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1530
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1425
1531
  Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1426
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1532
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1427
1533
  Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1428
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1534
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1429
1535
  Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1430
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1536
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1431
1537
  Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1432
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1538
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1433
1539
  Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1434
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1540
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1435
1541
  Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1436
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1542
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1437
1543
  Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
1438
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1544
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1439
1545
  Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
1546
+
1440
1547
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
1441
1548
  return Qnil;
1442
1549
  } else {
1443
1550
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
1444
1551
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10);
1445
1552
 
1446
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1553
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1447
1554
  Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1448
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1555
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1449
1556
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1450
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1557
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1451
1558
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1452
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1559
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1453
1560
  Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1454
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1561
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1455
1562
  Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1456
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1563
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1457
1564
  Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1458
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1565
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1459
1566
  Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1460
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1567
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1461
1568
  Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1462
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1569
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1463
1570
  Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1464
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1571
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1465
1572
  Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1466
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1573
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1467
1574
  Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
1575
+
1468
1576
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
1469
1577
  return Qnil;
1470
1578
  }
@@ -1505,6 +1613,13 @@ Auto_Function_Wrapper(
1505
1613
  }
1506
1614
  }
1507
1615
 
1616
+ template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T>
1617
+ Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T>::
1618
+ ~Auto_Function_Wrapper()
1619
+ {
1620
+ if(arguments_) { delete arguments_; }
1621
+ }
1622
+
1508
1623
  template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T>
1509
1624
  VALUE Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T>::
1510
1625
  call(int argc, VALUE *argv, VALUE self)
@@ -1531,49 +1646,51 @@ call(int argc, VALUE *argv, VALUE self)
1531
1646
 
1532
1647
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
1533
1648
 
1534
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1649
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1535
1650
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1536
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1651
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1537
1652
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1538
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1653
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1539
1654
  Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1540
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1655
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1541
1656
  Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1542
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1657
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1543
1658
  Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1544
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1659
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1545
1660
  Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1546
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1661
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1547
1662
  Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1548
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1663
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1549
1664
  Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1550
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1665
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1551
1666
  Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
1667
+
1552
1668
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9));
1553
1669
  } else {
1554
1670
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
1555
1671
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9);
1556
1672
 
1557
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1673
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1558
1674
  Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1559
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1675
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1560
1676
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1561
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1677
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1562
1678
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1563
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1679
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1564
1680
  Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1565
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1681
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1566
1682
  Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1567
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1683
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1568
1684
  Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1569
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1685
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1570
1686
  Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1571
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1687
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1572
1688
  Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1573
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1689
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1574
1690
  Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1575
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1691
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1576
1692
  Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1693
+
1577
1694
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9));
1578
1695
  }
1579
1696
  }
@@ -1612,6 +1729,13 @@ Auto_Function_Wrapper(
1612
1729
  }
1613
1730
  }
1614
1731
 
1732
+ template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T>
1733
+ 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>::
1734
+ ~Auto_Function_Wrapper()
1735
+ {
1736
+ if(arguments_) { delete arguments_; }
1737
+ }
1738
+
1615
1739
  template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T>
1616
1740
  VALUE 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>::
1617
1741
  call(int argc, VALUE* argv, VALUE self)
@@ -1638,50 +1762,52 @@ call(int argc, VALUE* argv, VALUE self)
1638
1762
 
1639
1763
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
1640
1764
 
1641
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1765
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1642
1766
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1643
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1767
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1644
1768
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1645
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1769
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1646
1770
  Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1647
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1771
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1648
1772
  Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1649
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1773
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1650
1774
  Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1651
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1775
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1652
1776
  Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1653
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1777
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1654
1778
  Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1655
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1779
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1656
1780
  Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1657
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1781
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1658
1782
  Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
1783
+
1659
1784
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
1660
1785
  return Qnil;
1661
1786
  } else {
1662
1787
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
1663
1788
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9);
1664
1789
 
1665
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1790
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1666
1791
  Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1667
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1792
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1668
1793
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1669
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1794
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1670
1795
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1671
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1796
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1672
1797
  Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1673
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1798
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1674
1799
  Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1675
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1800
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1676
1801
  Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1677
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1802
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1678
1803
  Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1679
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1804
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1680
1805
  Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1681
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1806
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1682
1807
  Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1683
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1808
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1684
1809
  Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1810
+
1685
1811
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
1686
1812
  return Qnil;
1687
1813
  }
@@ -1722,6 +1848,13 @@ Auto_Function_Wrapper(
1722
1848
  }
1723
1849
  }
1724
1850
 
1851
+ template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T>
1852
+ Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T>::
1853
+ ~Auto_Function_Wrapper()
1854
+ {
1855
+ if(arguments_) { delete arguments_; }
1856
+ }
1857
+
1725
1858
  template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T>
1726
1859
  VALUE Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T>::
1727
1860
  call(int argc, VALUE *argv, VALUE self)
@@ -1748,45 +1881,47 @@ call(int argc, VALUE *argv, VALUE self)
1748
1881
 
1749
1882
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
1750
1883
 
1751
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1884
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1752
1885
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1753
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1886
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1754
1887
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1755
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1888
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1756
1889
  Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1757
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1890
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1758
1891
  Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1759
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1892
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1760
1893
  Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1761
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1894
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1762
1895
  Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1763
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1896
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1764
1897
  Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1765
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1898
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1766
1899
  Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1900
+
1767
1901
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8));
1768
1902
  } else {
1769
1903
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
1770
1904
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8);
1771
1905
 
1772
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1906
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1773
1907
  Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1774
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1908
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1775
1909
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1776
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1910
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1777
1911
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1778
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1912
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1779
1913
  Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1780
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1914
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1781
1915
  Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1782
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1916
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1783
1917
  Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1784
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1918
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1785
1919
  Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1786
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1920
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1787
1921
  Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1788
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1922
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1789
1923
  Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1924
+
1790
1925
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8));
1791
1926
  }
1792
1927
  }
@@ -1825,6 +1960,13 @@ Auto_Function_Wrapper(
1825
1960
  }
1826
1961
  }
1827
1962
 
1963
+ template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T>
1964
+ Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T>::
1965
+ ~Auto_Function_Wrapper()
1966
+ {
1967
+ if(arguments_) { delete arguments_; }
1968
+ }
1969
+
1828
1970
  template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T>
1829
1971
  VALUE Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T>::
1830
1972
  call(int argc, VALUE* argv, VALUE self)
@@ -1851,46 +1993,48 @@ call(int argc, VALUE* argv, VALUE self)
1851
1993
 
1852
1994
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
1853
1995
 
1854
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1996
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1855
1997
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1856
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1998
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1857
1999
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1858
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2000
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1859
2001
  Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1860
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2002
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1861
2003
  Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1862
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2004
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1863
2005
  Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1864
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2006
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1865
2007
  Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1866
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
2008
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1867
2009
  Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1868
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
2010
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1869
2011
  Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
2012
+
1870
2013
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
1871
2014
  return Qnil;
1872
2015
  } else {
1873
2016
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
1874
2017
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8);
1875
2018
 
1876
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2019
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1877
2020
  Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1878
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2021
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1879
2022
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1880
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2023
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1881
2024
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1882
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2025
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1883
2026
  Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1884
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2027
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1885
2028
  Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1886
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2029
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1887
2030
  Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1888
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2031
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1889
2032
  Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1890
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
2033
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1891
2034
  Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1892
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
2035
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1893
2036
  Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
2037
+
1894
2038
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
1895
2039
  return Qnil;
1896
2040
  }
@@ -1931,6 +2075,13 @@ Auto_Function_Wrapper(
1931
2075
  }
1932
2076
  }
1933
2077
 
2078
+ template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T>
2079
+ Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T>::
2080
+ ~Auto_Function_Wrapper()
2081
+ {
2082
+ if(arguments_) { delete arguments_; }
2083
+ }
2084
+
1934
2085
  template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T>
1935
2086
  VALUE Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T>::
1936
2087
  call(int argc, VALUE *argv, VALUE self)
@@ -1957,41 +2108,43 @@ call(int argc, VALUE *argv, VALUE self)
1957
2108
 
1958
2109
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
1959
2110
 
1960
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2111
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1961
2112
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1962
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2113
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1963
2114
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1964
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2115
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1965
2116
  Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1966
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2117
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1967
2118
  Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1968
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2119
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1969
2120
  Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1970
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2121
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1971
2122
  Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1972
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
2123
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1973
2124
  Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
2125
+
1974
2126
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7));
1975
2127
  } else {
1976
2128
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
1977
2129
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7);
1978
2130
 
1979
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2131
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1980
2132
  Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1981
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2133
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1982
2134
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1983
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2135
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1984
2136
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1985
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2137
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1986
2138
  Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1987
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2139
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1988
2140
  Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1989
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2141
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1990
2142
  Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1991
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2143
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1992
2144
  Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1993
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
2145
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1994
2146
  Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
2147
+
1995
2148
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7));
1996
2149
  }
1997
2150
  }
@@ -2030,6 +2183,13 @@ Auto_Function_Wrapper(
2030
2183
  }
2031
2184
  }
2032
2185
 
2186
+ template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T>
2187
+ Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T>::
2188
+ ~Auto_Function_Wrapper()
2189
+ {
2190
+ if(arguments_) { delete arguments_; }
2191
+ }
2192
+
2033
2193
  template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T>
2034
2194
  VALUE Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T>::
2035
2195
  call(int argc, VALUE* argv, VALUE self)
@@ -2056,42 +2216,44 @@ call(int argc, VALUE* argv, VALUE self)
2056
2216
 
2057
2217
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
2058
2218
 
2059
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2219
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2060
2220
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2061
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2221
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2062
2222
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2063
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2223
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2064
2224
  Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2065
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2225
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2066
2226
  Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2067
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2227
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2068
2228
  Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
2069
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2229
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2070
2230
  Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
2071
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
2231
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
2072
2232
  Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
2233
+
2073
2234
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
2074
2235
  return Qnil;
2075
2236
  } else {
2076
2237
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
2077
2238
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7);
2078
2239
 
2079
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2240
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2080
2241
  Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2081
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2242
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2082
2243
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2083
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2244
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2084
2245
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2085
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2246
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2086
2247
  Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2087
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2248
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2088
2249
  Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2089
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2250
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2090
2251
  Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
2091
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2252
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2092
2253
  Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
2093
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
2254
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
2094
2255
  Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
2256
+
2095
2257
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
2096
2258
  return Qnil;
2097
2259
  }
@@ -2132,6 +2294,13 @@ Auto_Function_Wrapper(
2132
2294
  }
2133
2295
  }
2134
2296
 
2297
+ template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T>
2298
+ Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T>::
2299
+ ~Auto_Function_Wrapper()
2300
+ {
2301
+ if(arguments_) { delete arguments_; }
2302
+ }
2303
+
2135
2304
  template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T>
2136
2305
  VALUE Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T>::
2137
2306
  call(int argc, VALUE *argv, VALUE self)
@@ -2158,37 +2327,39 @@ call(int argc, VALUE *argv, VALUE self)
2158
2327
 
2159
2328
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
2160
2329
 
2161
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2330
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2162
2331
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2163
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2332
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2164
2333
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2165
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2334
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2166
2335
  Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2167
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2336
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2168
2337
  Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2169
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2338
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2170
2339
  Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
2171
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2340
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2172
2341
  Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
2342
+
2173
2343
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6));
2174
2344
  } else {
2175
2345
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
2176
2346
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6);
2177
2347
 
2178
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2348
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2179
2349
  Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2180
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2350
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2181
2351
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2182
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2352
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2183
2353
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2184
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2354
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2185
2355
  Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2186
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2356
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2187
2357
  Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2188
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2358
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2189
2359
  Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
2190
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2360
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2191
2361
  Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
2362
+
2192
2363
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6));
2193
2364
  }
2194
2365
  }
@@ -2227,6 +2398,13 @@ Auto_Function_Wrapper(
2227
2398
  }
2228
2399
  }
2229
2400
 
2401
+ template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T>
2402
+ Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T>::
2403
+ ~Auto_Function_Wrapper()
2404
+ {
2405
+ if(arguments_) { delete arguments_; }
2406
+ }
2407
+
2230
2408
  template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T>
2231
2409
  VALUE Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T>::
2232
2410
  call(int argc, VALUE* argv, VALUE self)
@@ -2253,38 +2431,40 @@ call(int argc, VALUE* argv, VALUE self)
2253
2431
 
2254
2432
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
2255
2433
 
2256
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2434
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2257
2435
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2258
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2436
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2259
2437
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2260
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2438
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2261
2439
  Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2262
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2440
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2263
2441
  Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2264
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2442
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2265
2443
  Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
2266
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2444
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2267
2445
  Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
2446
+
2268
2447
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
2269
2448
  return Qnil;
2270
2449
  } else {
2271
2450
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
2272
2451
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6);
2273
2452
 
2274
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2453
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2275
2454
  Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2276
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2455
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2277
2456
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2278
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2457
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2279
2458
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2280
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2459
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2281
2460
  Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2282
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2461
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2283
2462
  Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2284
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2463
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2285
2464
  Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
2286
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2465
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2287
2466
  Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
2467
+
2288
2468
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
2289
2469
  return Qnil;
2290
2470
  }
@@ -2325,6 +2505,13 @@ Auto_Function_Wrapper(
2325
2505
  }
2326
2506
  }
2327
2507
 
2508
+ template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T>
2509
+ Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T>::
2510
+ ~Auto_Function_Wrapper()
2511
+ {
2512
+ if(arguments_) { delete arguments_; }
2513
+ }
2514
+
2328
2515
  template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T>
2329
2516
  VALUE Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T>::
2330
2517
  call(int argc, VALUE *argv, VALUE self)
@@ -2351,33 +2538,35 @@ call(int argc, VALUE *argv, VALUE self)
2351
2538
 
2352
2539
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
2353
2540
 
2354
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2541
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2355
2542
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2356
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2543
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2357
2544
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2358
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2545
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2359
2546
  Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2360
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2547
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2361
2548
  Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2362
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2549
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2363
2550
  Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
2551
+
2364
2552
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5));
2365
2553
  } else {
2366
2554
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
2367
2555
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5);
2368
2556
 
2369
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2557
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2370
2558
  Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2371
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2559
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2372
2560
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2373
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2561
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2374
2562
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2375
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2563
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2376
2564
  Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2377
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2565
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2378
2566
  Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2379
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2567
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2380
2568
  Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
2569
+
2381
2570
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5));
2382
2571
  }
2383
2572
  }
@@ -2416,6 +2605,13 @@ Auto_Function_Wrapper(
2416
2605
  }
2417
2606
  }
2418
2607
 
2608
+ template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T>
2609
+ Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T>::
2610
+ ~Auto_Function_Wrapper()
2611
+ {
2612
+ if(arguments_) { delete arguments_; }
2613
+ }
2614
+
2419
2615
  template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T>
2420
2616
  VALUE Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T>::
2421
2617
  call(int argc, VALUE* argv, VALUE self)
@@ -2442,34 +2638,36 @@ call(int argc, VALUE* argv, VALUE self)
2442
2638
 
2443
2639
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
2444
2640
 
2445
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2641
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2446
2642
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2447
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2643
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2448
2644
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2449
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2645
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2450
2646
  Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2451
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2647
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2452
2648
  Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2453
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2649
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2454
2650
  Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
2651
+
2455
2652
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5);
2456
2653
  return Qnil;
2457
2654
  } else {
2458
2655
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
2459
2656
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5);
2460
2657
 
2461
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2658
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2462
2659
  Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2463
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2660
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2464
2661
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2465
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2662
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2466
2663
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2467
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2664
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2468
2665
  Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2469
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2666
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2470
2667
  Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2471
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2668
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2472
2669
  Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
2670
+
2473
2671
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5);
2474
2672
  return Qnil;
2475
2673
  }
@@ -2510,6 +2708,13 @@ Auto_Function_Wrapper(
2510
2708
  }
2511
2709
  }
2512
2710
 
2711
+ template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T>
2712
+ Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T>::
2713
+ ~Auto_Function_Wrapper()
2714
+ {
2715
+ if(arguments_) { delete arguments_; }
2716
+ }
2717
+
2513
2718
  template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T>
2514
2719
  VALUE Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T>::
2515
2720
  call(int argc, VALUE *argv, VALUE self)
@@ -2536,29 +2741,31 @@ call(int argc, VALUE *argv, VALUE self)
2536
2741
 
2537
2742
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
2538
2743
 
2539
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2744
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2540
2745
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2541
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2746
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2542
2747
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2543
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2748
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2544
2749
  Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2545
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2750
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2546
2751
  Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2752
+
2547
2753
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4));
2548
2754
  } else {
2549
2755
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
2550
2756
  , &varg0, &varg1, &varg2, &varg3, &varg4);
2551
2757
 
2552
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2758
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2553
2759
  Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2554
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2760
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2555
2761
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2556
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2762
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2557
2763
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2558
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2764
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2559
2765
  Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2560
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2766
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2561
2767
  Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2768
+
2562
2769
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4));
2563
2770
  }
2564
2771
  }
@@ -2597,6 +2804,13 @@ Auto_Function_Wrapper(
2597
2804
  }
2598
2805
  }
2599
2806
 
2807
+ template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T>
2808
+ Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T>::
2809
+ ~Auto_Function_Wrapper()
2810
+ {
2811
+ if(arguments_) { delete arguments_; }
2812
+ }
2813
+
2600
2814
  template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T>
2601
2815
  VALUE Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T>::
2602
2816
  call(int argc, VALUE* argv, VALUE self)
@@ -2623,30 +2837,32 @@ call(int argc, VALUE* argv, VALUE self)
2623
2837
 
2624
2838
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
2625
2839
 
2626
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2840
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2627
2841
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2628
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2842
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2629
2843
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2630
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2844
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2631
2845
  Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2632
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2846
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2633
2847
  Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2848
+
2634
2849
  wrapper->func_(arg0, arg1, arg2, arg3, arg4);
2635
2850
  return Qnil;
2636
2851
  } else {
2637
2852
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
2638
2853
  , &varg0, &varg1, &varg2, &varg3, &varg4);
2639
2854
 
2640
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2855
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2641
2856
  Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2642
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2857
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2643
2858
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2644
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2859
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2645
2860
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2646
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2861
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2647
2862
  Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2648
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2863
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2649
2864
  Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2865
+
2650
2866
  wrapper->func_(arg0, arg1, arg2, arg3, arg4);
2651
2867
  return Qnil;
2652
2868
  }
@@ -2687,6 +2903,13 @@ Auto_Function_Wrapper(
2687
2903
  }
2688
2904
  }
2689
2905
 
2906
+ template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T>
2907
+ Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T>::
2908
+ ~Auto_Function_Wrapper()
2909
+ {
2910
+ if(arguments_) { delete arguments_; }
2911
+ }
2912
+
2690
2913
  template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T>
2691
2914
  VALUE Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T>::
2692
2915
  call(int argc, VALUE *argv, VALUE self)
@@ -2713,25 +2936,27 @@ call(int argc, VALUE *argv, VALUE self)
2713
2936
 
2714
2937
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
2715
2938
 
2716
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2939
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2717
2940
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2718
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2941
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2719
2942
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2720
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2943
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2721
2944
  Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2945
+
2722
2946
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3));
2723
2947
  } else {
2724
2948
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
2725
2949
  , &varg0, &varg1, &varg2, &varg3);
2726
2950
 
2727
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2951
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2728
2952
  Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2729
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2953
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2730
2954
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2731
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2955
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2732
2956
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2733
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2957
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2734
2958
  Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2959
+
2735
2960
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3));
2736
2961
  }
2737
2962
  }
@@ -2770,6 +2995,13 @@ Auto_Function_Wrapper(
2770
2995
  }
2771
2996
  }
2772
2997
 
2998
+ template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T>
2999
+ Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T>::
3000
+ ~Auto_Function_Wrapper()
3001
+ {
3002
+ if(arguments_) { delete arguments_; }
3003
+ }
3004
+
2773
3005
  template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T>
2774
3006
  VALUE Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T>::
2775
3007
  call(int argc, VALUE* argv, VALUE self)
@@ -2796,26 +3028,28 @@ call(int argc, VALUE* argv, VALUE self)
2796
3028
 
2797
3029
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
2798
3030
 
2799
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3031
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2800
3032
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2801
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
3033
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2802
3034
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2803
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
3035
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2804
3036
  Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
3037
+
2805
3038
  wrapper->func_(arg0, arg1, arg2, arg3);
2806
3039
  return Qnil;
2807
3040
  } else {
2808
3041
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
2809
3042
  , &varg0, &varg1, &varg2, &varg3);
2810
3043
 
2811
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
3044
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2812
3045
  Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2813
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3046
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2814
3047
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2815
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
3048
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2816
3049
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2817
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
3050
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2818
3051
  Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
3052
+
2819
3053
  wrapper->func_(arg0, arg1, arg2, arg3);
2820
3054
  return Qnil;
2821
3055
  }
@@ -2856,6 +3090,13 @@ Auto_Function_Wrapper(
2856
3090
  }
2857
3091
  }
2858
3092
 
3093
+ template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T>
3094
+ Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T>::
3095
+ ~Auto_Function_Wrapper()
3096
+ {
3097
+ if(arguments_) { delete arguments_; }
3098
+ }
3099
+
2859
3100
  template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T>
2860
3101
  VALUE Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T>::
2861
3102
  call(int argc, VALUE *argv, VALUE self)
@@ -2882,21 +3123,23 @@ call(int argc, VALUE *argv, VALUE self)
2882
3123
 
2883
3124
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
2884
3125
 
2885
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3126
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2886
3127
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2887
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
3128
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2888
3129
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
3130
+
2889
3131
  return to_ruby(wrapper->func_(arg0, arg1, arg2));
2890
3132
  } else {
2891
3133
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
2892
3134
  , &varg0, &varg1, &varg2);
2893
3135
 
2894
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
3136
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2895
3137
  Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2896
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3138
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2897
3139
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2898
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
3140
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2899
3141
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
3142
+
2900
3143
  return to_ruby(wrapper->func_(arg0, arg1, arg2));
2901
3144
  }
2902
3145
  }
@@ -2935,6 +3178,13 @@ Auto_Function_Wrapper(
2935
3178
  }
2936
3179
  }
2937
3180
 
3181
+ template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T>
3182
+ Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T>::
3183
+ ~Auto_Function_Wrapper()
3184
+ {
3185
+ if(arguments_) { delete arguments_; }
3186
+ }
3187
+
2938
3188
  template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T>
2939
3189
  VALUE Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T>::
2940
3190
  call(int argc, VALUE* argv, VALUE self)
@@ -2961,22 +3211,24 @@ call(int argc, VALUE* argv, VALUE self)
2961
3211
 
2962
3212
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
2963
3213
 
2964
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3214
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2965
3215
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2966
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
3216
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2967
3217
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
3218
+
2968
3219
  wrapper->func_(arg0, arg1, arg2);
2969
3220
  return Qnil;
2970
3221
  } else {
2971
3222
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
2972
3223
  , &varg0, &varg1, &varg2);
2973
3224
 
2974
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
3225
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2975
3226
  Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2976
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3227
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2977
3228
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2978
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
3229
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2979
3230
  Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
3231
+
2980
3232
  wrapper->func_(arg0, arg1, arg2);
2981
3233
  return Qnil;
2982
3234
  }
@@ -3017,6 +3269,13 @@ Auto_Function_Wrapper(
3017
3269
  }
3018
3270
  }
3019
3271
 
3272
+ template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T>
3273
+ Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T>::
3274
+ ~Auto_Function_Wrapper()
3275
+ {
3276
+ if(arguments_) { delete arguments_; }
3277
+ }
3278
+
3020
3279
  template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T>
3021
3280
  VALUE Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T>::
3022
3281
  call(int argc, VALUE *argv, VALUE self)
@@ -3043,17 +3302,19 @@ call(int argc, VALUE *argv, VALUE self)
3043
3302
 
3044
3303
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
3045
3304
 
3046
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3305
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3047
3306
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
3307
+
3048
3308
  return to_ruby(wrapper->func_(arg0, arg1));
3049
3309
  } else {
3050
3310
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
3051
3311
  , &varg0, &varg1);
3052
3312
 
3053
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
3313
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
3054
3314
  Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
3055
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3315
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3056
3316
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
3317
+
3057
3318
  return to_ruby(wrapper->func_(arg0, arg1));
3058
3319
  }
3059
3320
  }
@@ -3092,6 +3353,13 @@ Auto_Function_Wrapper(
3092
3353
  }
3093
3354
  }
3094
3355
 
3356
+ template<typename Func_T, typename Arg0_T, typename Arg1_T>
3357
+ Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T>::
3358
+ ~Auto_Function_Wrapper()
3359
+ {
3360
+ if(arguments_) { delete arguments_; }
3361
+ }
3362
+
3095
3363
  template<typename Func_T, typename Arg0_T, typename Arg1_T>
3096
3364
  VALUE Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T>::
3097
3365
  call(int argc, VALUE* argv, VALUE self)
@@ -3118,18 +3386,20 @@ call(int argc, VALUE* argv, VALUE self)
3118
3386
 
3119
3387
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
3120
3388
 
3121
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3389
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3122
3390
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
3391
+
3123
3392
  wrapper->func_(arg0, arg1);
3124
3393
  return Qnil;
3125
3394
  } else {
3126
3395
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
3127
3396
  , &varg0, &varg1);
3128
3397
 
3129
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
3398
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
3130
3399
  Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
3131
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3400
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3132
3401
  Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
3402
+
3133
3403
  wrapper->func_(arg0, arg1);
3134
3404
  return Qnil;
3135
3405
  }
@@ -3170,6 +3440,13 @@ Auto_Function_Wrapper(
3170
3440
  }
3171
3441
  }
3172
3442
 
3443
+ template<typename Func_T, typename Ret_T, typename Arg0_T>
3444
+ Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T>::
3445
+ ~Auto_Function_Wrapper()
3446
+ {
3447
+ if(arguments_) { delete arguments_; }
3448
+ }
3449
+
3173
3450
  template<typename Func_T, typename Ret_T, typename Arg0_T>
3174
3451
  VALUE Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T>::
3175
3452
  call(int argc, VALUE *argv, VALUE self)
@@ -3196,13 +3473,15 @@ call(int argc, VALUE *argv, VALUE self)
3196
3473
 
3197
3474
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
3198
3475
 
3476
+
3199
3477
  return to_ruby(wrapper->func_(arg0));
3200
3478
  } else {
3201
3479
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
3202
3480
  , &varg0);
3203
3481
 
3204
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
3482
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
3205
3483
  Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
3484
+
3206
3485
  return to_ruby(wrapper->func_(arg0));
3207
3486
  }
3208
3487
  }
@@ -3241,6 +3520,13 @@ Auto_Function_Wrapper(
3241
3520
  }
3242
3521
  }
3243
3522
 
3523
+ template<typename Func_T, typename Arg0_T>
3524
+ Auto_Function_Wrapper<Func_T, void, Arg0_T>::
3525
+ ~Auto_Function_Wrapper()
3526
+ {
3527
+ if(arguments_) { delete arguments_; }
3528
+ }
3529
+
3244
3530
  template<typename Func_T, typename Arg0_T>
3245
3531
  VALUE Auto_Function_Wrapper<Func_T, void, Arg0_T>::
3246
3532
  call(int argc, VALUE* argv, VALUE self)
@@ -3267,14 +3553,16 @@ call(int argc, VALUE* argv, VALUE self)
3267
3553
 
3268
3554
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
3269
3555
 
3556
+
3270
3557
  wrapper->func_(arg0);
3271
3558
  return Qnil;
3272
3559
  } else {
3273
3560
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
3274
3561
  , &varg0);
3275
3562
 
3276
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
3563
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
3277
3564
  Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
3565
+
3278
3566
  wrapper->func_(arg0);
3279
3567
  return Qnil;
3280
3568
  }
@@ -3297,6 +3585,7 @@ call(int argc, VALUE* argv, VALUE self)
3297
3585
  }
3298
3586
 
3299
3587
  // ---------------------------------------------------------------------
3588
+
3300
3589
  template<typename Func_T, typename Ret_T>
3301
3590
  Auto_Function_Wrapper<Func_T, Ret_T>::
3302
3591
  Auto_Function_Wrapper(
@@ -3310,6 +3599,13 @@ Auto_Function_Wrapper(
3310
3599
  {
3311
3600
  }
3312
3601
 
3602
+ template<typename Func_T, typename Ret_T>
3603
+ Auto_Function_Wrapper<Func_T, Ret_T>::
3604
+ ~Auto_Function_Wrapper()
3605
+ {
3606
+ if(arguments_) { delete arguments_; }
3607
+ }
3608
+
3313
3609
  template<typename Func_T, typename Ret_T>
3314
3610
  VALUE Auto_Function_Wrapper<Func_T, Ret_T>::
3315
3611
  call()
@@ -3352,6 +3648,13 @@ Auto_Function_Wrapper(
3352
3648
  {
3353
3649
  }
3354
3650
 
3651
+ template<typename Func_T>
3652
+ Auto_Function_Wrapper<Func_T, void>::
3653
+ ~Auto_Function_Wrapper()
3654
+ {
3655
+ if(arguments_) { delete arguments_; }
3656
+ }
3657
+
3355
3658
  template<typename Func_T>
3356
3659
  VALUE Auto_Function_Wrapper<Func_T, void>::
3357
3660
  call()