rice 1.4.3 → 1.5.0

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