rice2 2.2.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 (190) hide show
  1. checksums.yaml +7 -0
  2. data/COPYING +23 -0
  3. data/Doxyfile +2268 -0
  4. data/Makefile.am +26 -0
  5. data/Makefile.in +929 -0
  6. data/README.md +1054 -0
  7. data/README.mingw +8 -0
  8. data/Rakefile +24 -0
  9. data/aclocal.m4 +1090 -0
  10. data/bootstrap +8 -0
  11. data/config.guess +1667 -0
  12. data/config.sub +1793 -0
  13. data/configure +8209 -0
  14. data/configure.ac +55 -0
  15. data/depcomp +791 -0
  16. data/doxygen.ac +314 -0
  17. data/doxygen.am +186 -0
  18. data/extconf.rb +66 -0
  19. data/install-sh +529 -0
  20. data/missing +215 -0
  21. data/post-autoconf.rb +22 -0
  22. data/post-automake.rb +28 -0
  23. data/rice/Address_Registration_Guard.cpp +22 -0
  24. data/rice/Address_Registration_Guard.hpp +7 -0
  25. data/rice/Address_Registration_Guard.ipp +37 -0
  26. data/rice/Address_Registration_Guard_defn.hpp +75 -0
  27. data/rice/Arg.hpp +8 -0
  28. data/rice/Arg_impl.hpp +129 -0
  29. data/rice/Arg_operators.cpp +21 -0
  30. data/rice/Arg_operators.hpp +19 -0
  31. data/rice/Array.hpp +214 -0
  32. data/rice/Array.ipp +256 -0
  33. data/rice/Builtin_Object.hpp +8 -0
  34. data/rice/Builtin_Object.ipp +50 -0
  35. data/rice/Builtin_Object_defn.hpp +50 -0
  36. data/rice/Class.cpp +57 -0
  37. data/rice/Class.hpp +8 -0
  38. data/rice/Class.ipp +6 -0
  39. data/rice/Class_defn.hpp +83 -0
  40. data/rice/Constructor.hpp +47 -0
  41. data/rice/Data_Object.hpp +8 -0
  42. data/rice/Data_Object.ipp +133 -0
  43. data/rice/Data_Object_defn.hpp +138 -0
  44. data/rice/Data_Type.cpp +54 -0
  45. data/rice/Data_Type.hpp +8 -0
  46. data/rice/Data_Type.ipp +365 -0
  47. data/rice/Data_Type_defn.hpp +261 -0
  48. data/rice/Data_Type_fwd.hpp +12 -0
  49. data/rice/Director.cpp +13 -0
  50. data/rice/Director.hpp +39 -0
  51. data/rice/Enum.hpp +117 -0
  52. data/rice/Enum.ipp +246 -0
  53. data/rice/Exception.cpp +59 -0
  54. data/rice/Exception.hpp +13 -0
  55. data/rice/Exception_Base.hpp +8 -0
  56. data/rice/Exception_Base.ipp +13 -0
  57. data/rice/Exception_Base_defn.hpp +27 -0
  58. data/rice/Exception_defn.hpp +69 -0
  59. data/rice/Hash.hpp +227 -0
  60. data/rice/Hash.ipp +329 -0
  61. data/rice/Identifier.cpp +8 -0
  62. data/rice/Identifier.hpp +50 -0
  63. data/rice/Identifier.ipp +33 -0
  64. data/rice/Jump_Tag.hpp +24 -0
  65. data/rice/Makefile.am +122 -0
  66. data/rice/Makefile.in +885 -0
  67. data/rice/Module.cpp +84 -0
  68. data/rice/Module.hpp +8 -0
  69. data/rice/Module.ipp +6 -0
  70. data/rice/Module_defn.hpp +88 -0
  71. data/rice/Module_impl.hpp +281 -0
  72. data/rice/Module_impl.ipp +345 -0
  73. data/rice/Object.cpp +169 -0
  74. data/rice/Object.hpp +8 -0
  75. data/rice/Object.ipp +33 -0
  76. data/rice/Object_defn.hpp +214 -0
  77. data/rice/Require_Guard.hpp +21 -0
  78. data/rice/String.cpp +94 -0
  79. data/rice/String.hpp +91 -0
  80. data/rice/Struct.cpp +117 -0
  81. data/rice/Struct.hpp +162 -0
  82. data/rice/Struct.ipp +26 -0
  83. data/rice/Symbol.cpp +25 -0
  84. data/rice/Symbol.hpp +66 -0
  85. data/rice/Symbol.ipp +44 -0
  86. data/rice/config.hpp +47 -0
  87. data/rice/config.hpp.in +46 -0
  88. data/rice/detail/Arguments.hpp +118 -0
  89. data/rice/detail/Auto_Function_Wrapper.hpp +898 -0
  90. data/rice/detail/Auto_Function_Wrapper.ipp +3694 -0
  91. data/rice/detail/Auto_Member_Function_Wrapper.hpp +897 -0
  92. data/rice/detail/Auto_Member_Function_Wrapper.ipp +2774 -0
  93. data/rice/detail/Caster.hpp +103 -0
  94. data/rice/detail/Exception_Handler.hpp +8 -0
  95. data/rice/detail/Exception_Handler.ipp +68 -0
  96. data/rice/detail/Exception_Handler_defn.hpp +96 -0
  97. data/rice/detail/Iterator.hpp +93 -0
  98. data/rice/detail/Not_Copyable.hpp +25 -0
  99. data/rice/detail/Wrapped_Function.hpp +33 -0
  100. data/rice/detail/cfp.hpp +24 -0
  101. data/rice/detail/cfp.ipp +51 -0
  102. data/rice/detail/check_ruby_type.cpp +27 -0
  103. data/rice/detail/check_ruby_type.hpp +23 -0
  104. data/rice/detail/creation_funcs.hpp +37 -0
  105. data/rice/detail/creation_funcs.ipp +36 -0
  106. data/rice/detail/default_allocation_func.hpp +23 -0
  107. data/rice/detail/default_allocation_func.ipp +11 -0
  108. data/rice/detail/define_method_and_auto_wrap.hpp +31 -0
  109. data/rice/detail/define_method_and_auto_wrap.ipp +30 -0
  110. data/rice/detail/demangle.cpp +56 -0
  111. data/rice/detail/demangle.hpp +19 -0
  112. data/rice/detail/env.hpp +11 -0
  113. data/rice/detail/from_ruby.hpp +43 -0
  114. data/rice/detail/from_ruby.ipp +60 -0
  115. data/rice/detail/method_data.cpp +92 -0
  116. data/rice/detail/method_data.hpp +21 -0
  117. data/rice/detail/node.hpp +13 -0
  118. data/rice/detail/protect.cpp +29 -0
  119. data/rice/detail/protect.hpp +34 -0
  120. data/rice/detail/ruby.hpp +74 -0
  121. data/rice/detail/ruby_version_code.hpp +6 -0
  122. data/rice/detail/ruby_version_code.hpp.in +6 -0
  123. data/rice/detail/st.hpp +22 -0
  124. data/rice/detail/to_ruby.hpp +22 -0
  125. data/rice/detail/to_ruby.ipp +36 -0
  126. data/rice/detail/traits.hpp +43 -0
  127. data/rice/detail/win32.hpp +16 -0
  128. data/rice/detail/wrap_function.hpp +66 -0
  129. data/rice/global_function.hpp +33 -0
  130. data/rice/global_function.ipp +22 -0
  131. data/rice/protect.hpp +38 -0
  132. data/rice/protect.ipp +1134 -0
  133. data/rice/ruby_mark.hpp +13 -0
  134. data/rice/ruby_try_catch.hpp +86 -0
  135. data/rice/rubypp.rb +97 -0
  136. data/rice/to_from_ruby.hpp +8 -0
  137. data/rice/to_from_ruby.ipp +418 -0
  138. data/rice/to_from_ruby_defn.hpp +70 -0
  139. data/ruby.ac +135 -0
  140. data/ruby/Makefile.am +1 -0
  141. data/ruby/Makefile.in +628 -0
  142. data/ruby/lib/Makefile.am +3 -0
  143. data/ruby/lib/Makefile.in +506 -0
  144. data/ruby/lib/mkmf-rice.rb.in +217 -0
  145. data/ruby/lib/version.rb +3 -0
  146. data/sample/Makefile.am +47 -0
  147. data/sample/Makefile.in +489 -0
  148. data/sample/enum/extconf.rb +3 -0
  149. data/sample/enum/sample_enum.cpp +54 -0
  150. data/sample/enum/test.rb +8 -0
  151. data/sample/inheritance/animals.cpp +98 -0
  152. data/sample/inheritance/extconf.rb +3 -0
  153. data/sample/inheritance/test.rb +7 -0
  154. data/sample/map/extconf.rb +3 -0
  155. data/sample/map/map.cpp +81 -0
  156. data/sample/map/test.rb +7 -0
  157. data/test/Makefile.am +72 -0
  158. data/test/Makefile.in +1213 -0
  159. data/test/ext/Makefile.am +41 -0
  160. data/test/ext/Makefile.in +483 -0
  161. data/test/ext/t1/Foo.hpp +10 -0
  162. data/test/ext/t1/extconf.rb +2 -0
  163. data/test/ext/t1/t1.cpp +15 -0
  164. data/test/ext/t2/extconf.rb +2 -0
  165. data/test/ext/t2/t2.cpp +11 -0
  166. data/test/test_Address_Registration_Guard.cpp +43 -0
  167. data/test/test_Array.cpp +248 -0
  168. data/test/test_Builtin_Object.cpp +71 -0
  169. data/test/test_Class.cpp +496 -0
  170. data/test/test_Constructor.cpp +128 -0
  171. data/test/test_Data_Object.cpp +275 -0
  172. data/test/test_Data_Type.cpp +348 -0
  173. data/test/test_Director.cpp +308 -0
  174. data/test/test_Enum.cpp +215 -0
  175. data/test/test_Exception.cpp +47 -0
  176. data/test/test_Hash.cpp +212 -0
  177. data/test/test_Identifier.cpp +70 -0
  178. data/test/test_Jump_Tag.cpp +17 -0
  179. data/test/test_Memory_Management.cpp +50 -0
  180. data/test/test_Module.cpp +497 -0
  181. data/test/test_Object.cpp +159 -0
  182. data/test/test_String.cpp +107 -0
  183. data/test/test_Struct.cpp +205 -0
  184. data/test/test_Symbol.cpp +63 -0
  185. data/test/test_To_From_Ruby.cpp +428 -0
  186. data/test/test_global_functions.cpp +114 -0
  187. data/test/test_rice.rb +41 -0
  188. data/test/unittest.cpp +136 -0
  189. data/test/unittest.hpp +294 -0
  190. metadata +297 -0
data/rice/detail/Auto_Function_Wrapper.ipp ADDED
@@ -0,0 +1,3694 @@
1
+ #ifndef Rice__detail__Auto_Function_Wrapper__ipp_
2
+ #define Rice__detail__Auto_Function_Wrapper__ipp_
3
+
4
+ // This is a generated file. DO NOT EDIT!!
5
+
6
+
7
+ // This causes problems with certain C++ libraries
8
+ #undef TYPE
9
+
10
+ #include "method_data.hpp"
11
+ #include "../ruby_try_catch.hpp"
12
+ #include "../to_from_ruby.hpp"
13
+ #include "traits.hpp"
14
+ namespace Rice
15
+ {
16
+
17
+ namespace detail
18
+ {
19
+
20
+ 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>
21
+ 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>::
22
+ Auto_Function_Wrapper(
23
+ Func func,
24
+ Data_Object<Exception_Handler> handler,
25
+ Arguments* arguments)
26
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
27
+ , func_(func)
28
+ , handler_(handler)
29
+ , handler_guard_(&handler_)
30
+ {
31
+ if(arguments == 0) {
32
+ arguments_ = new Arguments();
33
+ } else {
34
+ arguments_ = arguments;
35
+ }
36
+ }
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
+
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>
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>::
47
+ call(int argc, VALUE *argv, VALUE self)
48
+ {
49
+ 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> * wrapper = 0;
50
+ try
51
+ {
52
+ Data_Object<Wrapped_Function> data(detail::method_data());
53
+ wrapper = (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> *)data.get();
54
+ Arguments* args = wrapper->arguments_;
55
+
56
+ bool hasSelf = (self && self != Qnil);
57
+ if(args->count() >= 0) {
58
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
59
+ } else {
60
+ hasSelf = hasSelf && argc == Num_Args -1;
61
+ }
62
+
63
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12, varg13, varg14, varg15;
64
+
65
+ if(hasSelf) {
66
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1).c_str()
67
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14, &varg15);
68
+
69
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
70
+
71
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
72
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
73
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
74
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
75
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
76
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
77
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
78
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
79
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
80
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
81
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
82
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
83
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
84
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
85
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
86
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
87
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
88
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
89
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
90
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
91
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
92
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
93
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
94
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
95
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
96
+ Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(12, varg12);
97
+ typedef typename sanitize< Arg14_T >::Type Arg14_Type;
98
+ Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(13, varg13);
99
+ typedef typename sanitize< Arg15_T >::Type Arg15_Type;
100
+ Arg15_Type arg15 = args->getArgumentOrDefault<Arg15_Type>(14, varg14);
101
+
102
+ return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15));
103
+ } else {
104
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
105
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14, &varg15);
106
+
107
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
108
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
109
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
110
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
111
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
112
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
113
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
114
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
115
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
116
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
117
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
118
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
119
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
120
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
121
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
122
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
123
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
124
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
125
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
126
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
127
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
128
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
129
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
130
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
131
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
132
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
133
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
134
+ Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
135
+ typedef typename sanitize< Arg14_T >::Type Arg14_Type;
136
+ Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(14, varg14);
137
+ typedef typename sanitize< Arg15_T >::Type Arg15_Type;
138
+ Arg15_Type arg15 = args->getArgumentOrDefault<Arg15_Type>(15, varg15);
139
+
140
+ return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15));
141
+ }
142
+ }
143
+ catch(...)
144
+ {
145
+ RUBY_TRY
146
+ {
147
+ if(wrapper)
148
+ {
149
+ return wrapper->handler_->handle_exception();
150
+ }
151
+ else
152
+ {
153
+ throw;
154
+ }
155
+ }
156
+ RUBY_CATCH
157
+ }
158
+ }
159
+
160
+ 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>
161
+ 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>::
162
+ Auto_Function_Wrapper(
163
+ Func func,
164
+ Data_Object<Exception_Handler> handler,
165
+ Arguments* arguments)
166
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
167
+ , func_(func)
168
+ , handler_(handler)
169
+ , handler_guard_(&handler_)
170
+ {
171
+ if(arguments == 0) {
172
+ arguments_ = new Arguments();
173
+ } else {
174
+ arguments_ = arguments;
175
+ }
176
+ }
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
+
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>
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>::
187
+ call(int argc, VALUE* argv, VALUE self)
188
+ {
189
+ 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> * wrapper = 0;
190
+ try
191
+ {
192
+ Data_Object<Wrapped_Function> data(detail::method_data());
193
+ wrapper = (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T, Arg14_T, Arg15_T> *)data.get();
194
+ Arguments* args = wrapper->arguments_;
195
+
196
+ bool hasSelf = (self && self != Qnil);
197
+ if(args->count() >= 0) {
198
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
199
+ } else {
200
+ hasSelf = hasSelf && argc == Num_Args -1;
201
+ }
202
+
203
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12, varg13, varg14, varg15;
204
+
205
+ if(hasSelf) {
206
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1) .c_str()
207
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14, &varg15);
208
+
209
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
210
+
211
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
212
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
213
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
214
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
215
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
216
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
217
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
218
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
219
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
220
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
221
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
222
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
223
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
224
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
225
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
226
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
227
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
228
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
229
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
230
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
231
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
232
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
233
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
234
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
235
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
236
+ Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(12, varg12);
237
+ typedef typename sanitize< Arg14_T >::Type Arg14_Type;
238
+ Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(13, varg13);
239
+ typedef typename sanitize< Arg15_T >::Type Arg15_Type;
240
+ Arg15_Type arg15 = args->getArgumentOrDefault<Arg15_Type>(14, varg14);
241
+
242
+ wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15);
243
+ return Qnil;
244
+ } else {
245
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
246
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14, &varg15);
247
+
248
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
249
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
250
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
251
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
252
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
253
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
254
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
255
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
256
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
257
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
258
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
259
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
260
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
261
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
262
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
263
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
264
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
265
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
266
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
267
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
268
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
269
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
270
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
271
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
272
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
273
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
274
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
275
+ Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
276
+ typedef typename sanitize< Arg14_T >::Type Arg14_Type;
277
+ Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(14, varg14);
278
+ typedef typename sanitize< Arg15_T >::Type Arg15_Type;
279
+ Arg15_Type arg15 = args->getArgumentOrDefault<Arg15_Type>(15, varg15);
280
+
281
+ wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15);
282
+ return Qnil;
283
+ }
284
+ }
285
+ catch(...)
286
+ {
287
+ RUBY_TRY
288
+ {
289
+ if(wrapper)
290
+ {
291
+ return wrapper->handler_->handle_exception();
292
+ }
293
+ else
294
+ {
295
+ throw;
296
+ }
297
+ }
298
+ RUBY_CATCH
299
+ }
300
+ }
301
+
302
+ // ---------------------------------------------------------------------
303
+ 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
+ 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
+ Auto_Function_Wrapper(
306
+ Func func,
307
+ Data_Object<Exception_Handler> handler,
308
+ Arguments* arguments)
309
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
310
+ , func_(func)
311
+ , handler_(handler)
312
+ , handler_guard_(&handler_)
313
+ {
314
+ if(arguments == 0) {
315
+ arguments_ = new Arguments();
316
+ } else {
317
+ arguments_ = arguments;
318
+ }
319
+ }
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
+
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>
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>::
330
+ call(int argc, VALUE *argv, VALUE self)
331
+ {
332
+ 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> * wrapper = 0;
333
+ try
334
+ {
335
+ Data_Object<Wrapped_Function> data(detail::method_data());
336
+ wrapper = (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> *)data.get();
337
+ Arguments* args = wrapper->arguments_;
338
+
339
+ bool hasSelf = (self && self != Qnil);
340
+ if(args->count() >= 0) {
341
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
342
+ } else {
343
+ hasSelf = hasSelf && argc == Num_Args -1;
344
+ }
345
+
346
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12, varg13, varg14;
347
+
348
+ if(hasSelf) {
349
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1).c_str()
350
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14);
351
+
352
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
353
+
354
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
355
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
356
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
357
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
358
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
359
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
360
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
361
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
362
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
363
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
364
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
365
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
366
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
367
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
368
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
369
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
370
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
371
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
372
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
373
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
374
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
375
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
376
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
377
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
378
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
379
+ Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(12, varg12);
380
+ typedef typename sanitize< Arg14_T >::Type Arg14_Type;
381
+ Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(13, varg13);
382
+
383
+ return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14));
384
+ } else {
385
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
386
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14);
387
+
388
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
389
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
390
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
391
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
392
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
393
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
394
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
395
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
396
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
397
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
398
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
399
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
400
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
401
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
402
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
403
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
404
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
405
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
406
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
407
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
408
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
409
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
410
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
411
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
412
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
413
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
414
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
415
+ Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
416
+ typedef typename sanitize< Arg14_T >::Type Arg14_Type;
417
+ Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(14, varg14);
418
+
419
+ return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14));
420
+ }
421
+ }
422
+ catch(...)
423
+ {
424
+ RUBY_TRY
425
+ {
426
+ if(wrapper)
427
+ {
428
+ return wrapper->handler_->handle_exception();
429
+ }
430
+ else
431
+ {
432
+ throw;
433
+ }
434
+ }
435
+ RUBY_CATCH
436
+ }
437
+ }
438
+
439
+ 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>
440
+ 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>::
441
+ Auto_Function_Wrapper(
442
+ Func func,
443
+ Data_Object<Exception_Handler> handler,
444
+ Arguments* arguments)
445
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
446
+ , func_(func)
447
+ , handler_(handler)
448
+ , handler_guard_(&handler_)
449
+ {
450
+ if(arguments == 0) {
451
+ arguments_ = new Arguments();
452
+ } else {
453
+ arguments_ = arguments;
454
+ }
455
+ }
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
+
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>
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>::
466
+ call(int argc, VALUE* argv, VALUE self)
467
+ {
468
+ 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> * wrapper = 0;
469
+ try
470
+ {
471
+ Data_Object<Wrapped_Function> data(detail::method_data());
472
+ wrapper = (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T, Arg14_T> *)data.get();
473
+ Arguments* args = wrapper->arguments_;
474
+
475
+ bool hasSelf = (self && self != Qnil);
476
+ if(args->count() >= 0) {
477
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
478
+ } else {
479
+ hasSelf = hasSelf && argc == Num_Args -1;
480
+ }
481
+
482
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12, varg13, varg14;
483
+
484
+ if(hasSelf) {
485
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1) .c_str()
486
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14);
487
+
488
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
489
+
490
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
491
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
492
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
493
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
494
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
495
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
496
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
497
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
498
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
499
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
500
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
501
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
502
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
503
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
504
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
505
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
506
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
507
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
508
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
509
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
510
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
511
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
512
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
513
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
514
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
515
+ Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(12, varg12);
516
+ typedef typename sanitize< Arg14_T >::Type Arg14_Type;
517
+ Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(13, varg13);
518
+
519
+ wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
520
+ return Qnil;
521
+ } else {
522
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
523
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14);
524
+
525
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
526
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
527
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
528
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
529
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
530
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
531
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
532
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
533
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
534
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
535
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
536
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
537
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
538
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
539
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
540
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
541
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
542
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
543
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
544
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
545
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
546
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
547
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
548
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
549
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
550
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
551
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
552
+ Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
553
+ typedef typename sanitize< Arg14_T >::Type Arg14_Type;
554
+ Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(14, varg14);
555
+
556
+ wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
557
+ return Qnil;
558
+ }
559
+ }
560
+ catch(...)
561
+ {
562
+ RUBY_TRY
563
+ {
564
+ if(wrapper)
565
+ {
566
+ return wrapper->handler_->handle_exception();
567
+ }
568
+ else
569
+ {
570
+ throw;
571
+ }
572
+ }
573
+ RUBY_CATCH
574
+ }
575
+ }
576
+
577
+ // ---------------------------------------------------------------------
578
+ 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>
579
+ 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>::
580
+ Auto_Function_Wrapper(
581
+ Func func,
582
+ Data_Object<Exception_Handler> handler,
583
+ Arguments* arguments)
584
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
585
+ , func_(func)
586
+ , handler_(handler)
587
+ , handler_guard_(&handler_)
588
+ {
589
+ if(arguments == 0) {
590
+ arguments_ = new Arguments();
591
+ } else {
592
+ arguments_ = arguments;
593
+ }
594
+ }
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
+
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>
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>::
605
+ call(int argc, VALUE *argv, VALUE self)
606
+ {
607
+ 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> * wrapper = 0;
608
+ try
609
+ {
610
+ Data_Object<Wrapped_Function> data(detail::method_data());
611
+ wrapper = (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> *)data.get();
612
+ Arguments* args = wrapper->arguments_;
613
+
614
+ bool hasSelf = (self && self != Qnil);
615
+ if(args->count() >= 0) {
616
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
617
+ } else {
618
+ hasSelf = hasSelf && argc == Num_Args -1;
619
+ }
620
+
621
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12, varg13;
622
+
623
+ if(hasSelf) {
624
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1).c_str()
625
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13);
626
+
627
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
628
+
629
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
630
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
631
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
632
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
633
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
634
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
635
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
636
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
637
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
638
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
639
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
640
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
641
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
642
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
643
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
644
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
645
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
646
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
647
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
648
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
649
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
650
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
651
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
652
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
653
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
654
+ Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(12, varg12);
655
+
656
+ return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13));
657
+ } else {
658
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
659
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13);
660
+
661
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
662
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
663
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
664
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
665
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
666
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
667
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
668
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
669
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
670
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
671
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
672
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
673
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
674
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
675
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
676
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
677
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
678
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
679
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
680
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
681
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
682
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
683
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
684
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
685
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
686
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
687
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
688
+ Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
689
+
690
+ return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13));
691
+ }
692
+ }
693
+ catch(...)
694
+ {
695
+ RUBY_TRY
696
+ {
697
+ if(wrapper)
698
+ {
699
+ return wrapper->handler_->handle_exception();
700
+ }
701
+ else
702
+ {
703
+ throw;
704
+ }
705
+ }
706
+ RUBY_CATCH
707
+ }
708
+ }
709
+
710
+ 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>
711
+ 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>::
712
+ Auto_Function_Wrapper(
713
+ Func func,
714
+ Data_Object<Exception_Handler> handler,
715
+ Arguments* arguments)
716
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
717
+ , func_(func)
718
+ , handler_(handler)
719
+ , handler_guard_(&handler_)
720
+ {
721
+ if(arguments == 0) {
722
+ arguments_ = new Arguments();
723
+ } else {
724
+ arguments_ = arguments;
725
+ }
726
+ }
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
+
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>
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>::
737
+ call(int argc, VALUE* argv, VALUE self)
738
+ {
739
+ 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> * wrapper = 0;
740
+ try
741
+ {
742
+ Data_Object<Wrapped_Function> data(detail::method_data());
743
+ wrapper = (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T> *)data.get();
744
+ Arguments* args = wrapper->arguments_;
745
+
746
+ bool hasSelf = (self && self != Qnil);
747
+ if(args->count() >= 0) {
748
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
749
+ } else {
750
+ hasSelf = hasSelf && argc == Num_Args -1;
751
+ }
752
+
753
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12, varg13;
754
+
755
+ if(hasSelf) {
756
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1) .c_str()
757
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13);
758
+
759
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
760
+
761
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
762
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
763
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
764
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
765
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
766
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
767
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
768
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
769
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
770
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
771
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
772
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
773
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
774
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
775
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
776
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
777
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
778
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
779
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
780
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
781
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
782
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
783
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
784
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
785
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
786
+ Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(12, varg12);
787
+
788
+ wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
789
+ return Qnil;
790
+ } else {
791
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
792
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13);
793
+
794
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
795
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
796
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
797
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
798
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
799
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
800
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
801
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
802
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
803
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
804
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
805
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
806
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
807
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
808
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
809
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
810
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
811
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
812
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
813
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
814
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
815
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
816
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
817
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
818
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
819
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
820
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
821
+ Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
822
+
823
+ wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
824
+ return Qnil;
825
+ }
826
+ }
827
+ catch(...)
828
+ {
829
+ RUBY_TRY
830
+ {
831
+ if(wrapper)
832
+ {
833
+ return wrapper->handler_->handle_exception();
834
+ }
835
+ else
836
+ {
837
+ throw;
838
+ }
839
+ }
840
+ RUBY_CATCH
841
+ }
842
+ }
843
+
844
+ // ---------------------------------------------------------------------
845
+ 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>
846
+ 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>::
847
+ Auto_Function_Wrapper(
848
+ Func func,
849
+ Data_Object<Exception_Handler> handler,
850
+ Arguments* arguments)
851
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
852
+ , func_(func)
853
+ , handler_(handler)
854
+ , handler_guard_(&handler_)
855
+ {
856
+ if(arguments == 0) {
857
+ arguments_ = new Arguments();
858
+ } else {
859
+ arguments_ = arguments;
860
+ }
861
+ }
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
+
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>
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>::
872
+ call(int argc, VALUE *argv, VALUE self)
873
+ {
874
+ 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> * wrapper = 0;
875
+ try
876
+ {
877
+ Data_Object<Wrapped_Function> data(detail::method_data());
878
+ wrapper = (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> *)data.get();
879
+ Arguments* args = wrapper->arguments_;
880
+
881
+ bool hasSelf = (self && self != Qnil);
882
+ if(args->count() >= 0) {
883
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
884
+ } else {
885
+ hasSelf = hasSelf && argc == Num_Args -1;
886
+ }
887
+
888
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12;
889
+
890
+ if(hasSelf) {
891
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1).c_str()
892
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12);
893
+
894
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
895
+
896
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
897
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
898
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
899
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
900
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
901
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
902
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
903
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
904
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
905
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
906
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
907
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
908
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
909
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
910
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
911
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
912
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
913
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
914
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
915
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
916
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
917
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
918
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
919
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
920
+
921
+ return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12));
922
+ } else {
923
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
924
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12);
925
+
926
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
927
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
928
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
929
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
930
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
931
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
932
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
933
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
934
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
935
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
936
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
937
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
938
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
939
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
940
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
941
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
942
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
943
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
944
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
945
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
946
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
947
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
948
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
949
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
950
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
951
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
952
+
953
+ return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12));
954
+ }
955
+ }
956
+ catch(...)
957
+ {
958
+ RUBY_TRY
959
+ {
960
+ if(wrapper)
961
+ {
962
+ return wrapper->handler_->handle_exception();
963
+ }
964
+ else
965
+ {
966
+ throw;
967
+ }
968
+ }
969
+ RUBY_CATCH
970
+ }
971
+ }
972
+
973
+ 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>
974
+ 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>::
975
+ Auto_Function_Wrapper(
976
+ Func func,
977
+ Data_Object<Exception_Handler> handler,
978
+ Arguments* arguments)
979
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
980
+ , func_(func)
981
+ , handler_(handler)
982
+ , handler_guard_(&handler_)
983
+ {
984
+ if(arguments == 0) {
985
+ arguments_ = new Arguments();
986
+ } else {
987
+ arguments_ = arguments;
988
+ }
989
+ }
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
+
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>
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>::
1000
+ call(int argc, VALUE* argv, VALUE self)
1001
+ {
1002
+ 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> * wrapper = 0;
1003
+ try
1004
+ {
1005
+ Data_Object<Wrapped_Function> data(detail::method_data());
1006
+ wrapper = (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T> *)data.get();
1007
+ Arguments* args = wrapper->arguments_;
1008
+
1009
+ bool hasSelf = (self && self != Qnil);
1010
+ if(args->count() >= 0) {
1011
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
1012
+ } else {
1013
+ hasSelf = hasSelf && argc == Num_Args -1;
1014
+ }
1015
+
1016
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12;
1017
+
1018
+ if(hasSelf) {
1019
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1) .c_str()
1020
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12);
1021
+
1022
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
1023
+
1024
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1025
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1026
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1027
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1028
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1029
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1030
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1031
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1032
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1033
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1034
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1035
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1036
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1037
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1038
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1039
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1040
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1041
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
1042
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1043
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
1044
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
1045
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
1046
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
1047
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
1048
+
1049
+ wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
1050
+ return Qnil;
1051
+ } else {
1052
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
1053
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12);
1054
+
1055
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1056
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1057
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1058
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1059
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1060
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1061
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1062
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1063
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1064
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1065
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1066
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1067
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1068
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1069
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1070
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1071
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1072
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1073
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1074
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1075
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1076
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
1077
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
1078
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
1079
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
1080
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
1081
+
1082
+ wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
1083
+ return Qnil;
1084
+ }
1085
+ }
1086
+ catch(...)
1087
+ {
1088
+ RUBY_TRY
1089
+ {
1090
+ if(wrapper)
1091
+ {
1092
+ return wrapper->handler_->handle_exception();
1093
+ }
1094
+ else
1095
+ {
1096
+ throw;
1097
+ }
1098
+ }
1099
+ RUBY_CATCH
1100
+ }
1101
+ }
1102
+
1103
+ // ---------------------------------------------------------------------
1104
+ 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>
1105
+ 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>::
1106
+ Auto_Function_Wrapper(
1107
+ Func func,
1108
+ Data_Object<Exception_Handler> handler,
1109
+ Arguments* arguments)
1110
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
1111
+ , func_(func)
1112
+ , handler_(handler)
1113
+ , handler_guard_(&handler_)
1114
+ {
1115
+ if(arguments == 0) {
1116
+ arguments_ = new Arguments();
1117
+ } else {
1118
+ arguments_ = arguments;
1119
+ }
1120
+ }
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
+
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>
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>::
1131
+ call(int argc, VALUE *argv, VALUE self)
1132
+ {
1133
+ 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> * wrapper = 0;
1134
+ try
1135
+ {
1136
+ Data_Object<Wrapped_Function> data(detail::method_data());
1137
+ wrapper = (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> *)data.get();
1138
+ Arguments* args = wrapper->arguments_;
1139
+
1140
+ bool hasSelf = (self && self != Qnil);
1141
+ if(args->count() >= 0) {
1142
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
1143
+ } else {
1144
+ hasSelf = hasSelf && argc == Num_Args -1;
1145
+ }
1146
+
1147
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11;
1148
+
1149
+ if(hasSelf) {
1150
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1).c_str()
1151
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11);
1152
+
1153
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
1154
+
1155
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1156
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1157
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1158
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1159
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1160
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1161
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1162
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1163
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1164
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1165
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1166
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1167
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1168
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1169
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1170
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1171
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1172
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
1173
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1174
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
1175
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
1176
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
1177
+
1178
+ return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11));
1179
+ } else {
1180
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
1181
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11);
1182
+
1183
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1184
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1185
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1186
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1187
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1188
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1189
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1190
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1191
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1192
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1193
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1194
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1195
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1196
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1197
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1198
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1199
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1200
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1201
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1202
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1203
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1204
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
1205
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
1206
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
1207
+
1208
+ return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11));
1209
+ }
1210
+ }
1211
+ catch(...)
1212
+ {
1213
+ RUBY_TRY
1214
+ {
1215
+ if(wrapper)
1216
+ {
1217
+ return wrapper->handler_->handle_exception();
1218
+ }
1219
+ else
1220
+ {
1221
+ throw;
1222
+ }
1223
+ }
1224
+ RUBY_CATCH
1225
+ }
1226
+ }
1227
+
1228
+ 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>
1229
+ 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>::
1230
+ Auto_Function_Wrapper(
1231
+ Func func,
1232
+ Data_Object<Exception_Handler> handler,
1233
+ Arguments* arguments)
1234
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
1235
+ , func_(func)
1236
+ , handler_(handler)
1237
+ , handler_guard_(&handler_)
1238
+ {
1239
+ if(arguments == 0) {
1240
+ arguments_ = new Arguments();
1241
+ } else {
1242
+ arguments_ = arguments;
1243
+ }
1244
+ }
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
+
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>
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>::
1255
+ call(int argc, VALUE* argv, VALUE self)
1256
+ {
1257
+ 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> * wrapper = 0;
1258
+ try
1259
+ {
1260
+ Data_Object<Wrapped_Function> data(detail::method_data());
1261
+ wrapper = (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T> *)data.get();
1262
+ Arguments* args = wrapper->arguments_;
1263
+
1264
+ bool hasSelf = (self && self != Qnil);
1265
+ if(args->count() >= 0) {
1266
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
1267
+ } else {
1268
+ hasSelf = hasSelf && argc == Num_Args -1;
1269
+ }
1270
+
1271
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11;
1272
+
1273
+ if(hasSelf) {
1274
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1) .c_str()
1275
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11);
1276
+
1277
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
1278
+
1279
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1280
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1281
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1282
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1283
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1284
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1285
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1286
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1287
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1288
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1289
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1290
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1291
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1292
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1293
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1294
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1295
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1296
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
1297
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1298
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
1299
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
1300
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
1301
+
1302
+ wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
1303
+ return Qnil;
1304
+ } else {
1305
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
1306
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11);
1307
+
1308
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1309
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1310
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1311
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1312
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1313
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1314
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1315
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1316
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1317
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1318
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1319
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1320
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1321
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1322
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1323
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1324
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1325
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1326
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1327
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1328
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1329
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
1330
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
1331
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
1332
+
1333
+ wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
1334
+ return Qnil;
1335
+ }
1336
+ }
1337
+ catch(...)
1338
+ {
1339
+ RUBY_TRY
1340
+ {
1341
+ if(wrapper)
1342
+ {
1343
+ return wrapper->handler_->handle_exception();
1344
+ }
1345
+ else
1346
+ {
1347
+ throw;
1348
+ }
1349
+ }
1350
+ RUBY_CATCH
1351
+ }
1352
+ }
1353
+
1354
+ // ---------------------------------------------------------------------
1355
+ 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>
1356
+ 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>::
1357
+ Auto_Function_Wrapper(
1358
+ Func func,
1359
+ Data_Object<Exception_Handler> handler,
1360
+ Arguments* arguments)
1361
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
1362
+ , func_(func)
1363
+ , handler_(handler)
1364
+ , handler_guard_(&handler_)
1365
+ {
1366
+ if(arguments == 0) {
1367
+ arguments_ = new Arguments();
1368
+ } else {
1369
+ arguments_ = arguments;
1370
+ }
1371
+ }
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
+
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>
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>::
1382
+ call(int argc, VALUE *argv, VALUE self)
1383
+ {
1384
+ 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> * wrapper = 0;
1385
+ try
1386
+ {
1387
+ Data_Object<Wrapped_Function> data(detail::method_data());
1388
+ wrapper = (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> *)data.get();
1389
+ Arguments* args = wrapper->arguments_;
1390
+
1391
+ bool hasSelf = (self && self != Qnil);
1392
+ if(args->count() >= 0) {
1393
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
1394
+ } else {
1395
+ hasSelf = hasSelf && argc == Num_Args -1;
1396
+ }
1397
+
1398
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10;
1399
+
1400
+ if(hasSelf) {
1401
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1).c_str()
1402
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10);
1403
+
1404
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
1405
+
1406
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1407
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1408
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1409
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1410
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1411
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1412
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1413
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1414
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1415
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1416
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1417
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1418
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1419
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1420
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1421
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1422
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1423
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
1424
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1425
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
1426
+
1427
+ return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10));
1428
+ } else {
1429
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
1430
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10);
1431
+
1432
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1433
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1434
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1435
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1436
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1437
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1438
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1439
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1440
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1441
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1442
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1443
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1444
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1445
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1446
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1447
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1448
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1449
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1450
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1451
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1452
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1453
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
1454
+
1455
+ return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10));
1456
+ }
1457
+ }
1458
+ catch(...)
1459
+ {
1460
+ RUBY_TRY
1461
+ {
1462
+ if(wrapper)
1463
+ {
1464
+ return wrapper->handler_->handle_exception();
1465
+ }
1466
+ else
1467
+ {
1468
+ throw;
1469
+ }
1470
+ }
1471
+ RUBY_CATCH
1472
+ }
1473
+ }
1474
+
1475
+ 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>
1476
+ 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>::
1477
+ Auto_Function_Wrapper(
1478
+ Func func,
1479
+ Data_Object<Exception_Handler> handler,
1480
+ Arguments* arguments)
1481
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
1482
+ , func_(func)
1483
+ , handler_(handler)
1484
+ , handler_guard_(&handler_)
1485
+ {
1486
+ if(arguments == 0) {
1487
+ arguments_ = new Arguments();
1488
+ } else {
1489
+ arguments_ = arguments;
1490
+ }
1491
+ }
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
+
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>
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>::
1502
+ call(int argc, VALUE* argv, VALUE self)
1503
+ {
1504
+ 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> * wrapper = 0;
1505
+ try
1506
+ {
1507
+ Data_Object<Wrapped_Function> data(detail::method_data());
1508
+ wrapper = (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T> *)data.get();
1509
+ Arguments* args = wrapper->arguments_;
1510
+
1511
+ bool hasSelf = (self && self != Qnil);
1512
+ if(args->count() >= 0) {
1513
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
1514
+ } else {
1515
+ hasSelf = hasSelf && argc == Num_Args -1;
1516
+ }
1517
+
1518
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10;
1519
+
1520
+ if(hasSelf) {
1521
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1) .c_str()
1522
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10);
1523
+
1524
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
1525
+
1526
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1527
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1528
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1529
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1530
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1531
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1532
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1533
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1534
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1535
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1536
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1537
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1538
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1539
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1540
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1541
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1542
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1543
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
1544
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1545
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
1546
+
1547
+ wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
1548
+ return Qnil;
1549
+ } else {
1550
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
1551
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10);
1552
+
1553
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1554
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1555
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1556
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1557
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1558
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1559
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1560
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1561
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1562
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1563
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1564
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1565
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1566
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1567
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1568
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1569
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1570
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1571
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1572
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1573
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1574
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
1575
+
1576
+ wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
1577
+ return Qnil;
1578
+ }
1579
+ }
1580
+ catch(...)
1581
+ {
1582
+ RUBY_TRY
1583
+ {
1584
+ if(wrapper)
1585
+ {
1586
+ return wrapper->handler_->handle_exception();
1587
+ }
1588
+ else
1589
+ {
1590
+ throw;
1591
+ }
1592
+ }
1593
+ RUBY_CATCH
1594
+ }
1595
+ }
1596
+
1597
+ // ---------------------------------------------------------------------
1598
+ 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>
1599
+ 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>::
1600
+ Auto_Function_Wrapper(
1601
+ Func func,
1602
+ Data_Object<Exception_Handler> handler,
1603
+ Arguments* arguments)
1604
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
1605
+ , func_(func)
1606
+ , handler_(handler)
1607
+ , handler_guard_(&handler_)
1608
+ {
1609
+ if(arguments == 0) {
1610
+ arguments_ = new Arguments();
1611
+ } else {
1612
+ arguments_ = arguments;
1613
+ }
1614
+ }
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
+
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>
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>::
1625
+ call(int argc, VALUE *argv, VALUE self)
1626
+ {
1627
+ 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> * wrapper = 0;
1628
+ try
1629
+ {
1630
+ Data_Object<Wrapped_Function> data(detail::method_data());
1631
+ wrapper = (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> *)data.get();
1632
+ Arguments* args = wrapper->arguments_;
1633
+
1634
+ bool hasSelf = (self && self != Qnil);
1635
+ if(args->count() >= 0) {
1636
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
1637
+ } else {
1638
+ hasSelf = hasSelf && argc == Num_Args -1;
1639
+ }
1640
+
1641
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9;
1642
+
1643
+ if(hasSelf) {
1644
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1).c_str()
1645
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9);
1646
+
1647
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
1648
+
1649
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1650
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1651
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1652
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1653
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1654
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1655
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1656
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1657
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1658
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1659
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1660
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1661
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1662
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1663
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1664
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1665
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1666
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
1667
+
1668
+ return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9));
1669
+ } else {
1670
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
1671
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9);
1672
+
1673
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1674
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1675
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1676
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1677
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1678
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1679
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1680
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1681
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1682
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1683
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1684
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1685
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1686
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1687
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1688
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1689
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1690
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1691
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1692
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1693
+
1694
+ return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9));
1695
+ }
1696
+ }
1697
+ catch(...)
1698
+ {
1699
+ RUBY_TRY
1700
+ {
1701
+ if(wrapper)
1702
+ {
1703
+ return wrapper->handler_->handle_exception();
1704
+ }
1705
+ else
1706
+ {
1707
+ throw;
1708
+ }
1709
+ }
1710
+ RUBY_CATCH
1711
+ }
1712
+ }
1713
+
1714
+ 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>
1715
+ 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>::
1716
+ Auto_Function_Wrapper(
1717
+ Func func,
1718
+ Data_Object<Exception_Handler> handler,
1719
+ Arguments* arguments)
1720
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
1721
+ , func_(func)
1722
+ , handler_(handler)
1723
+ , handler_guard_(&handler_)
1724
+ {
1725
+ if(arguments == 0) {
1726
+ arguments_ = new Arguments();
1727
+ } else {
1728
+ arguments_ = arguments;
1729
+ }
1730
+ }
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
+
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>
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>::
1741
+ call(int argc, VALUE* argv, VALUE self)
1742
+ {
1743
+ 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> * wrapper = 0;
1744
+ try
1745
+ {
1746
+ Data_Object<Wrapped_Function> data(detail::method_data());
1747
+ wrapper = (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T> *)data.get();
1748
+ Arguments* args = wrapper->arguments_;
1749
+
1750
+ bool hasSelf = (self && self != Qnil);
1751
+ if(args->count() >= 0) {
1752
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
1753
+ } else {
1754
+ hasSelf = hasSelf && argc == Num_Args -1;
1755
+ }
1756
+
1757
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9;
1758
+
1759
+ if(hasSelf) {
1760
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1) .c_str()
1761
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9);
1762
+
1763
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
1764
+
1765
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1766
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1767
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1768
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1769
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1770
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1771
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1772
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1773
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1774
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1775
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1776
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1777
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1778
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1779
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1780
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1781
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1782
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
1783
+
1784
+ wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
1785
+ return Qnil;
1786
+ } else {
1787
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
1788
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9);
1789
+
1790
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1791
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1792
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1793
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1794
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1795
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1796
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1797
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1798
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1799
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1800
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1801
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1802
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1803
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1804
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1805
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1806
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1807
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1808
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1809
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1810
+
1811
+ wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
1812
+ return Qnil;
1813
+ }
1814
+ }
1815
+ catch(...)
1816
+ {
1817
+ RUBY_TRY
1818
+ {
1819
+ if(wrapper)
1820
+ {
1821
+ return wrapper->handler_->handle_exception();
1822
+ }
1823
+ else
1824
+ {
1825
+ throw;
1826
+ }
1827
+ }
1828
+ RUBY_CATCH
1829
+ }
1830
+ }
1831
+
1832
+ // ---------------------------------------------------------------------
1833
+ 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>
1834
+ 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>::
1835
+ Auto_Function_Wrapper(
1836
+ Func func,
1837
+ Data_Object<Exception_Handler> handler,
1838
+ Arguments* arguments)
1839
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
1840
+ , func_(func)
1841
+ , handler_(handler)
1842
+ , handler_guard_(&handler_)
1843
+ {
1844
+ if(arguments == 0) {
1845
+ arguments_ = new Arguments();
1846
+ } else {
1847
+ arguments_ = arguments;
1848
+ }
1849
+ }
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
+
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>
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>::
1860
+ call(int argc, VALUE *argv, VALUE self)
1861
+ {
1862
+ 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> * wrapper = 0;
1863
+ try
1864
+ {
1865
+ Data_Object<Wrapped_Function> data(detail::method_data());
1866
+ wrapper = (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> *)data.get();
1867
+ Arguments* args = wrapper->arguments_;
1868
+
1869
+ bool hasSelf = (self && self != Qnil);
1870
+ if(args->count() >= 0) {
1871
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
1872
+ } else {
1873
+ hasSelf = hasSelf && argc == Num_Args -1;
1874
+ }
1875
+
1876
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8;
1877
+
1878
+ if(hasSelf) {
1879
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1).c_str()
1880
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8);
1881
+
1882
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
1883
+
1884
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1885
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1886
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1887
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1888
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1889
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1890
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1891
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1892
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1893
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1894
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1895
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1896
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1897
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1898
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1899
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1900
+
1901
+ return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8));
1902
+ } else {
1903
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
1904
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8);
1905
+
1906
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1907
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1908
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1909
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1910
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1911
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1912
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1913
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1914
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1915
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1916
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1917
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1918
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1919
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1920
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1921
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1922
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1923
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1924
+
1925
+ return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8));
1926
+ }
1927
+ }
1928
+ catch(...)
1929
+ {
1930
+ RUBY_TRY
1931
+ {
1932
+ if(wrapper)
1933
+ {
1934
+ return wrapper->handler_->handle_exception();
1935
+ }
1936
+ else
1937
+ {
1938
+ throw;
1939
+ }
1940
+ }
1941
+ RUBY_CATCH
1942
+ }
1943
+ }
1944
+
1945
+ 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>
1946
+ Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T>::
1947
+ Auto_Function_Wrapper(
1948
+ Func func,
1949
+ Data_Object<Exception_Handler> handler,
1950
+ Arguments* arguments)
1951
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
1952
+ , func_(func)
1953
+ , handler_(handler)
1954
+ , handler_guard_(&handler_)
1955
+ {
1956
+ if(arguments == 0) {
1957
+ arguments_ = new Arguments();
1958
+ } else {
1959
+ arguments_ = arguments;
1960
+ }
1961
+ }
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
+
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>
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>::
1972
+ call(int argc, VALUE* argv, VALUE self)
1973
+ {
1974
+ Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T> * wrapper = 0;
1975
+ try
1976
+ {
1977
+ Data_Object<Wrapped_Function> data(detail::method_data());
1978
+ wrapper = (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T> *)data.get();
1979
+ Arguments* args = wrapper->arguments_;
1980
+
1981
+ bool hasSelf = (self && self != Qnil);
1982
+ if(args->count() >= 0) {
1983
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
1984
+ } else {
1985
+ hasSelf = hasSelf && argc == Num_Args -1;
1986
+ }
1987
+
1988
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8;
1989
+
1990
+ if(hasSelf) {
1991
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1) .c_str()
1992
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8);
1993
+
1994
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
1995
+
1996
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1997
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1998
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1999
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2000
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2001
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2002
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2003
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2004
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2005
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
2006
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2007
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
2008
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
2009
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
2010
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
2011
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
2012
+
2013
+ wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
2014
+ return Qnil;
2015
+ } else {
2016
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
2017
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8);
2018
+
2019
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2020
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2021
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2022
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2023
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2024
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2025
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2026
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2027
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2028
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2029
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2030
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
2031
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2032
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
2033
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
2034
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
2035
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
2036
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
2037
+
2038
+ wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
2039
+ return Qnil;
2040
+ }
2041
+ }
2042
+ catch(...)
2043
+ {
2044
+ RUBY_TRY
2045
+ {
2046
+ if(wrapper)
2047
+ {
2048
+ return wrapper->handler_->handle_exception();
2049
+ }
2050
+ else
2051
+ {
2052
+ throw;
2053
+ }
2054
+ }
2055
+ RUBY_CATCH
2056
+ }
2057
+ }
2058
+
2059
+ // ---------------------------------------------------------------------
2060
+ 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>
2061
+ Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T>::
2062
+ Auto_Function_Wrapper(
2063
+ Func func,
2064
+ Data_Object<Exception_Handler> handler,
2065
+ Arguments* arguments)
2066
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
2067
+ , func_(func)
2068
+ , handler_(handler)
2069
+ , handler_guard_(&handler_)
2070
+ {
2071
+ if(arguments == 0) {
2072
+ arguments_ = new Arguments();
2073
+ } else {
2074
+ arguments_ = arguments;
2075
+ }
2076
+ }
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
+
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>
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>::
2087
+ call(int argc, VALUE *argv, VALUE self)
2088
+ {
2089
+ Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T> * wrapper = 0;
2090
+ try
2091
+ {
2092
+ Data_Object<Wrapped_Function> data(detail::method_data());
2093
+ wrapper = (Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T> *)data.get();
2094
+ Arguments* args = wrapper->arguments_;
2095
+
2096
+ bool hasSelf = (self && self != Qnil);
2097
+ if(args->count() >= 0) {
2098
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
2099
+ } else {
2100
+ hasSelf = hasSelf && argc == Num_Args -1;
2101
+ }
2102
+
2103
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7;
2104
+
2105
+ if(hasSelf) {
2106
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1).c_str()
2107
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7);
2108
+
2109
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
2110
+
2111
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2112
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2113
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2114
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2115
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2116
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2117
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2118
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2119
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2120
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
2121
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2122
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
2123
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
2124
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
2125
+
2126
+ return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7));
2127
+ } else {
2128
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
2129
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7);
2130
+
2131
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2132
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2133
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2134
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2135
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2136
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2137
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2138
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2139
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2140
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2141
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2142
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
2143
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2144
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
2145
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
2146
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
2147
+
2148
+ return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7));
2149
+ }
2150
+ }
2151
+ catch(...)
2152
+ {
2153
+ RUBY_TRY
2154
+ {
2155
+ if(wrapper)
2156
+ {
2157
+ return wrapper->handler_->handle_exception();
2158
+ }
2159
+ else
2160
+ {
2161
+ throw;
2162
+ }
2163
+ }
2164
+ RUBY_CATCH
2165
+ }
2166
+ }
2167
+
2168
+ 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>
2169
+ Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T>::
2170
+ Auto_Function_Wrapper(
2171
+ Func func,
2172
+ Data_Object<Exception_Handler> handler,
2173
+ Arguments* arguments)
2174
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
2175
+ , func_(func)
2176
+ , handler_(handler)
2177
+ , handler_guard_(&handler_)
2178
+ {
2179
+ if(arguments == 0) {
2180
+ arguments_ = new Arguments();
2181
+ } else {
2182
+ arguments_ = arguments;
2183
+ }
2184
+ }
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
+
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>
2194
+ VALUE Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T>::
2195
+ call(int argc, VALUE* argv, VALUE self)
2196
+ {
2197
+ Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T> * wrapper = 0;
2198
+ try
2199
+ {
2200
+ Data_Object<Wrapped_Function> data(detail::method_data());
2201
+ wrapper = (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T> *)data.get();
2202
+ Arguments* args = wrapper->arguments_;
2203
+
2204
+ bool hasSelf = (self && self != Qnil);
2205
+ if(args->count() >= 0) {
2206
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
2207
+ } else {
2208
+ hasSelf = hasSelf && argc == Num_Args -1;
2209
+ }
2210
+
2211
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7;
2212
+
2213
+ if(hasSelf) {
2214
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1) .c_str()
2215
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7);
2216
+
2217
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
2218
+
2219
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2220
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2221
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2222
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2223
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2224
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2225
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2226
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2227
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2228
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
2229
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2230
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
2231
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
2232
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
2233
+
2234
+ wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
2235
+ return Qnil;
2236
+ } else {
2237
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
2238
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7);
2239
+
2240
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2241
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2242
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2243
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2244
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2245
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2246
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2247
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2248
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2249
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2250
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2251
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
2252
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2253
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
2254
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
2255
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
2256
+
2257
+ wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
2258
+ return Qnil;
2259
+ }
2260
+ }
2261
+ catch(...)
2262
+ {
2263
+ RUBY_TRY
2264
+ {
2265
+ if(wrapper)
2266
+ {
2267
+ return wrapper->handler_->handle_exception();
2268
+ }
2269
+ else
2270
+ {
2271
+ throw;
2272
+ }
2273
+ }
2274
+ RUBY_CATCH
2275
+ }
2276
+ }
2277
+
2278
+ // ---------------------------------------------------------------------
2279
+ 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>
2280
+ Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T>::
2281
+ Auto_Function_Wrapper(
2282
+ Func func,
2283
+ Data_Object<Exception_Handler> handler,
2284
+ Arguments* arguments)
2285
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
2286
+ , func_(func)
2287
+ , handler_(handler)
2288
+ , handler_guard_(&handler_)
2289
+ {
2290
+ if(arguments == 0) {
2291
+ arguments_ = new Arguments();
2292
+ } else {
2293
+ arguments_ = arguments;
2294
+ }
2295
+ }
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
+
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>
2305
+ VALUE Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T>::
2306
+ call(int argc, VALUE *argv, VALUE self)
2307
+ {
2308
+ Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T> * wrapper = 0;
2309
+ try
2310
+ {
2311
+ Data_Object<Wrapped_Function> data(detail::method_data());
2312
+ wrapper = (Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T> *)data.get();
2313
+ Arguments* args = wrapper->arguments_;
2314
+
2315
+ bool hasSelf = (self && self != Qnil);
2316
+ if(args->count() >= 0) {
2317
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
2318
+ } else {
2319
+ hasSelf = hasSelf && argc == Num_Args -1;
2320
+ }
2321
+
2322
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6;
2323
+
2324
+ if(hasSelf) {
2325
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1).c_str()
2326
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6);
2327
+
2328
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
2329
+
2330
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2331
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2332
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2333
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2334
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2335
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2336
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2337
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2338
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2339
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
2340
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2341
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
2342
+
2343
+ return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6));
2344
+ } else {
2345
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
2346
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6);
2347
+
2348
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2349
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2350
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2351
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2352
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2353
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2354
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2355
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2356
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2357
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2358
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2359
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
2360
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2361
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
2362
+
2363
+ return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6));
2364
+ }
2365
+ }
2366
+ catch(...)
2367
+ {
2368
+ RUBY_TRY
2369
+ {
2370
+ if(wrapper)
2371
+ {
2372
+ return wrapper->handler_->handle_exception();
2373
+ }
2374
+ else
2375
+ {
2376
+ throw;
2377
+ }
2378
+ }
2379
+ RUBY_CATCH
2380
+ }
2381
+ }
2382
+
2383
+ 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>
2384
+ Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T>::
2385
+ Auto_Function_Wrapper(
2386
+ Func func,
2387
+ Data_Object<Exception_Handler> handler,
2388
+ Arguments* arguments)
2389
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
2390
+ , func_(func)
2391
+ , handler_(handler)
2392
+ , handler_guard_(&handler_)
2393
+ {
2394
+ if(arguments == 0) {
2395
+ arguments_ = new Arguments();
2396
+ } else {
2397
+ arguments_ = arguments;
2398
+ }
2399
+ }
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
+
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>
2409
+ VALUE Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T>::
2410
+ call(int argc, VALUE* argv, VALUE self)
2411
+ {
2412
+ Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T> * wrapper = 0;
2413
+ try
2414
+ {
2415
+ Data_Object<Wrapped_Function> data(detail::method_data());
2416
+ wrapper = (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T> *)data.get();
2417
+ Arguments* args = wrapper->arguments_;
2418
+
2419
+ bool hasSelf = (self && self != Qnil);
2420
+ if(args->count() >= 0) {
2421
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
2422
+ } else {
2423
+ hasSelf = hasSelf && argc == Num_Args -1;
2424
+ }
2425
+
2426
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6;
2427
+
2428
+ if(hasSelf) {
2429
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1) .c_str()
2430
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6);
2431
+
2432
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
2433
+
2434
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2435
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2436
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2437
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2438
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2439
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2440
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2441
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2442
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2443
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
2444
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2445
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
2446
+
2447
+ wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
2448
+ return Qnil;
2449
+ } else {
2450
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
2451
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6);
2452
+
2453
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2454
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2455
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2456
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2457
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2458
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2459
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2460
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2461
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2462
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2463
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2464
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
2465
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2466
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
2467
+
2468
+ wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
2469
+ return Qnil;
2470
+ }
2471
+ }
2472
+ catch(...)
2473
+ {
2474
+ RUBY_TRY
2475
+ {
2476
+ if(wrapper)
2477
+ {
2478
+ return wrapper->handler_->handle_exception();
2479
+ }
2480
+ else
2481
+ {
2482
+ throw;
2483
+ }
2484
+ }
2485
+ RUBY_CATCH
2486
+ }
2487
+ }
2488
+
2489
+ // ---------------------------------------------------------------------
2490
+ 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>
2491
+ Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T>::
2492
+ Auto_Function_Wrapper(
2493
+ Func func,
2494
+ Data_Object<Exception_Handler> handler,
2495
+ Arguments* arguments)
2496
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
2497
+ , func_(func)
2498
+ , handler_(handler)
2499
+ , handler_guard_(&handler_)
2500
+ {
2501
+ if(arguments == 0) {
2502
+ arguments_ = new Arguments();
2503
+ } else {
2504
+ arguments_ = arguments;
2505
+ }
2506
+ }
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
+
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>
2516
+ VALUE Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T>::
2517
+ call(int argc, VALUE *argv, VALUE self)
2518
+ {
2519
+ Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T> * wrapper = 0;
2520
+ try
2521
+ {
2522
+ Data_Object<Wrapped_Function> data(detail::method_data());
2523
+ wrapper = (Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T> *)data.get();
2524
+ Arguments* args = wrapper->arguments_;
2525
+
2526
+ bool hasSelf = (self && self != Qnil);
2527
+ if(args->count() >= 0) {
2528
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
2529
+ } else {
2530
+ hasSelf = hasSelf && argc == Num_Args -1;
2531
+ }
2532
+
2533
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5;
2534
+
2535
+ if(hasSelf) {
2536
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1).c_str()
2537
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5);
2538
+
2539
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
2540
+
2541
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2542
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2543
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2544
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2545
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2546
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2547
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2548
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2549
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2550
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
2551
+
2552
+ return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5));
2553
+ } else {
2554
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
2555
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5);
2556
+
2557
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2558
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2559
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2560
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2561
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2562
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2563
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2564
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2565
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2566
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2567
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2568
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
2569
+
2570
+ return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5));
2571
+ }
2572
+ }
2573
+ catch(...)
2574
+ {
2575
+ RUBY_TRY
2576
+ {
2577
+ if(wrapper)
2578
+ {
2579
+ return wrapper->handler_->handle_exception();
2580
+ }
2581
+ else
2582
+ {
2583
+ throw;
2584
+ }
2585
+ }
2586
+ RUBY_CATCH
2587
+ }
2588
+ }
2589
+
2590
+ template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T>
2591
+ Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T>::
2592
+ Auto_Function_Wrapper(
2593
+ Func func,
2594
+ Data_Object<Exception_Handler> handler,
2595
+ Arguments* arguments)
2596
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
2597
+ , func_(func)
2598
+ , handler_(handler)
2599
+ , handler_guard_(&handler_)
2600
+ {
2601
+ if(arguments == 0) {
2602
+ arguments_ = new Arguments();
2603
+ } else {
2604
+ arguments_ = arguments;
2605
+ }
2606
+ }
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
+
2615
+ template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T>
2616
+ VALUE Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T>::
2617
+ call(int argc, VALUE* argv, VALUE self)
2618
+ {
2619
+ Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T> * wrapper = 0;
2620
+ try
2621
+ {
2622
+ Data_Object<Wrapped_Function> data(detail::method_data());
2623
+ wrapper = (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T> *)data.get();
2624
+ Arguments* args = wrapper->arguments_;
2625
+
2626
+ bool hasSelf = (self && self != Qnil);
2627
+ if(args->count() >= 0) {
2628
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
2629
+ } else {
2630
+ hasSelf = hasSelf && argc == Num_Args -1;
2631
+ }
2632
+
2633
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5;
2634
+
2635
+ if(hasSelf) {
2636
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1) .c_str()
2637
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5);
2638
+
2639
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
2640
+
2641
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2642
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2643
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2644
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2645
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2646
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2647
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2648
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2649
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2650
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
2651
+
2652
+ wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5);
2653
+ return Qnil;
2654
+ } else {
2655
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
2656
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5);
2657
+
2658
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2659
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2660
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2661
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2662
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2663
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2664
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2665
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2666
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2667
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2668
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2669
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
2670
+
2671
+ wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5);
2672
+ return Qnil;
2673
+ }
2674
+ }
2675
+ catch(...)
2676
+ {
2677
+ RUBY_TRY
2678
+ {
2679
+ if(wrapper)
2680
+ {
2681
+ return wrapper->handler_->handle_exception();
2682
+ }
2683
+ else
2684
+ {
2685
+ throw;
2686
+ }
2687
+ }
2688
+ RUBY_CATCH
2689
+ }
2690
+ }
2691
+
2692
+ // ---------------------------------------------------------------------
2693
+ template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T>
2694
+ Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T>::
2695
+ Auto_Function_Wrapper(
2696
+ Func func,
2697
+ Data_Object<Exception_Handler> handler,
2698
+ Arguments* arguments)
2699
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
2700
+ , func_(func)
2701
+ , handler_(handler)
2702
+ , handler_guard_(&handler_)
2703
+ {
2704
+ if(arguments == 0) {
2705
+ arguments_ = new Arguments();
2706
+ } else {
2707
+ arguments_ = arguments;
2708
+ }
2709
+ }
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
+
2718
+ template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T>
2719
+ VALUE Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T>::
2720
+ call(int argc, VALUE *argv, VALUE self)
2721
+ {
2722
+ Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T> * wrapper = 0;
2723
+ try
2724
+ {
2725
+ Data_Object<Wrapped_Function> data(detail::method_data());
2726
+ wrapper = (Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T> *)data.get();
2727
+ Arguments* args = wrapper->arguments_;
2728
+
2729
+ bool hasSelf = (self && self != Qnil);
2730
+ if(args->count() >= 0) {
2731
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
2732
+ } else {
2733
+ hasSelf = hasSelf && argc == Num_Args -1;
2734
+ }
2735
+
2736
+ VALUE varg0, varg1, varg2, varg3, varg4;
2737
+
2738
+ if(hasSelf) {
2739
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1).c_str()
2740
+ , &varg0, &varg1, &varg2, &varg3, &varg4);
2741
+
2742
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
2743
+
2744
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2745
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2746
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2747
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2748
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2749
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2750
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2751
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2752
+
2753
+ return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4));
2754
+ } else {
2755
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
2756
+ , &varg0, &varg1, &varg2, &varg3, &varg4);
2757
+
2758
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2759
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2760
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2761
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2762
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2763
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2764
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2765
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2766
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2767
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2768
+
2769
+ return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4));
2770
+ }
2771
+ }
2772
+ catch(...)
2773
+ {
2774
+ RUBY_TRY
2775
+ {
2776
+ if(wrapper)
2777
+ {
2778
+ return wrapper->handler_->handle_exception();
2779
+ }
2780
+ else
2781
+ {
2782
+ throw;
2783
+ }
2784
+ }
2785
+ RUBY_CATCH
2786
+ }
2787
+ }
2788
+
2789
+ template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T>
2790
+ Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T>::
2791
+ Auto_Function_Wrapper(
2792
+ Func func,
2793
+ Data_Object<Exception_Handler> handler,
2794
+ Arguments* arguments)
2795
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
2796
+ , func_(func)
2797
+ , handler_(handler)
2798
+ , handler_guard_(&handler_)
2799
+ {
2800
+ if(arguments == 0) {
2801
+ arguments_ = new Arguments();
2802
+ } else {
2803
+ arguments_ = arguments;
2804
+ }
2805
+ }
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
+
2814
+ template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T>
2815
+ VALUE Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T>::
2816
+ call(int argc, VALUE* argv, VALUE self)
2817
+ {
2818
+ Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T> * wrapper = 0;
2819
+ try
2820
+ {
2821
+ Data_Object<Wrapped_Function> data(detail::method_data());
2822
+ wrapper = (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T> *)data.get();
2823
+ Arguments* args = wrapper->arguments_;
2824
+
2825
+ bool hasSelf = (self && self != Qnil);
2826
+ if(args->count() >= 0) {
2827
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
2828
+ } else {
2829
+ hasSelf = hasSelf && argc == Num_Args -1;
2830
+ }
2831
+
2832
+ VALUE varg0, varg1, varg2, varg3, varg4;
2833
+
2834
+ if(hasSelf) {
2835
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1) .c_str()
2836
+ , &varg0, &varg1, &varg2, &varg3, &varg4);
2837
+
2838
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
2839
+
2840
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2841
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2842
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2843
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2844
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2845
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2846
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2847
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2848
+
2849
+ wrapper->func_(arg0, arg1, arg2, arg3, arg4);
2850
+ return Qnil;
2851
+ } else {
2852
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
2853
+ , &varg0, &varg1, &varg2, &varg3, &varg4);
2854
+
2855
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2856
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2857
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2858
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2859
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2860
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2861
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2862
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2863
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2864
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2865
+
2866
+ wrapper->func_(arg0, arg1, arg2, arg3, arg4);
2867
+ return Qnil;
2868
+ }
2869
+ }
2870
+ catch(...)
2871
+ {
2872
+ RUBY_TRY
2873
+ {
2874
+ if(wrapper)
2875
+ {
2876
+ return wrapper->handler_->handle_exception();
2877
+ }
2878
+ else
2879
+ {
2880
+ throw;
2881
+ }
2882
+ }
2883
+ RUBY_CATCH
2884
+ }
2885
+ }
2886
+
2887
+ // ---------------------------------------------------------------------
2888
+ template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T>
2889
+ Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T>::
2890
+ Auto_Function_Wrapper(
2891
+ Func func,
2892
+ Data_Object<Exception_Handler> handler,
2893
+ Arguments* arguments)
2894
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
2895
+ , func_(func)
2896
+ , handler_(handler)
2897
+ , handler_guard_(&handler_)
2898
+ {
2899
+ if(arguments == 0) {
2900
+ arguments_ = new Arguments();
2901
+ } else {
2902
+ arguments_ = arguments;
2903
+ }
2904
+ }
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
+
2913
+ template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T>
2914
+ VALUE Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T>::
2915
+ call(int argc, VALUE *argv, VALUE self)
2916
+ {
2917
+ Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T> * wrapper = 0;
2918
+ try
2919
+ {
2920
+ Data_Object<Wrapped_Function> data(detail::method_data());
2921
+ wrapper = (Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T> *)data.get();
2922
+ Arguments* args = wrapper->arguments_;
2923
+
2924
+ bool hasSelf = (self && self != Qnil);
2925
+ if(args->count() >= 0) {
2926
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
2927
+ } else {
2928
+ hasSelf = hasSelf && argc == Num_Args -1;
2929
+ }
2930
+
2931
+ VALUE varg0, varg1, varg2, varg3;
2932
+
2933
+ if(hasSelf) {
2934
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1).c_str()
2935
+ , &varg0, &varg1, &varg2, &varg3);
2936
+
2937
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
2938
+
2939
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2940
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2941
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2942
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2943
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2944
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2945
+
2946
+ return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3));
2947
+ } else {
2948
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
2949
+ , &varg0, &varg1, &varg2, &varg3);
2950
+
2951
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2952
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2953
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2954
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2955
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2956
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2957
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2958
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2959
+
2960
+ return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3));
2961
+ }
2962
+ }
2963
+ catch(...)
2964
+ {
2965
+ RUBY_TRY
2966
+ {
2967
+ if(wrapper)
2968
+ {
2969
+ return wrapper->handler_->handle_exception();
2970
+ }
2971
+ else
2972
+ {
2973
+ throw;
2974
+ }
2975
+ }
2976
+ RUBY_CATCH
2977
+ }
2978
+ }
2979
+
2980
+ template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T>
2981
+ Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T>::
2982
+ Auto_Function_Wrapper(
2983
+ Func func,
2984
+ Data_Object<Exception_Handler> handler,
2985
+ Arguments* arguments)
2986
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
2987
+ , func_(func)
2988
+ , handler_(handler)
2989
+ , handler_guard_(&handler_)
2990
+ {
2991
+ if(arguments == 0) {
2992
+ arguments_ = new Arguments();
2993
+ } else {
2994
+ arguments_ = arguments;
2995
+ }
2996
+ }
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
+
3005
+ template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T>
3006
+ VALUE Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T>::
3007
+ call(int argc, VALUE* argv, VALUE self)
3008
+ {
3009
+ Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T> * wrapper = 0;
3010
+ try
3011
+ {
3012
+ Data_Object<Wrapped_Function> data(detail::method_data());
3013
+ wrapper = (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T> *)data.get();
3014
+ Arguments* args = wrapper->arguments_;
3015
+
3016
+ bool hasSelf = (self && self != Qnil);
3017
+ if(args->count() >= 0) {
3018
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
3019
+ } else {
3020
+ hasSelf = hasSelf && argc == Num_Args -1;
3021
+ }
3022
+
3023
+ VALUE varg0, varg1, varg2, varg3;
3024
+
3025
+ if(hasSelf) {
3026
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1) .c_str()
3027
+ , &varg0, &varg1, &varg2, &varg3);
3028
+
3029
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
3030
+
3031
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3032
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
3033
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
3034
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
3035
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
3036
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
3037
+
3038
+ wrapper->func_(arg0, arg1, arg2, arg3);
3039
+ return Qnil;
3040
+ } else {
3041
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
3042
+ , &varg0, &varg1, &varg2, &varg3);
3043
+
3044
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
3045
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
3046
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3047
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
3048
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
3049
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
3050
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
3051
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
3052
+
3053
+ wrapper->func_(arg0, arg1, arg2, arg3);
3054
+ return Qnil;
3055
+ }
3056
+ }
3057
+ catch(...)
3058
+ {
3059
+ RUBY_TRY
3060
+ {
3061
+ if(wrapper)
3062
+ {
3063
+ return wrapper->handler_->handle_exception();
3064
+ }
3065
+ else
3066
+ {
3067
+ throw;
3068
+ }
3069
+ }
3070
+ RUBY_CATCH
3071
+ }
3072
+ }
3073
+
3074
+ // ---------------------------------------------------------------------
3075
+ template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T>
3076
+ Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T>::
3077
+ Auto_Function_Wrapper(
3078
+ Func func,
3079
+ Data_Object<Exception_Handler> handler,
3080
+ Arguments* arguments)
3081
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
3082
+ , func_(func)
3083
+ , handler_(handler)
3084
+ , handler_guard_(&handler_)
3085
+ {
3086
+ if(arguments == 0) {
3087
+ arguments_ = new Arguments();
3088
+ } else {
3089
+ arguments_ = arguments;
3090
+ }
3091
+ }
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
+
3100
+ template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T>
3101
+ VALUE Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T>::
3102
+ call(int argc, VALUE *argv, VALUE self)
3103
+ {
3104
+ Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T> * wrapper = 0;
3105
+ try
3106
+ {
3107
+ Data_Object<Wrapped_Function> data(detail::method_data());
3108
+ wrapper = (Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T> *)data.get();
3109
+ Arguments* args = wrapper->arguments_;
3110
+
3111
+ bool hasSelf = (self && self != Qnil);
3112
+ if(args->count() >= 0) {
3113
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
3114
+ } else {
3115
+ hasSelf = hasSelf && argc == Num_Args -1;
3116
+ }
3117
+
3118
+ VALUE varg0, varg1, varg2;
3119
+
3120
+ if(hasSelf) {
3121
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1).c_str()
3122
+ , &varg0, &varg1, &varg2);
3123
+
3124
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
3125
+
3126
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3127
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
3128
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
3129
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
3130
+
3131
+ return to_ruby(wrapper->func_(arg0, arg1, arg2));
3132
+ } else {
3133
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
3134
+ , &varg0, &varg1, &varg2);
3135
+
3136
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
3137
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
3138
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3139
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
3140
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
3141
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
3142
+
3143
+ return to_ruby(wrapper->func_(arg0, arg1, arg2));
3144
+ }
3145
+ }
3146
+ catch(...)
3147
+ {
3148
+ RUBY_TRY
3149
+ {
3150
+ if(wrapper)
3151
+ {
3152
+ return wrapper->handler_->handle_exception();
3153
+ }
3154
+ else
3155
+ {
3156
+ throw;
3157
+ }
3158
+ }
3159
+ RUBY_CATCH
3160
+ }
3161
+ }
3162
+
3163
+ template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T>
3164
+ Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T>::
3165
+ Auto_Function_Wrapper(
3166
+ Func func,
3167
+ Data_Object<Exception_Handler> handler,
3168
+ Arguments* arguments)
3169
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
3170
+ , func_(func)
3171
+ , handler_(handler)
3172
+ , handler_guard_(&handler_)
3173
+ {
3174
+ if(arguments == 0) {
3175
+ arguments_ = new Arguments();
3176
+ } else {
3177
+ arguments_ = arguments;
3178
+ }
3179
+ }
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
+
3188
+ template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T>
3189
+ VALUE Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T>::
3190
+ call(int argc, VALUE* argv, VALUE self)
3191
+ {
3192
+ Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T> * wrapper = 0;
3193
+ try
3194
+ {
3195
+ Data_Object<Wrapped_Function> data(detail::method_data());
3196
+ wrapper = (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T> *)data.get();
3197
+ Arguments* args = wrapper->arguments_;
3198
+
3199
+ bool hasSelf = (self && self != Qnil);
3200
+ if(args->count() >= 0) {
3201
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
3202
+ } else {
3203
+ hasSelf = hasSelf && argc == Num_Args -1;
3204
+ }
3205
+
3206
+ VALUE varg0, varg1, varg2;
3207
+
3208
+ if(hasSelf) {
3209
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1) .c_str()
3210
+ , &varg0, &varg1, &varg2);
3211
+
3212
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
3213
+
3214
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3215
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
3216
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
3217
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
3218
+
3219
+ wrapper->func_(arg0, arg1, arg2);
3220
+ return Qnil;
3221
+ } else {
3222
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
3223
+ , &varg0, &varg1, &varg2);
3224
+
3225
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
3226
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
3227
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3228
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
3229
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
3230
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
3231
+
3232
+ wrapper->func_(arg0, arg1, arg2);
3233
+ return Qnil;
3234
+ }
3235
+ }
3236
+ catch(...)
3237
+ {
3238
+ RUBY_TRY
3239
+ {
3240
+ if(wrapper)
3241
+ {
3242
+ return wrapper->handler_->handle_exception();
3243
+ }
3244
+ else
3245
+ {
3246
+ throw;
3247
+ }
3248
+ }
3249
+ RUBY_CATCH
3250
+ }
3251
+ }
3252
+
3253
+ // ---------------------------------------------------------------------
3254
+ template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T>
3255
+ Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T>::
3256
+ Auto_Function_Wrapper(
3257
+ Func func,
3258
+ Data_Object<Exception_Handler> handler,
3259
+ Arguments* arguments)
3260
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
3261
+ , func_(func)
3262
+ , handler_(handler)
3263
+ , handler_guard_(&handler_)
3264
+ {
3265
+ if(arguments == 0) {
3266
+ arguments_ = new Arguments();
3267
+ } else {
3268
+ arguments_ = arguments;
3269
+ }
3270
+ }
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
+
3279
+ template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T>
3280
+ VALUE Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T>::
3281
+ call(int argc, VALUE *argv, VALUE self)
3282
+ {
3283
+ Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T> * wrapper = 0;
3284
+ try
3285
+ {
3286
+ Data_Object<Wrapped_Function> data(detail::method_data());
3287
+ wrapper = (Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T> *)data.get();
3288
+ Arguments* args = wrapper->arguments_;
3289
+
3290
+ bool hasSelf = (self && self != Qnil);
3291
+ if(args->count() >= 0) {
3292
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
3293
+ } else {
3294
+ hasSelf = hasSelf && argc == Num_Args -1;
3295
+ }
3296
+
3297
+ VALUE varg0, varg1;
3298
+
3299
+ if(hasSelf) {
3300
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1).c_str()
3301
+ , &varg0, &varg1);
3302
+
3303
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
3304
+
3305
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3306
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
3307
+
3308
+ return to_ruby(wrapper->func_(arg0, arg1));
3309
+ } else {
3310
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
3311
+ , &varg0, &varg1);
3312
+
3313
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
3314
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
3315
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3316
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
3317
+
3318
+ return to_ruby(wrapper->func_(arg0, arg1));
3319
+ }
3320
+ }
3321
+ catch(...)
3322
+ {
3323
+ RUBY_TRY
3324
+ {
3325
+ if(wrapper)
3326
+ {
3327
+ return wrapper->handler_->handle_exception();
3328
+ }
3329
+ else
3330
+ {
3331
+ throw;
3332
+ }
3333
+ }
3334
+ RUBY_CATCH
3335
+ }
3336
+ }
3337
+
3338
+ template<typename Func_T, typename Arg0_T, typename Arg1_T>
3339
+ Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T>::
3340
+ Auto_Function_Wrapper(
3341
+ Func func,
3342
+ Data_Object<Exception_Handler> handler,
3343
+ Arguments* arguments)
3344
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
3345
+ , func_(func)
3346
+ , handler_(handler)
3347
+ , handler_guard_(&handler_)
3348
+ {
3349
+ if(arguments == 0) {
3350
+ arguments_ = new Arguments();
3351
+ } else {
3352
+ arguments_ = arguments;
3353
+ }
3354
+ }
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
+
3363
+ template<typename Func_T, typename Arg0_T, typename Arg1_T>
3364
+ VALUE Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T>::
3365
+ call(int argc, VALUE* argv, VALUE self)
3366
+ {
3367
+ Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T> * wrapper = 0;
3368
+ try
3369
+ {
3370
+ Data_Object<Wrapped_Function> data(detail::method_data());
3371
+ wrapper = (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T> *)data.get();
3372
+ Arguments* args = wrapper->arguments_;
3373
+
3374
+ bool hasSelf = (self && self != Qnil);
3375
+ if(args->count() >= 0) {
3376
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
3377
+ } else {
3378
+ hasSelf = hasSelf && argc == Num_Args -1;
3379
+ }
3380
+
3381
+ VALUE varg0, varg1;
3382
+
3383
+ if(hasSelf) {
3384
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1) .c_str()
3385
+ , &varg0, &varg1);
3386
+
3387
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
3388
+
3389
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3390
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
3391
+
3392
+ wrapper->func_(arg0, arg1);
3393
+ return Qnil;
3394
+ } else {
3395
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
3396
+ , &varg0, &varg1);
3397
+
3398
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
3399
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
3400
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3401
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
3402
+
3403
+ wrapper->func_(arg0, arg1);
3404
+ return Qnil;
3405
+ }
3406
+ }
3407
+ catch(...)
3408
+ {
3409
+ RUBY_TRY
3410
+ {
3411
+ if(wrapper)
3412
+ {
3413
+ return wrapper->handler_->handle_exception();
3414
+ }
3415
+ else
3416
+ {
3417
+ throw;
3418
+ }
3419
+ }
3420
+ RUBY_CATCH
3421
+ }
3422
+ }
3423
+
3424
+ // ---------------------------------------------------------------------
3425
+ template<typename Func_T, typename Ret_T, typename Arg0_T>
3426
+ Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T>::
3427
+ Auto_Function_Wrapper(
3428
+ Func func,
3429
+ Data_Object<Exception_Handler> handler,
3430
+ Arguments* arguments)
3431
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
3432
+ , func_(func)
3433
+ , handler_(handler)
3434
+ , handler_guard_(&handler_)
3435
+ {
3436
+ if(arguments == 0) {
3437
+ arguments_ = new Arguments();
3438
+ } else {
3439
+ arguments_ = arguments;
3440
+ }
3441
+ }
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
+
3450
+ template<typename Func_T, typename Ret_T, typename Arg0_T>
3451
+ VALUE Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T>::
3452
+ call(int argc, VALUE *argv, VALUE self)
3453
+ {
3454
+ Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T> * wrapper = 0;
3455
+ try
3456
+ {
3457
+ Data_Object<Wrapped_Function> data(detail::method_data());
3458
+ wrapper = (Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T> *)data.get();
3459
+ Arguments* args = wrapper->arguments_;
3460
+
3461
+ bool hasSelf = (self && self != Qnil);
3462
+ if(args->count() >= 0) {
3463
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
3464
+ } else {
3465
+ hasSelf = hasSelf && argc == Num_Args -1;
3466
+ }
3467
+
3468
+ VALUE varg0;
3469
+
3470
+ if(hasSelf) {
3471
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1).c_str()
3472
+ , &varg0);
3473
+
3474
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
3475
+
3476
+
3477
+ return to_ruby(wrapper->func_(arg0));
3478
+ } else {
3479
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
3480
+ , &varg0);
3481
+
3482
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
3483
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
3484
+
3485
+ return to_ruby(wrapper->func_(arg0));
3486
+ }
3487
+ }
3488
+ catch(...)
3489
+ {
3490
+ RUBY_TRY
3491
+ {
3492
+ if(wrapper)
3493
+ {
3494
+ return wrapper->handler_->handle_exception();
3495
+ }
3496
+ else
3497
+ {
3498
+ throw;
3499
+ }
3500
+ }
3501
+ RUBY_CATCH
3502
+ }
3503
+ }
3504
+
3505
+ template<typename Func_T, typename Arg0_T>
3506
+ Auto_Function_Wrapper<Func_T, void, Arg0_T>::
3507
+ Auto_Function_Wrapper(
3508
+ Func func,
3509
+ Data_Object<Exception_Handler> handler,
3510
+ Arguments* arguments)
3511
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
3512
+ , func_(func)
3513
+ , handler_(handler)
3514
+ , handler_guard_(&handler_)
3515
+ {
3516
+ if(arguments == 0) {
3517
+ arguments_ = new Arguments();
3518
+ } else {
3519
+ arguments_ = arguments;
3520
+ }
3521
+ }
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
+
3530
+ template<typename Func_T, typename Arg0_T>
3531
+ VALUE Auto_Function_Wrapper<Func_T, void, Arg0_T>::
3532
+ call(int argc, VALUE* argv, VALUE self)
3533
+ {
3534
+ Auto_Function_Wrapper<Func_T, void, Arg0_T> * wrapper = 0;
3535
+ try
3536
+ {
3537
+ Data_Object<Wrapped_Function> data(detail::method_data());
3538
+ wrapper = (Auto_Function_Wrapper<Func_T, void, Arg0_T> *)data.get();
3539
+ Arguments* args = wrapper->arguments_;
3540
+
3541
+ bool hasSelf = (self && self != Qnil);
3542
+ if(args->count() >= 0) {
3543
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
3544
+ } else {
3545
+ hasSelf = hasSelf && argc == Num_Args -1;
3546
+ }
3547
+
3548
+ VALUE varg0;
3549
+
3550
+ if(hasSelf) {
3551
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1) .c_str()
3552
+ , &varg0);
3553
+
3554
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
3555
+
3556
+
3557
+ wrapper->func_(arg0);
3558
+ return Qnil;
3559
+ } else {
3560
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
3561
+ , &varg0);
3562
+
3563
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
3564
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
3565
+
3566
+ wrapper->func_(arg0);
3567
+ return Qnil;
3568
+ }
3569
+ }
3570
+ catch(...)
3571
+ {
3572
+ RUBY_TRY
3573
+ {
3574
+ if(wrapper)
3575
+ {
3576
+ return wrapper->handler_->handle_exception();
3577
+ }
3578
+ else
3579
+ {
3580
+ throw;
3581
+ }
3582
+ }
3583
+ RUBY_CATCH
3584
+ }
3585
+ }
3586
+
3587
+ // ---------------------------------------------------------------------
3588
+
3589
+ template<typename Func_T, typename Ret_T>
3590
+ Auto_Function_Wrapper<Func_T, Ret_T>::
3591
+ Auto_Function_Wrapper(
3592
+ Func func,
3593
+ Data_Object<Exception_Handler> handler,
3594
+ Arguments* arguments)
3595
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
3596
+ , func_(func)
3597
+ , handler_(handler ? handler : new Default_Exception_Handler)
3598
+ , arguments_(arguments)
3599
+ {
3600
+ }
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
+
3609
+ template<typename Func_T, typename Ret_T>
3610
+ VALUE Auto_Function_Wrapper<Func_T, Ret_T>::
3611
+ call()
3612
+ {
3613
+ Auto_Function_Wrapper<Func_T, Ret_T> * wrapper = 0;
3614
+ try
3615
+ {
3616
+ Data_Object<Wrapped_Function> data(detail::method_data());
3617
+ wrapper = (Auto_Function_Wrapper<Func_T, Ret_T>*)data.get();
3618
+
3619
+ return to_ruby(wrapper->func_());
3620
+ }
3621
+ catch(...)
3622
+ {
3623
+ RUBY_TRY
3624
+ {
3625
+ if(wrapper)
3626
+ {
3627
+ return wrapper->handler_->handle_exception();
3628
+ }
3629
+ else
3630
+ {
3631
+ throw;
3632
+ }
3633
+ }
3634
+ RUBY_CATCH
3635
+ }
3636
+ }
3637
+
3638
+ template<typename Func_T>
3639
+ Auto_Function_Wrapper<Func_T, void>::
3640
+ Auto_Function_Wrapper(
3641
+ Func func,
3642
+ Data_Object<Exception_Handler> handler,
3643
+ Arguments* arguments)
3644
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
3645
+ , func_(func)
3646
+ , handler_(handler ? handler : new Default_Exception_Handler)
3647
+ , arguments_(arguments)
3648
+ {
3649
+ }
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
+
3658
+ template<typename Func_T>
3659
+ VALUE Auto_Function_Wrapper<Func_T, void>::
3660
+ call()
3661
+ {
3662
+ Auto_Function_Wrapper<Func_T, void> * wrapper = 0;
3663
+ try
3664
+ {
3665
+ Data_Object<Wrapped_Function> data(detail::method_data());
3666
+ wrapper = (Auto_Function_Wrapper<Func_T, void> *)data.get();
3667
+
3668
+ wrapper->func_();
3669
+ return Qnil;
3670
+ }
3671
+ catch(...)
3672
+ {
3673
+ RUBY_TRY
3674
+ {
3675
+ if(wrapper)
3676
+ {
3677
+ return wrapper->handler_->handle_exception();
3678
+ }
3679
+ else
3680
+ {
3681
+ throw;
3682
+ }
3683
+ }
3684
+ RUBY_CATCH
3685
+ }
3686
+ }
3687
+
3688
+ } // namespace detail
3689
+
3690
+ } // namespace Rice
3691
+
3692
+
3693
+ #endif // Rice__detail__Auto_Function_Wrapper__ipp_
3694
+