jameskilton-rice 1.2.0

Sign up to get free protection for your applications and to get access to all the features.
Files changed (196) hide show
  1. data/COPYING +23 -0
  2. data/Doxyfile +1253 -0
  3. data/Makefile.am +26 -0
  4. data/Makefile.in +749 -0
  5. data/README +879 -0
  6. data/README.mingw +8 -0
  7. data/Rakefile +72 -0
  8. data/aclocal.m4 +891 -0
  9. data/bootstrap +8 -0
  10. data/config.guess +1526 -0
  11. data/config.sub +1658 -0
  12. data/configure +7668 -0
  13. data/configure.ac +52 -0
  14. data/depcomp +589 -0
  15. data/doxygen.ac +314 -0
  16. data/doxygen.am +186 -0
  17. data/extconf.rb +22 -0
  18. data/install-sh +519 -0
  19. data/missing +367 -0
  20. data/post-autoconf.rb +22 -0
  21. data/post-automake.rb +28 -0
  22. data/rice/Address_Registration_Guard.hpp +7 -0
  23. data/rice/Address_Registration_Guard.ipp +34 -0
  24. data/rice/Address_Registration_Guard_defn.hpp +65 -0
  25. data/rice/Allocation_Strategies.hpp +37 -0
  26. data/rice/Arg.hpp +8 -0
  27. data/rice/Arg_impl.hpp +116 -0
  28. data/rice/Arg_operators.cpp +21 -0
  29. data/rice/Arg_operators.hpp +18 -0
  30. data/rice/Array.hpp +220 -0
  31. data/rice/Array.ipp +263 -0
  32. data/rice/Builtin_Object.hpp +8 -0
  33. data/rice/Builtin_Object.ipp +50 -0
  34. data/rice/Builtin_Object_defn.hpp +51 -0
  35. data/rice/Class.cpp +57 -0
  36. data/rice/Class.hpp +8 -0
  37. data/rice/Class.ipp +6 -0
  38. data/rice/Class_defn.hpp +83 -0
  39. data/rice/Constructor.hpp +339 -0
  40. data/rice/Critical_Guard.hpp +40 -0
  41. data/rice/Critical_Guard.ipp +26 -0
  42. data/rice/Data_Object.hpp +8 -0
  43. data/rice/Data_Object.ipp +133 -0
  44. data/rice/Data_Object_defn.hpp +132 -0
  45. data/rice/Data_Type.cpp +21 -0
  46. data/rice/Data_Type.hpp +8 -0
  47. data/rice/Data_Type.ipp +306 -0
  48. data/rice/Data_Type_defn.hpp +219 -0
  49. data/rice/Data_Type_fwd.hpp +12 -0
  50. data/rice/Director.cpp +19 -0
  51. data/rice/Director.hpp +47 -0
  52. data/rice/Enum.hpp +118 -0
  53. data/rice/Enum.ipp +246 -0
  54. data/rice/Exception.cpp +59 -0
  55. data/rice/Exception.hpp +9 -0
  56. data/rice/Exception_Base.hpp +8 -0
  57. data/rice/Exception_Base.ipp +13 -0
  58. data/rice/Exception_Base_defn.hpp +27 -0
  59. data/rice/Exception_defn.hpp +69 -0
  60. data/rice/Hash.hpp +210 -0
  61. data/rice/Hash.ipp +338 -0
  62. data/rice/Identifier.cpp +8 -0
  63. data/rice/Identifier.hpp +50 -0
  64. data/rice/Identifier.ipp +33 -0
  65. data/rice/Jump_Tag.hpp +24 -0
  66. data/rice/Makefile.am +140 -0
  67. data/rice/Makefile.in +740 -0
  68. data/rice/Module.cpp +84 -0
  69. data/rice/Module.hpp +8 -0
  70. data/rice/Module.ipp +6 -0
  71. data/rice/Module_defn.hpp +88 -0
  72. data/rice/Module_impl.hpp +281 -0
  73. data/rice/Module_impl.ipp +348 -0
  74. data/rice/Object.cpp +153 -0
  75. data/rice/Object.hpp +8 -0
  76. data/rice/Object.ipp +19 -0
  77. data/rice/Object_defn.hpp +183 -0
  78. data/rice/Require_Guard.hpp +21 -0
  79. data/rice/String.cpp +94 -0
  80. data/rice/String.hpp +89 -0
  81. data/rice/Struct.cpp +117 -0
  82. data/rice/Struct.hpp +162 -0
  83. data/rice/Struct.ipp +26 -0
  84. data/rice/Symbol.cpp +25 -0
  85. data/rice/Symbol.hpp +66 -0
  86. data/rice/Symbol.ipp +44 -0
  87. data/rice/VM.cpp +92 -0
  88. data/rice/VM.hpp +32 -0
  89. data/rice/config.hpp +44 -0
  90. data/rice/config.hpp.in +43 -0
  91. data/rice/detail/Arguments.hpp +126 -0
  92. data/rice/detail/Auto_Function_Wrapper.hpp +861 -0
  93. data/rice/detail/Auto_Function_Wrapper.ipp +2929 -0
  94. data/rice/detail/Auto_Member_Function_Wrapper.hpp +828 -0
  95. data/rice/detail/Auto_Member_Function_Wrapper.ipp +2326 -0
  96. data/rice/detail/Caster.hpp +63 -0
  97. data/rice/detail/Exception_Handler.hpp +8 -0
  98. data/rice/detail/Exception_Handler.ipp +68 -0
  99. data/rice/detail/Exception_Handler_defn.hpp +96 -0
  100. data/rice/detail/Iterator.hpp +93 -0
  101. data/rice/detail/Not_Copyable.hpp +25 -0
  102. data/rice/detail/Wrapped_Function.hpp +33 -0
  103. data/rice/detail/check_ruby_type.cpp +27 -0
  104. data/rice/detail/check_ruby_type.hpp +23 -0
  105. data/rice/detail/creation_funcs.hpp +37 -0
  106. data/rice/detail/creation_funcs.ipp +36 -0
  107. data/rice/detail/default_allocation_func.hpp +23 -0
  108. data/rice/detail/default_allocation_func.ipp +11 -0
  109. data/rice/detail/define_method_and_auto_wrap.hpp +31 -0
  110. data/rice/detail/define_method_and_auto_wrap.ipp +30 -0
  111. data/rice/detail/demangle.cpp +56 -0
  112. data/rice/detail/demangle.hpp +19 -0
  113. data/rice/detail/env.hpp +19 -0
  114. data/rice/detail/from_ruby.hpp +43 -0
  115. data/rice/detail/from_ruby.ipp +60 -0
  116. data/rice/detail/method_data.cpp +392 -0
  117. data/rice/detail/method_data.cpp.rpp +301 -0
  118. data/rice/detail/method_data.hpp +21 -0
  119. data/rice/detail/mininode.cpp +1220 -0
  120. data/rice/detail/mininode.cpp.rpp +62 -0
  121. data/rice/detail/mininode.hpp +320 -0
  122. data/rice/detail/mininode.hpp.rpp +119 -0
  123. data/rice/detail/node.hpp +13 -0
  124. data/rice/detail/object_call.hpp +85 -0
  125. data/rice/detail/object_call.ipp +147 -0
  126. data/rice/detail/protect.cpp +29 -0
  127. data/rice/detail/protect.hpp +34 -0
  128. data/rice/detail/remove_const.hpp +21 -0
  129. data/rice/detail/ruby.hpp +89 -0
  130. data/rice/detail/ruby_version_code.hpp +6 -0
  131. data/rice/detail/ruby_version_code.hpp.in +6 -0
  132. data/rice/detail/rubysig.hpp +19 -0
  133. data/rice/detail/st.hpp +60 -0
  134. data/rice/detail/to_ruby.hpp +22 -0
  135. data/rice/detail/to_ruby.ipp +37 -0
  136. data/rice/detail/win32.hpp +16 -0
  137. data/rice/detail/wrap_function.hpp +345 -0
  138. data/rice/detail/wrap_function.ipp +531 -0
  139. data/rice/generate_code.rb +1311 -0
  140. data/rice/global_function.hpp +33 -0
  141. data/rice/global_function.ipp +22 -0
  142. data/rice/protect.hpp +91 -0
  143. data/rice/protect.ipp +803 -0
  144. data/rice/ruby_mark.hpp +13 -0
  145. data/rice/ruby_try_catch.hpp +86 -0
  146. data/rice/rubypp.rb +97 -0
  147. data/rice/to_from_ruby.hpp +8 -0
  148. data/rice/to_from_ruby.ipp +299 -0
  149. data/rice/to_from_ruby_defn.hpp +71 -0
  150. data/ruby.ac +150 -0
  151. data/ruby/Makefile.am +1 -0
  152. data/ruby/Makefile.in +497 -0
  153. data/ruby/lib/Makefile.am +3 -0
  154. data/ruby/lib/Makefile.in +374 -0
  155. data/ruby/lib/mkmf-rice.rb.in +209 -0
  156. data/ruby/lib/version.rb +3 -0
  157. data/sample/Makefile.am +47 -0
  158. data/sample/Makefile.in +380 -0
  159. data/sample/enum/extconf.rb +3 -0
  160. data/sample/enum/sample_enum.cpp +54 -0
  161. data/sample/enum/test.rb +8 -0
  162. data/sample/inheritance/animals.cpp +98 -0
  163. data/sample/inheritance/extconf.rb +3 -0
  164. data/sample/inheritance/test.rb +7 -0
  165. data/sample/map/extconf.rb +3 -0
  166. data/sample/map/map.cpp +81 -0
  167. data/sample/map/test.rb +7 -0
  168. data/test/Makefile.am +49 -0
  169. data/test/Makefile.in +603 -0
  170. data/test/test_Address_Registration_Guard.cpp +43 -0
  171. data/test/test_Allocation_Strategies.cpp +77 -0
  172. data/test/test_Array.cpp +241 -0
  173. data/test/test_Builtin_Object.cpp +72 -0
  174. data/test/test_Class.cpp +398 -0
  175. data/test/test_Constructor.cpp +238 -0
  176. data/test/test_Critical_Guard.cpp +51 -0
  177. data/test/test_Data_Object.cpp +275 -0
  178. data/test/test_Data_Type.cpp +121 -0
  179. data/test/test_Director.cpp +225 -0
  180. data/test/test_Enum.cpp +162 -0
  181. data/test/test_Exception.cpp +46 -0
  182. data/test/test_Hash.cpp +195 -0
  183. data/test/test_Identifier.cpp +70 -0
  184. data/test/test_Jump_Tag.cpp +17 -0
  185. data/test/test_Module.cpp +428 -0
  186. data/test/test_Object.cpp +148 -0
  187. data/test/test_String.cpp +94 -0
  188. data/test/test_Struct.cpp +192 -0
  189. data/test/test_Symbol.cpp +63 -0
  190. data/test/test_To_From_Ruby.cpp +263 -0
  191. data/test/test_VM.cpp +26 -0
  192. data/test/test_global_functions.cpp +97 -0
  193. data/test/test_rice.rb +35 -0
  194. data/test/unittest.cpp +136 -0
  195. data/test/unittest.hpp +292 -0
  196. metadata +247 -0
data/rice/detail/Auto_Member_Function_Wrapper.ipp ADDED
@@ -0,0 +1,2326 @@
1
+ #ifndef Rice__detail__Auto_Member_Function_Wrapper__ipp_
2
+ #define Rice__detail__Auto_Member_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 <typeinfo>
14
+ namespace Rice
15
+ {
16
+
17
+ namespace detail
18
+ {
19
+
20
+ template<typename Func_T, typename Ret_T, typename Self_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_Member_Function_Wrapper<Func_T, Ret_T, Self_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_Member_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
+ , arguments_(arguments)
31
+ {
32
+ if(arguments == 0) {
33
+ arguments_ = new Arguments();
34
+ } else {
35
+ arguments_ = arguments;
36
+ }
37
+ }
38
+
39
+ template<typename Func_T, typename Ret_T, typename Self_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>
40
+ VALUE Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_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>::
41
+ call(int argc, VALUE* argv, VALUE self)
42
+ {
43
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_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;
44
+ try
45
+ {
46
+ Data_Object<Wrapped_Function> data(detail::method_data());
47
+ wrapper =
48
+ (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_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();
49
+ Arguments* args = wrapper->arguments_;
50
+
51
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12, varg13, varg14, varg15;
52
+ Arg0_T arg0;Arg1_T arg1;Arg2_T arg2;Arg3_T arg3;Arg4_T arg4;Arg5_T arg5;Arg6_T arg6;Arg7_T arg7;Arg8_T arg8;Arg9_T arg9;Arg10_T arg10;Arg11_T arg11;Arg12_T arg12;Arg13_T arg13;Arg14_T arg14;Arg15_T arg15;
53
+
54
+ rb_scan_args(argc, argv, args->formatString(Num_Args),
55
+ &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14, &varg15);
56
+
57
+ Self_T * obj = from_ruby<Self_T *>(self);
58
+ if(args->isOptional(0) && NIL_P(varg0)) { arg0 = args->get(0)->getDefaultValue<Arg0_T>(); } else { arg0 = from_ruby<Arg0_T>(varg0); }
59
+ if(args->isOptional(1) && NIL_P(varg1)) { arg1 = args->get(1)->getDefaultValue<Arg1_T>(); } else { arg1 = from_ruby<Arg1_T>(varg1); }
60
+ if(args->isOptional(2) && NIL_P(varg2)) { arg2 = args->get(2)->getDefaultValue<Arg2_T>(); } else { arg2 = from_ruby<Arg2_T>(varg2); }
61
+ if(args->isOptional(3) && NIL_P(varg3)) { arg3 = args->get(3)->getDefaultValue<Arg3_T>(); } else { arg3 = from_ruby<Arg3_T>(varg3); }
62
+ if(args->isOptional(4) && NIL_P(varg4)) { arg4 = args->get(4)->getDefaultValue<Arg4_T>(); } else { arg4 = from_ruby<Arg4_T>(varg4); }
63
+ if(args->isOptional(5) && NIL_P(varg5)) { arg5 = args->get(5)->getDefaultValue<Arg5_T>(); } else { arg5 = from_ruby<Arg5_T>(varg5); }
64
+ if(args->isOptional(6) && NIL_P(varg6)) { arg6 = args->get(6)->getDefaultValue<Arg6_T>(); } else { arg6 = from_ruby<Arg6_T>(varg6); }
65
+ if(args->isOptional(7) && NIL_P(varg7)) { arg7 = args->get(7)->getDefaultValue<Arg7_T>(); } else { arg7 = from_ruby<Arg7_T>(varg7); }
66
+ if(args->isOptional(8) && NIL_P(varg8)) { arg8 = args->get(8)->getDefaultValue<Arg8_T>(); } else { arg8 = from_ruby<Arg8_T>(varg8); }
67
+ if(args->isOptional(9) && NIL_P(varg9)) { arg9 = args->get(9)->getDefaultValue<Arg9_T>(); } else { arg9 = from_ruby<Arg9_T>(varg9); }
68
+ if(args->isOptional(10) && NIL_P(varg10)) { arg10 = args->get(10)->getDefaultValue<Arg10_T>(); } else { arg10 = from_ruby<Arg10_T>(varg10); }
69
+ if(args->isOptional(11) && NIL_P(varg11)) { arg11 = args->get(11)->getDefaultValue<Arg11_T>(); } else { arg11 = from_ruby<Arg11_T>(varg11); }
70
+ if(args->isOptional(12) && NIL_P(varg12)) { arg12 = args->get(12)->getDefaultValue<Arg12_T>(); } else { arg12 = from_ruby<Arg12_T>(varg12); }
71
+ if(args->isOptional(13) && NIL_P(varg13)) { arg13 = args->get(13)->getDefaultValue<Arg13_T>(); } else { arg13 = from_ruby<Arg13_T>(varg13); }
72
+ if(args->isOptional(14) && NIL_P(varg14)) { arg14 = args->get(14)->getDefaultValue<Arg14_T>(); } else { arg14 = from_ruby<Arg14_T>(varg14); }
73
+ if(args->isOptional(15) && NIL_P(varg15)) { arg15 = args->get(15)->getDefaultValue<Arg15_T>(); } else { arg15 = from_ruby<Arg15_T>(varg15); }
74
+
75
+ Func func = wrapper->func_;
76
+ return to_ruby((*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15));
77
+ }
78
+ catch(...)
79
+ {
80
+ RUBY_TRY
81
+ {
82
+ if(wrapper)
83
+ {
84
+ return wrapper->handler_->handle_exception();
85
+ }
86
+ else
87
+ {
88
+ throw;
89
+ }
90
+ }
91
+ RUBY_CATCH
92
+ }
93
+ }
94
+
95
+ template<typename Func_T, typename Self_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>
96
+ Auto_Member_Function_Wrapper<Func_T, void, Self_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>::
97
+ Auto_Member_Function_Wrapper(
98
+ Func func,
99
+ Data_Object<Exception_Handler> handler,
100
+ Arguments* arguments)
101
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
102
+ , func_(func)
103
+ , handler_(handler)
104
+ , handler_guard_(&handler_)
105
+ , arguments_(arguments)
106
+ {
107
+ if(arguments == 0) {
108
+ arguments_ = new Arguments();
109
+ } else {
110
+ arguments_ = arguments;
111
+ }
112
+ }
113
+
114
+ template<typename Func_T, typename Self_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>
115
+ VALUE Auto_Member_Function_Wrapper<Func_T, void, Self_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>::
116
+ call(int argc, VALUE* argv, VALUE self)
117
+ {
118
+ Auto_Member_Function_Wrapper<Func_T, void, Self_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;
119
+ try
120
+ {
121
+ Data_Object<Wrapped_Function> data(detail::method_data());
122
+ wrapper =
123
+ (Auto_Member_Function_Wrapper<Func_T, void, Self_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();
124
+ Arguments* args = wrapper->arguments_;
125
+
126
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12, varg13, varg14, varg15;
127
+ Arg0_T arg0;Arg1_T arg1;Arg2_T arg2;Arg3_T arg3;Arg4_T arg4;Arg5_T arg5;Arg6_T arg6;Arg7_T arg7;Arg8_T arg8;Arg9_T arg9;Arg10_T arg10;Arg11_T arg11;Arg12_T arg12;Arg13_T arg13;Arg14_T arg14;Arg15_T arg15;
128
+
129
+ rb_scan_args(argc, argv, args->formatString(Num_Args),
130
+ &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14, &varg15);
131
+
132
+ Self_T * obj = from_ruby<Self_T *>(self);
133
+ if(args->isOptional(0) && NIL_P(varg0)) { arg0 = args->get(0)->getDefaultValue<Arg0_T>(); } else { arg0 = from_ruby<Arg0_T>(varg0); }
134
+ if(args->isOptional(1) && NIL_P(varg1)) { arg1 = args->get(1)->getDefaultValue<Arg1_T>(); } else { arg1 = from_ruby<Arg1_T>(varg1); }
135
+ if(args->isOptional(2) && NIL_P(varg2)) { arg2 = args->get(2)->getDefaultValue<Arg2_T>(); } else { arg2 = from_ruby<Arg2_T>(varg2); }
136
+ if(args->isOptional(3) && NIL_P(varg3)) { arg3 = args->get(3)->getDefaultValue<Arg3_T>(); } else { arg3 = from_ruby<Arg3_T>(varg3); }
137
+ if(args->isOptional(4) && NIL_P(varg4)) { arg4 = args->get(4)->getDefaultValue<Arg4_T>(); } else { arg4 = from_ruby<Arg4_T>(varg4); }
138
+ if(args->isOptional(5) && NIL_P(varg5)) { arg5 = args->get(5)->getDefaultValue<Arg5_T>(); } else { arg5 = from_ruby<Arg5_T>(varg5); }
139
+ if(args->isOptional(6) && NIL_P(varg6)) { arg6 = args->get(6)->getDefaultValue<Arg6_T>(); } else { arg6 = from_ruby<Arg6_T>(varg6); }
140
+ if(args->isOptional(7) && NIL_P(varg7)) { arg7 = args->get(7)->getDefaultValue<Arg7_T>(); } else { arg7 = from_ruby<Arg7_T>(varg7); }
141
+ if(args->isOptional(8) && NIL_P(varg8)) { arg8 = args->get(8)->getDefaultValue<Arg8_T>(); } else { arg8 = from_ruby<Arg8_T>(varg8); }
142
+ if(args->isOptional(9) && NIL_P(varg9)) { arg9 = args->get(9)->getDefaultValue<Arg9_T>(); } else { arg9 = from_ruby<Arg9_T>(varg9); }
143
+ if(args->isOptional(10) && NIL_P(varg10)) { arg10 = args->get(10)->getDefaultValue<Arg10_T>(); } else { arg10 = from_ruby<Arg10_T>(varg10); }
144
+ if(args->isOptional(11) && NIL_P(varg11)) { arg11 = args->get(11)->getDefaultValue<Arg11_T>(); } else { arg11 = from_ruby<Arg11_T>(varg11); }
145
+ if(args->isOptional(12) && NIL_P(varg12)) { arg12 = args->get(12)->getDefaultValue<Arg12_T>(); } else { arg12 = from_ruby<Arg12_T>(varg12); }
146
+ if(args->isOptional(13) && NIL_P(varg13)) { arg13 = args->get(13)->getDefaultValue<Arg13_T>(); } else { arg13 = from_ruby<Arg13_T>(varg13); }
147
+ if(args->isOptional(14) && NIL_P(varg14)) { arg14 = args->get(14)->getDefaultValue<Arg14_T>(); } else { arg14 = from_ruby<Arg14_T>(varg14); }
148
+ if(args->isOptional(15) && NIL_P(varg15)) { arg15 = args->get(15)->getDefaultValue<Arg15_T>(); } else { arg15 = from_ruby<Arg15_T>(varg15); }
149
+
150
+ Func func = wrapper->func_;
151
+ (*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15);
152
+ return Qnil;
153
+ }
154
+ catch(...)
155
+ {
156
+ RUBY_TRY
157
+ {
158
+ if(wrapper)
159
+ {
160
+ return wrapper->handler_->handle_exception();
161
+ }
162
+ else
163
+ {
164
+ throw;
165
+ }
166
+ }
167
+ RUBY_CATCH
168
+ }
169
+ }
170
+
171
+ // ---------------------------------------------------------------------
172
+ template<typename Func_T, typename Ret_T, typename Self_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>
173
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_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>::
174
+ Auto_Member_Function_Wrapper(
175
+ Func func,
176
+ Data_Object<Exception_Handler> handler,
177
+ Arguments* arguments)
178
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
179
+ , func_(func)
180
+ , handler_(handler)
181
+ , handler_guard_(&handler_)
182
+ , arguments_(arguments)
183
+ {
184
+ if(arguments == 0) {
185
+ arguments_ = new Arguments();
186
+ } else {
187
+ arguments_ = arguments;
188
+ }
189
+ }
190
+
191
+ template<typename Func_T, typename Ret_T, typename Self_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>
192
+ VALUE Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_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>::
193
+ call(int argc, VALUE* argv, VALUE self)
194
+ {
195
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_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;
196
+ try
197
+ {
198
+ Data_Object<Wrapped_Function> data(detail::method_data());
199
+ wrapper =
200
+ (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_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();
201
+ Arguments* args = wrapper->arguments_;
202
+
203
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12, varg13, varg14;
204
+ Arg0_T arg0;Arg1_T arg1;Arg2_T arg2;Arg3_T arg3;Arg4_T arg4;Arg5_T arg5;Arg6_T arg6;Arg7_T arg7;Arg8_T arg8;Arg9_T arg9;Arg10_T arg10;Arg11_T arg11;Arg12_T arg12;Arg13_T arg13;Arg14_T arg14;
205
+
206
+ rb_scan_args(argc, argv, args->formatString(Num_Args),
207
+ &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14);
208
+
209
+ Self_T * obj = from_ruby<Self_T *>(self);
210
+ if(args->isOptional(0) && NIL_P(varg0)) { arg0 = args->get(0)->getDefaultValue<Arg0_T>(); } else { arg0 = from_ruby<Arg0_T>(varg0); }
211
+ if(args->isOptional(1) && NIL_P(varg1)) { arg1 = args->get(1)->getDefaultValue<Arg1_T>(); } else { arg1 = from_ruby<Arg1_T>(varg1); }
212
+ if(args->isOptional(2) && NIL_P(varg2)) { arg2 = args->get(2)->getDefaultValue<Arg2_T>(); } else { arg2 = from_ruby<Arg2_T>(varg2); }
213
+ if(args->isOptional(3) && NIL_P(varg3)) { arg3 = args->get(3)->getDefaultValue<Arg3_T>(); } else { arg3 = from_ruby<Arg3_T>(varg3); }
214
+ if(args->isOptional(4) && NIL_P(varg4)) { arg4 = args->get(4)->getDefaultValue<Arg4_T>(); } else { arg4 = from_ruby<Arg4_T>(varg4); }
215
+ if(args->isOptional(5) && NIL_P(varg5)) { arg5 = args->get(5)->getDefaultValue<Arg5_T>(); } else { arg5 = from_ruby<Arg5_T>(varg5); }
216
+ if(args->isOptional(6) && NIL_P(varg6)) { arg6 = args->get(6)->getDefaultValue<Arg6_T>(); } else { arg6 = from_ruby<Arg6_T>(varg6); }
217
+ if(args->isOptional(7) && NIL_P(varg7)) { arg7 = args->get(7)->getDefaultValue<Arg7_T>(); } else { arg7 = from_ruby<Arg7_T>(varg7); }
218
+ if(args->isOptional(8) && NIL_P(varg8)) { arg8 = args->get(8)->getDefaultValue<Arg8_T>(); } else { arg8 = from_ruby<Arg8_T>(varg8); }
219
+ if(args->isOptional(9) && NIL_P(varg9)) { arg9 = args->get(9)->getDefaultValue<Arg9_T>(); } else { arg9 = from_ruby<Arg9_T>(varg9); }
220
+ if(args->isOptional(10) && NIL_P(varg10)) { arg10 = args->get(10)->getDefaultValue<Arg10_T>(); } else { arg10 = from_ruby<Arg10_T>(varg10); }
221
+ if(args->isOptional(11) && NIL_P(varg11)) { arg11 = args->get(11)->getDefaultValue<Arg11_T>(); } else { arg11 = from_ruby<Arg11_T>(varg11); }
222
+ if(args->isOptional(12) && NIL_P(varg12)) { arg12 = args->get(12)->getDefaultValue<Arg12_T>(); } else { arg12 = from_ruby<Arg12_T>(varg12); }
223
+ if(args->isOptional(13) && NIL_P(varg13)) { arg13 = args->get(13)->getDefaultValue<Arg13_T>(); } else { arg13 = from_ruby<Arg13_T>(varg13); }
224
+ if(args->isOptional(14) && NIL_P(varg14)) { arg14 = args->get(14)->getDefaultValue<Arg14_T>(); } else { arg14 = from_ruby<Arg14_T>(varg14); }
225
+
226
+ Func func = wrapper->func_;
227
+ return to_ruby((*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14));
228
+ }
229
+ catch(...)
230
+ {
231
+ RUBY_TRY
232
+ {
233
+ if(wrapper)
234
+ {
235
+ return wrapper->handler_->handle_exception();
236
+ }
237
+ else
238
+ {
239
+ throw;
240
+ }
241
+ }
242
+ RUBY_CATCH
243
+ }
244
+ }
245
+
246
+ template<typename Func_T, typename Self_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>
247
+ Auto_Member_Function_Wrapper<Func_T, void, Self_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>::
248
+ Auto_Member_Function_Wrapper(
249
+ Func func,
250
+ Data_Object<Exception_Handler> handler,
251
+ Arguments* arguments)
252
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
253
+ , func_(func)
254
+ , handler_(handler)
255
+ , handler_guard_(&handler_)
256
+ , arguments_(arguments)
257
+ {
258
+ if(arguments == 0) {
259
+ arguments_ = new Arguments();
260
+ } else {
261
+ arguments_ = arguments;
262
+ }
263
+ }
264
+
265
+ template<typename Func_T, typename Self_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>
266
+ VALUE Auto_Member_Function_Wrapper<Func_T, void, Self_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>::
267
+ call(int argc, VALUE* argv, VALUE self)
268
+ {
269
+ Auto_Member_Function_Wrapper<Func_T, void, Self_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;
270
+ try
271
+ {
272
+ Data_Object<Wrapped_Function> data(detail::method_data());
273
+ wrapper =
274
+ (Auto_Member_Function_Wrapper<Func_T, void, Self_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();
275
+ Arguments* args = wrapper->arguments_;
276
+
277
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12, varg13, varg14;
278
+ Arg0_T arg0;Arg1_T arg1;Arg2_T arg2;Arg3_T arg3;Arg4_T arg4;Arg5_T arg5;Arg6_T arg6;Arg7_T arg7;Arg8_T arg8;Arg9_T arg9;Arg10_T arg10;Arg11_T arg11;Arg12_T arg12;Arg13_T arg13;Arg14_T arg14;
279
+
280
+ rb_scan_args(argc, argv, args->formatString(Num_Args),
281
+ &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14);
282
+
283
+ Self_T * obj = from_ruby<Self_T *>(self);
284
+ if(args->isOptional(0) && NIL_P(varg0)) { arg0 = args->get(0)->getDefaultValue<Arg0_T>(); } else { arg0 = from_ruby<Arg0_T>(varg0); }
285
+ if(args->isOptional(1) && NIL_P(varg1)) { arg1 = args->get(1)->getDefaultValue<Arg1_T>(); } else { arg1 = from_ruby<Arg1_T>(varg1); }
286
+ if(args->isOptional(2) && NIL_P(varg2)) { arg2 = args->get(2)->getDefaultValue<Arg2_T>(); } else { arg2 = from_ruby<Arg2_T>(varg2); }
287
+ if(args->isOptional(3) && NIL_P(varg3)) { arg3 = args->get(3)->getDefaultValue<Arg3_T>(); } else { arg3 = from_ruby<Arg3_T>(varg3); }
288
+ if(args->isOptional(4) && NIL_P(varg4)) { arg4 = args->get(4)->getDefaultValue<Arg4_T>(); } else { arg4 = from_ruby<Arg4_T>(varg4); }
289
+ if(args->isOptional(5) && NIL_P(varg5)) { arg5 = args->get(5)->getDefaultValue<Arg5_T>(); } else { arg5 = from_ruby<Arg5_T>(varg5); }
290
+ if(args->isOptional(6) && NIL_P(varg6)) { arg6 = args->get(6)->getDefaultValue<Arg6_T>(); } else { arg6 = from_ruby<Arg6_T>(varg6); }
291
+ if(args->isOptional(7) && NIL_P(varg7)) { arg7 = args->get(7)->getDefaultValue<Arg7_T>(); } else { arg7 = from_ruby<Arg7_T>(varg7); }
292
+ if(args->isOptional(8) && NIL_P(varg8)) { arg8 = args->get(8)->getDefaultValue<Arg8_T>(); } else { arg8 = from_ruby<Arg8_T>(varg8); }
293
+ if(args->isOptional(9) && NIL_P(varg9)) { arg9 = args->get(9)->getDefaultValue<Arg9_T>(); } else { arg9 = from_ruby<Arg9_T>(varg9); }
294
+ if(args->isOptional(10) && NIL_P(varg10)) { arg10 = args->get(10)->getDefaultValue<Arg10_T>(); } else { arg10 = from_ruby<Arg10_T>(varg10); }
295
+ if(args->isOptional(11) && NIL_P(varg11)) { arg11 = args->get(11)->getDefaultValue<Arg11_T>(); } else { arg11 = from_ruby<Arg11_T>(varg11); }
296
+ if(args->isOptional(12) && NIL_P(varg12)) { arg12 = args->get(12)->getDefaultValue<Arg12_T>(); } else { arg12 = from_ruby<Arg12_T>(varg12); }
297
+ if(args->isOptional(13) && NIL_P(varg13)) { arg13 = args->get(13)->getDefaultValue<Arg13_T>(); } else { arg13 = from_ruby<Arg13_T>(varg13); }
298
+ if(args->isOptional(14) && NIL_P(varg14)) { arg14 = args->get(14)->getDefaultValue<Arg14_T>(); } else { arg14 = from_ruby<Arg14_T>(varg14); }
299
+
300
+ Func func = wrapper->func_;
301
+ (*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
302
+ return Qnil;
303
+ }
304
+ catch(...)
305
+ {
306
+ RUBY_TRY
307
+ {
308
+ if(wrapper)
309
+ {
310
+ return wrapper->handler_->handle_exception();
311
+ }
312
+ else
313
+ {
314
+ throw;
315
+ }
316
+ }
317
+ RUBY_CATCH
318
+ }
319
+ }
320
+
321
+ // ---------------------------------------------------------------------
322
+ template<typename Func_T, typename Ret_T, typename Self_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>
323
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_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>::
324
+ Auto_Member_Function_Wrapper(
325
+ Func func,
326
+ Data_Object<Exception_Handler> handler,
327
+ Arguments* arguments)
328
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
329
+ , func_(func)
330
+ , handler_(handler)
331
+ , handler_guard_(&handler_)
332
+ , arguments_(arguments)
333
+ {
334
+ if(arguments == 0) {
335
+ arguments_ = new Arguments();
336
+ } else {
337
+ arguments_ = arguments;
338
+ }
339
+ }
340
+
341
+ template<typename Func_T, typename Ret_T, typename Self_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>
342
+ VALUE Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_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>::
343
+ call(int argc, VALUE* argv, VALUE self)
344
+ {
345
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_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;
346
+ try
347
+ {
348
+ Data_Object<Wrapped_Function> data(detail::method_data());
349
+ wrapper =
350
+ (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_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();
351
+ Arguments* args = wrapper->arguments_;
352
+
353
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12, varg13;
354
+ Arg0_T arg0;Arg1_T arg1;Arg2_T arg2;Arg3_T arg3;Arg4_T arg4;Arg5_T arg5;Arg6_T arg6;Arg7_T arg7;Arg8_T arg8;Arg9_T arg9;Arg10_T arg10;Arg11_T arg11;Arg12_T arg12;Arg13_T arg13;
355
+
356
+ rb_scan_args(argc, argv, args->formatString(Num_Args),
357
+ &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13);
358
+
359
+ Self_T * obj = from_ruby<Self_T *>(self);
360
+ if(args->isOptional(0) && NIL_P(varg0)) { arg0 = args->get(0)->getDefaultValue<Arg0_T>(); } else { arg0 = from_ruby<Arg0_T>(varg0); }
361
+ if(args->isOptional(1) && NIL_P(varg1)) { arg1 = args->get(1)->getDefaultValue<Arg1_T>(); } else { arg1 = from_ruby<Arg1_T>(varg1); }
362
+ if(args->isOptional(2) && NIL_P(varg2)) { arg2 = args->get(2)->getDefaultValue<Arg2_T>(); } else { arg2 = from_ruby<Arg2_T>(varg2); }
363
+ if(args->isOptional(3) && NIL_P(varg3)) { arg3 = args->get(3)->getDefaultValue<Arg3_T>(); } else { arg3 = from_ruby<Arg3_T>(varg3); }
364
+ if(args->isOptional(4) && NIL_P(varg4)) { arg4 = args->get(4)->getDefaultValue<Arg4_T>(); } else { arg4 = from_ruby<Arg4_T>(varg4); }
365
+ if(args->isOptional(5) && NIL_P(varg5)) { arg5 = args->get(5)->getDefaultValue<Arg5_T>(); } else { arg5 = from_ruby<Arg5_T>(varg5); }
366
+ if(args->isOptional(6) && NIL_P(varg6)) { arg6 = args->get(6)->getDefaultValue<Arg6_T>(); } else { arg6 = from_ruby<Arg6_T>(varg6); }
367
+ if(args->isOptional(7) && NIL_P(varg7)) { arg7 = args->get(7)->getDefaultValue<Arg7_T>(); } else { arg7 = from_ruby<Arg7_T>(varg7); }
368
+ if(args->isOptional(8) && NIL_P(varg8)) { arg8 = args->get(8)->getDefaultValue<Arg8_T>(); } else { arg8 = from_ruby<Arg8_T>(varg8); }
369
+ if(args->isOptional(9) && NIL_P(varg9)) { arg9 = args->get(9)->getDefaultValue<Arg9_T>(); } else { arg9 = from_ruby<Arg9_T>(varg9); }
370
+ if(args->isOptional(10) && NIL_P(varg10)) { arg10 = args->get(10)->getDefaultValue<Arg10_T>(); } else { arg10 = from_ruby<Arg10_T>(varg10); }
371
+ if(args->isOptional(11) && NIL_P(varg11)) { arg11 = args->get(11)->getDefaultValue<Arg11_T>(); } else { arg11 = from_ruby<Arg11_T>(varg11); }
372
+ if(args->isOptional(12) && NIL_P(varg12)) { arg12 = args->get(12)->getDefaultValue<Arg12_T>(); } else { arg12 = from_ruby<Arg12_T>(varg12); }
373
+ if(args->isOptional(13) && NIL_P(varg13)) { arg13 = args->get(13)->getDefaultValue<Arg13_T>(); } else { arg13 = from_ruby<Arg13_T>(varg13); }
374
+
375
+ Func func = wrapper->func_;
376
+ return to_ruby((*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13));
377
+ }
378
+ catch(...)
379
+ {
380
+ RUBY_TRY
381
+ {
382
+ if(wrapper)
383
+ {
384
+ return wrapper->handler_->handle_exception();
385
+ }
386
+ else
387
+ {
388
+ throw;
389
+ }
390
+ }
391
+ RUBY_CATCH
392
+ }
393
+ }
394
+
395
+ template<typename Func_T, typename Self_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>
396
+ Auto_Member_Function_Wrapper<Func_T, void, Self_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>::
397
+ Auto_Member_Function_Wrapper(
398
+ Func func,
399
+ Data_Object<Exception_Handler> handler,
400
+ Arguments* arguments)
401
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
402
+ , func_(func)
403
+ , handler_(handler)
404
+ , handler_guard_(&handler_)
405
+ , arguments_(arguments)
406
+ {
407
+ if(arguments == 0) {
408
+ arguments_ = new Arguments();
409
+ } else {
410
+ arguments_ = arguments;
411
+ }
412
+ }
413
+
414
+ template<typename Func_T, typename Self_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>
415
+ VALUE Auto_Member_Function_Wrapper<Func_T, void, Self_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>::
416
+ call(int argc, VALUE* argv, VALUE self)
417
+ {
418
+ Auto_Member_Function_Wrapper<Func_T, void, Self_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;
419
+ try
420
+ {
421
+ Data_Object<Wrapped_Function> data(detail::method_data());
422
+ wrapper =
423
+ (Auto_Member_Function_Wrapper<Func_T, void, Self_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();
424
+ Arguments* args = wrapper->arguments_;
425
+
426
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12, varg13;
427
+ Arg0_T arg0;Arg1_T arg1;Arg2_T arg2;Arg3_T arg3;Arg4_T arg4;Arg5_T arg5;Arg6_T arg6;Arg7_T arg7;Arg8_T arg8;Arg9_T arg9;Arg10_T arg10;Arg11_T arg11;Arg12_T arg12;Arg13_T arg13;
428
+
429
+ rb_scan_args(argc, argv, args->formatString(Num_Args),
430
+ &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13);
431
+
432
+ Self_T * obj = from_ruby<Self_T *>(self);
433
+ if(args->isOptional(0) && NIL_P(varg0)) { arg0 = args->get(0)->getDefaultValue<Arg0_T>(); } else { arg0 = from_ruby<Arg0_T>(varg0); }
434
+ if(args->isOptional(1) && NIL_P(varg1)) { arg1 = args->get(1)->getDefaultValue<Arg1_T>(); } else { arg1 = from_ruby<Arg1_T>(varg1); }
435
+ if(args->isOptional(2) && NIL_P(varg2)) { arg2 = args->get(2)->getDefaultValue<Arg2_T>(); } else { arg2 = from_ruby<Arg2_T>(varg2); }
436
+ if(args->isOptional(3) && NIL_P(varg3)) { arg3 = args->get(3)->getDefaultValue<Arg3_T>(); } else { arg3 = from_ruby<Arg3_T>(varg3); }
437
+ if(args->isOptional(4) && NIL_P(varg4)) { arg4 = args->get(4)->getDefaultValue<Arg4_T>(); } else { arg4 = from_ruby<Arg4_T>(varg4); }
438
+ if(args->isOptional(5) && NIL_P(varg5)) { arg5 = args->get(5)->getDefaultValue<Arg5_T>(); } else { arg5 = from_ruby<Arg5_T>(varg5); }
439
+ if(args->isOptional(6) && NIL_P(varg6)) { arg6 = args->get(6)->getDefaultValue<Arg6_T>(); } else { arg6 = from_ruby<Arg6_T>(varg6); }
440
+ if(args->isOptional(7) && NIL_P(varg7)) { arg7 = args->get(7)->getDefaultValue<Arg7_T>(); } else { arg7 = from_ruby<Arg7_T>(varg7); }
441
+ if(args->isOptional(8) && NIL_P(varg8)) { arg8 = args->get(8)->getDefaultValue<Arg8_T>(); } else { arg8 = from_ruby<Arg8_T>(varg8); }
442
+ if(args->isOptional(9) && NIL_P(varg9)) { arg9 = args->get(9)->getDefaultValue<Arg9_T>(); } else { arg9 = from_ruby<Arg9_T>(varg9); }
443
+ if(args->isOptional(10) && NIL_P(varg10)) { arg10 = args->get(10)->getDefaultValue<Arg10_T>(); } else { arg10 = from_ruby<Arg10_T>(varg10); }
444
+ if(args->isOptional(11) && NIL_P(varg11)) { arg11 = args->get(11)->getDefaultValue<Arg11_T>(); } else { arg11 = from_ruby<Arg11_T>(varg11); }
445
+ if(args->isOptional(12) && NIL_P(varg12)) { arg12 = args->get(12)->getDefaultValue<Arg12_T>(); } else { arg12 = from_ruby<Arg12_T>(varg12); }
446
+ if(args->isOptional(13) && NIL_P(varg13)) { arg13 = args->get(13)->getDefaultValue<Arg13_T>(); } else { arg13 = from_ruby<Arg13_T>(varg13); }
447
+
448
+ Func func = wrapper->func_;
449
+ (*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
450
+ return Qnil;
451
+ }
452
+ catch(...)
453
+ {
454
+ RUBY_TRY
455
+ {
456
+ if(wrapper)
457
+ {
458
+ return wrapper->handler_->handle_exception();
459
+ }
460
+ else
461
+ {
462
+ throw;
463
+ }
464
+ }
465
+ RUBY_CATCH
466
+ }
467
+ }
468
+
469
+ // ---------------------------------------------------------------------
470
+ template<typename Func_T, typename Ret_T, typename Self_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>
471
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_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>::
472
+ Auto_Member_Function_Wrapper(
473
+ Func func,
474
+ Data_Object<Exception_Handler> handler,
475
+ Arguments* arguments)
476
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
477
+ , func_(func)
478
+ , handler_(handler)
479
+ , handler_guard_(&handler_)
480
+ , arguments_(arguments)
481
+ {
482
+ if(arguments == 0) {
483
+ arguments_ = new Arguments();
484
+ } else {
485
+ arguments_ = arguments;
486
+ }
487
+ }
488
+
489
+ template<typename Func_T, typename Ret_T, typename Self_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>
490
+ VALUE Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_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>::
491
+ call(int argc, VALUE* argv, VALUE self)
492
+ {
493
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_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;
494
+ try
495
+ {
496
+ Data_Object<Wrapped_Function> data(detail::method_data());
497
+ wrapper =
498
+ (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_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();
499
+ Arguments* args = wrapper->arguments_;
500
+
501
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12;
502
+ Arg0_T arg0;Arg1_T arg1;Arg2_T arg2;Arg3_T arg3;Arg4_T arg4;Arg5_T arg5;Arg6_T arg6;Arg7_T arg7;Arg8_T arg8;Arg9_T arg9;Arg10_T arg10;Arg11_T arg11;Arg12_T arg12;
503
+
504
+ rb_scan_args(argc, argv, args->formatString(Num_Args),
505
+ &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12);
506
+
507
+ Self_T * obj = from_ruby<Self_T *>(self);
508
+ if(args->isOptional(0) && NIL_P(varg0)) { arg0 = args->get(0)->getDefaultValue<Arg0_T>(); } else { arg0 = from_ruby<Arg0_T>(varg0); }
509
+ if(args->isOptional(1) && NIL_P(varg1)) { arg1 = args->get(1)->getDefaultValue<Arg1_T>(); } else { arg1 = from_ruby<Arg1_T>(varg1); }
510
+ if(args->isOptional(2) && NIL_P(varg2)) { arg2 = args->get(2)->getDefaultValue<Arg2_T>(); } else { arg2 = from_ruby<Arg2_T>(varg2); }
511
+ if(args->isOptional(3) && NIL_P(varg3)) { arg3 = args->get(3)->getDefaultValue<Arg3_T>(); } else { arg3 = from_ruby<Arg3_T>(varg3); }
512
+ if(args->isOptional(4) && NIL_P(varg4)) { arg4 = args->get(4)->getDefaultValue<Arg4_T>(); } else { arg4 = from_ruby<Arg4_T>(varg4); }
513
+ if(args->isOptional(5) && NIL_P(varg5)) { arg5 = args->get(5)->getDefaultValue<Arg5_T>(); } else { arg5 = from_ruby<Arg5_T>(varg5); }
514
+ if(args->isOptional(6) && NIL_P(varg6)) { arg6 = args->get(6)->getDefaultValue<Arg6_T>(); } else { arg6 = from_ruby<Arg6_T>(varg6); }
515
+ if(args->isOptional(7) && NIL_P(varg7)) { arg7 = args->get(7)->getDefaultValue<Arg7_T>(); } else { arg7 = from_ruby<Arg7_T>(varg7); }
516
+ if(args->isOptional(8) && NIL_P(varg8)) { arg8 = args->get(8)->getDefaultValue<Arg8_T>(); } else { arg8 = from_ruby<Arg8_T>(varg8); }
517
+ if(args->isOptional(9) && NIL_P(varg9)) { arg9 = args->get(9)->getDefaultValue<Arg9_T>(); } else { arg9 = from_ruby<Arg9_T>(varg9); }
518
+ if(args->isOptional(10) && NIL_P(varg10)) { arg10 = args->get(10)->getDefaultValue<Arg10_T>(); } else { arg10 = from_ruby<Arg10_T>(varg10); }
519
+ if(args->isOptional(11) && NIL_P(varg11)) { arg11 = args->get(11)->getDefaultValue<Arg11_T>(); } else { arg11 = from_ruby<Arg11_T>(varg11); }
520
+ if(args->isOptional(12) && NIL_P(varg12)) { arg12 = args->get(12)->getDefaultValue<Arg12_T>(); } else { arg12 = from_ruby<Arg12_T>(varg12); }
521
+
522
+ Func func = wrapper->func_;
523
+ return to_ruby((*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12));
524
+ }
525
+ catch(...)
526
+ {
527
+ RUBY_TRY
528
+ {
529
+ if(wrapper)
530
+ {
531
+ return wrapper->handler_->handle_exception();
532
+ }
533
+ else
534
+ {
535
+ throw;
536
+ }
537
+ }
538
+ RUBY_CATCH
539
+ }
540
+ }
541
+
542
+ template<typename Func_T, typename Self_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>
543
+ Auto_Member_Function_Wrapper<Func_T, void, Self_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>::
544
+ Auto_Member_Function_Wrapper(
545
+ Func func,
546
+ Data_Object<Exception_Handler> handler,
547
+ Arguments* arguments)
548
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
549
+ , func_(func)
550
+ , handler_(handler)
551
+ , handler_guard_(&handler_)
552
+ , arguments_(arguments)
553
+ {
554
+ if(arguments == 0) {
555
+ arguments_ = new Arguments();
556
+ } else {
557
+ arguments_ = arguments;
558
+ }
559
+ }
560
+
561
+ template<typename Func_T, typename Self_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>
562
+ VALUE Auto_Member_Function_Wrapper<Func_T, void, Self_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>::
563
+ call(int argc, VALUE* argv, VALUE self)
564
+ {
565
+ Auto_Member_Function_Wrapper<Func_T, void, Self_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;
566
+ try
567
+ {
568
+ Data_Object<Wrapped_Function> data(detail::method_data());
569
+ wrapper =
570
+ (Auto_Member_Function_Wrapper<Func_T, void, Self_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();
571
+ Arguments* args = wrapper->arguments_;
572
+
573
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12;
574
+ Arg0_T arg0;Arg1_T arg1;Arg2_T arg2;Arg3_T arg3;Arg4_T arg4;Arg5_T arg5;Arg6_T arg6;Arg7_T arg7;Arg8_T arg8;Arg9_T arg9;Arg10_T arg10;Arg11_T arg11;Arg12_T arg12;
575
+
576
+ rb_scan_args(argc, argv, args->formatString(Num_Args),
577
+ &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12);
578
+
579
+ Self_T * obj = from_ruby<Self_T *>(self);
580
+ if(args->isOptional(0) && NIL_P(varg0)) { arg0 = args->get(0)->getDefaultValue<Arg0_T>(); } else { arg0 = from_ruby<Arg0_T>(varg0); }
581
+ if(args->isOptional(1) && NIL_P(varg1)) { arg1 = args->get(1)->getDefaultValue<Arg1_T>(); } else { arg1 = from_ruby<Arg1_T>(varg1); }
582
+ if(args->isOptional(2) && NIL_P(varg2)) { arg2 = args->get(2)->getDefaultValue<Arg2_T>(); } else { arg2 = from_ruby<Arg2_T>(varg2); }
583
+ if(args->isOptional(3) && NIL_P(varg3)) { arg3 = args->get(3)->getDefaultValue<Arg3_T>(); } else { arg3 = from_ruby<Arg3_T>(varg3); }
584
+ if(args->isOptional(4) && NIL_P(varg4)) { arg4 = args->get(4)->getDefaultValue<Arg4_T>(); } else { arg4 = from_ruby<Arg4_T>(varg4); }
585
+ if(args->isOptional(5) && NIL_P(varg5)) { arg5 = args->get(5)->getDefaultValue<Arg5_T>(); } else { arg5 = from_ruby<Arg5_T>(varg5); }
586
+ if(args->isOptional(6) && NIL_P(varg6)) { arg6 = args->get(6)->getDefaultValue<Arg6_T>(); } else { arg6 = from_ruby<Arg6_T>(varg6); }
587
+ if(args->isOptional(7) && NIL_P(varg7)) { arg7 = args->get(7)->getDefaultValue<Arg7_T>(); } else { arg7 = from_ruby<Arg7_T>(varg7); }
588
+ if(args->isOptional(8) && NIL_P(varg8)) { arg8 = args->get(8)->getDefaultValue<Arg8_T>(); } else { arg8 = from_ruby<Arg8_T>(varg8); }
589
+ if(args->isOptional(9) && NIL_P(varg9)) { arg9 = args->get(9)->getDefaultValue<Arg9_T>(); } else { arg9 = from_ruby<Arg9_T>(varg9); }
590
+ if(args->isOptional(10) && NIL_P(varg10)) { arg10 = args->get(10)->getDefaultValue<Arg10_T>(); } else { arg10 = from_ruby<Arg10_T>(varg10); }
591
+ if(args->isOptional(11) && NIL_P(varg11)) { arg11 = args->get(11)->getDefaultValue<Arg11_T>(); } else { arg11 = from_ruby<Arg11_T>(varg11); }
592
+ if(args->isOptional(12) && NIL_P(varg12)) { arg12 = args->get(12)->getDefaultValue<Arg12_T>(); } else { arg12 = from_ruby<Arg12_T>(varg12); }
593
+
594
+ Func func = wrapper->func_;
595
+ (*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
596
+ return Qnil;
597
+ }
598
+ catch(...)
599
+ {
600
+ RUBY_TRY
601
+ {
602
+ if(wrapper)
603
+ {
604
+ return wrapper->handler_->handle_exception();
605
+ }
606
+ else
607
+ {
608
+ throw;
609
+ }
610
+ }
611
+ RUBY_CATCH
612
+ }
613
+ }
614
+
615
+ // ---------------------------------------------------------------------
616
+ template<typename Func_T, typename Ret_T, typename Self_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>
617
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_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>::
618
+ Auto_Member_Function_Wrapper(
619
+ Func func,
620
+ Data_Object<Exception_Handler> handler,
621
+ Arguments* arguments)
622
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
623
+ , func_(func)
624
+ , handler_(handler)
625
+ , handler_guard_(&handler_)
626
+ , arguments_(arguments)
627
+ {
628
+ if(arguments == 0) {
629
+ arguments_ = new Arguments();
630
+ } else {
631
+ arguments_ = arguments;
632
+ }
633
+ }
634
+
635
+ template<typename Func_T, typename Ret_T, typename Self_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>
636
+ VALUE Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_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>::
637
+ call(int argc, VALUE* argv, VALUE self)
638
+ {
639
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_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;
640
+ try
641
+ {
642
+ Data_Object<Wrapped_Function> data(detail::method_data());
643
+ wrapper =
644
+ (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_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();
645
+ Arguments* args = wrapper->arguments_;
646
+
647
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11;
648
+ Arg0_T arg0;Arg1_T arg1;Arg2_T arg2;Arg3_T arg3;Arg4_T arg4;Arg5_T arg5;Arg6_T arg6;Arg7_T arg7;Arg8_T arg8;Arg9_T arg9;Arg10_T arg10;Arg11_T arg11;
649
+
650
+ rb_scan_args(argc, argv, args->formatString(Num_Args),
651
+ &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11);
652
+
653
+ Self_T * obj = from_ruby<Self_T *>(self);
654
+ if(args->isOptional(0) && NIL_P(varg0)) { arg0 = args->get(0)->getDefaultValue<Arg0_T>(); } else { arg0 = from_ruby<Arg0_T>(varg0); }
655
+ if(args->isOptional(1) && NIL_P(varg1)) { arg1 = args->get(1)->getDefaultValue<Arg1_T>(); } else { arg1 = from_ruby<Arg1_T>(varg1); }
656
+ if(args->isOptional(2) && NIL_P(varg2)) { arg2 = args->get(2)->getDefaultValue<Arg2_T>(); } else { arg2 = from_ruby<Arg2_T>(varg2); }
657
+ if(args->isOptional(3) && NIL_P(varg3)) { arg3 = args->get(3)->getDefaultValue<Arg3_T>(); } else { arg3 = from_ruby<Arg3_T>(varg3); }
658
+ if(args->isOptional(4) && NIL_P(varg4)) { arg4 = args->get(4)->getDefaultValue<Arg4_T>(); } else { arg4 = from_ruby<Arg4_T>(varg4); }
659
+ if(args->isOptional(5) && NIL_P(varg5)) { arg5 = args->get(5)->getDefaultValue<Arg5_T>(); } else { arg5 = from_ruby<Arg5_T>(varg5); }
660
+ if(args->isOptional(6) && NIL_P(varg6)) { arg6 = args->get(6)->getDefaultValue<Arg6_T>(); } else { arg6 = from_ruby<Arg6_T>(varg6); }
661
+ if(args->isOptional(7) && NIL_P(varg7)) { arg7 = args->get(7)->getDefaultValue<Arg7_T>(); } else { arg7 = from_ruby<Arg7_T>(varg7); }
662
+ if(args->isOptional(8) && NIL_P(varg8)) { arg8 = args->get(8)->getDefaultValue<Arg8_T>(); } else { arg8 = from_ruby<Arg8_T>(varg8); }
663
+ if(args->isOptional(9) && NIL_P(varg9)) { arg9 = args->get(9)->getDefaultValue<Arg9_T>(); } else { arg9 = from_ruby<Arg9_T>(varg9); }
664
+ if(args->isOptional(10) && NIL_P(varg10)) { arg10 = args->get(10)->getDefaultValue<Arg10_T>(); } else { arg10 = from_ruby<Arg10_T>(varg10); }
665
+ if(args->isOptional(11) && NIL_P(varg11)) { arg11 = args->get(11)->getDefaultValue<Arg11_T>(); } else { arg11 = from_ruby<Arg11_T>(varg11); }
666
+
667
+ Func func = wrapper->func_;
668
+ return to_ruby((*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11));
669
+ }
670
+ catch(...)
671
+ {
672
+ RUBY_TRY
673
+ {
674
+ if(wrapper)
675
+ {
676
+ return wrapper->handler_->handle_exception();
677
+ }
678
+ else
679
+ {
680
+ throw;
681
+ }
682
+ }
683
+ RUBY_CATCH
684
+ }
685
+ }
686
+
687
+ template<typename Func_T, typename Self_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>
688
+ Auto_Member_Function_Wrapper<Func_T, void, Self_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>::
689
+ Auto_Member_Function_Wrapper(
690
+ Func func,
691
+ Data_Object<Exception_Handler> handler,
692
+ Arguments* arguments)
693
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
694
+ , func_(func)
695
+ , handler_(handler)
696
+ , handler_guard_(&handler_)
697
+ , arguments_(arguments)
698
+ {
699
+ if(arguments == 0) {
700
+ arguments_ = new Arguments();
701
+ } else {
702
+ arguments_ = arguments;
703
+ }
704
+ }
705
+
706
+ template<typename Func_T, typename Self_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>
707
+ VALUE Auto_Member_Function_Wrapper<Func_T, void, Self_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>::
708
+ call(int argc, VALUE* argv, VALUE self)
709
+ {
710
+ Auto_Member_Function_Wrapper<Func_T, void, Self_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;
711
+ try
712
+ {
713
+ Data_Object<Wrapped_Function> data(detail::method_data());
714
+ wrapper =
715
+ (Auto_Member_Function_Wrapper<Func_T, void, Self_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();
716
+ Arguments* args = wrapper->arguments_;
717
+
718
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11;
719
+ Arg0_T arg0;Arg1_T arg1;Arg2_T arg2;Arg3_T arg3;Arg4_T arg4;Arg5_T arg5;Arg6_T arg6;Arg7_T arg7;Arg8_T arg8;Arg9_T arg9;Arg10_T arg10;Arg11_T arg11;
720
+
721
+ rb_scan_args(argc, argv, args->formatString(Num_Args),
722
+ &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11);
723
+
724
+ Self_T * obj = from_ruby<Self_T *>(self);
725
+ if(args->isOptional(0) && NIL_P(varg0)) { arg0 = args->get(0)->getDefaultValue<Arg0_T>(); } else { arg0 = from_ruby<Arg0_T>(varg0); }
726
+ if(args->isOptional(1) && NIL_P(varg1)) { arg1 = args->get(1)->getDefaultValue<Arg1_T>(); } else { arg1 = from_ruby<Arg1_T>(varg1); }
727
+ if(args->isOptional(2) && NIL_P(varg2)) { arg2 = args->get(2)->getDefaultValue<Arg2_T>(); } else { arg2 = from_ruby<Arg2_T>(varg2); }
728
+ if(args->isOptional(3) && NIL_P(varg3)) { arg3 = args->get(3)->getDefaultValue<Arg3_T>(); } else { arg3 = from_ruby<Arg3_T>(varg3); }
729
+ if(args->isOptional(4) && NIL_P(varg4)) { arg4 = args->get(4)->getDefaultValue<Arg4_T>(); } else { arg4 = from_ruby<Arg4_T>(varg4); }
730
+ if(args->isOptional(5) && NIL_P(varg5)) { arg5 = args->get(5)->getDefaultValue<Arg5_T>(); } else { arg5 = from_ruby<Arg5_T>(varg5); }
731
+ if(args->isOptional(6) && NIL_P(varg6)) { arg6 = args->get(6)->getDefaultValue<Arg6_T>(); } else { arg6 = from_ruby<Arg6_T>(varg6); }
732
+ if(args->isOptional(7) && NIL_P(varg7)) { arg7 = args->get(7)->getDefaultValue<Arg7_T>(); } else { arg7 = from_ruby<Arg7_T>(varg7); }
733
+ if(args->isOptional(8) && NIL_P(varg8)) { arg8 = args->get(8)->getDefaultValue<Arg8_T>(); } else { arg8 = from_ruby<Arg8_T>(varg8); }
734
+ if(args->isOptional(9) && NIL_P(varg9)) { arg9 = args->get(9)->getDefaultValue<Arg9_T>(); } else { arg9 = from_ruby<Arg9_T>(varg9); }
735
+ if(args->isOptional(10) && NIL_P(varg10)) { arg10 = args->get(10)->getDefaultValue<Arg10_T>(); } else { arg10 = from_ruby<Arg10_T>(varg10); }
736
+ if(args->isOptional(11) && NIL_P(varg11)) { arg11 = args->get(11)->getDefaultValue<Arg11_T>(); } else { arg11 = from_ruby<Arg11_T>(varg11); }
737
+
738
+ Func func = wrapper->func_;
739
+ (*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
740
+ return Qnil;
741
+ }
742
+ catch(...)
743
+ {
744
+ RUBY_TRY
745
+ {
746
+ if(wrapper)
747
+ {
748
+ return wrapper->handler_->handle_exception();
749
+ }
750
+ else
751
+ {
752
+ throw;
753
+ }
754
+ }
755
+ RUBY_CATCH
756
+ }
757
+ }
758
+
759
+ // ---------------------------------------------------------------------
760
+ template<typename Func_T, typename Ret_T, typename Self_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>
761
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T>::
762
+ Auto_Member_Function_Wrapper(
763
+ Func func,
764
+ Data_Object<Exception_Handler> handler,
765
+ Arguments* arguments)
766
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
767
+ , func_(func)
768
+ , handler_(handler)
769
+ , handler_guard_(&handler_)
770
+ , arguments_(arguments)
771
+ {
772
+ if(arguments == 0) {
773
+ arguments_ = new Arguments();
774
+ } else {
775
+ arguments_ = arguments;
776
+ }
777
+ }
778
+
779
+ template<typename Func_T, typename Ret_T, typename Self_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>
780
+ VALUE Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T>::
781
+ call(int argc, VALUE* argv, VALUE self)
782
+ {
783
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_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;
784
+ try
785
+ {
786
+ Data_Object<Wrapped_Function> data(detail::method_data());
787
+ wrapper =
788
+ (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_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();
789
+ Arguments* args = wrapper->arguments_;
790
+
791
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10;
792
+ Arg0_T arg0;Arg1_T arg1;Arg2_T arg2;Arg3_T arg3;Arg4_T arg4;Arg5_T arg5;Arg6_T arg6;Arg7_T arg7;Arg8_T arg8;Arg9_T arg9;Arg10_T arg10;
793
+
794
+ rb_scan_args(argc, argv, args->formatString(Num_Args),
795
+ &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10);
796
+
797
+ Self_T * obj = from_ruby<Self_T *>(self);
798
+ if(args->isOptional(0) && NIL_P(varg0)) { arg0 = args->get(0)->getDefaultValue<Arg0_T>(); } else { arg0 = from_ruby<Arg0_T>(varg0); }
799
+ if(args->isOptional(1) && NIL_P(varg1)) { arg1 = args->get(1)->getDefaultValue<Arg1_T>(); } else { arg1 = from_ruby<Arg1_T>(varg1); }
800
+ if(args->isOptional(2) && NIL_P(varg2)) { arg2 = args->get(2)->getDefaultValue<Arg2_T>(); } else { arg2 = from_ruby<Arg2_T>(varg2); }
801
+ if(args->isOptional(3) && NIL_P(varg3)) { arg3 = args->get(3)->getDefaultValue<Arg3_T>(); } else { arg3 = from_ruby<Arg3_T>(varg3); }
802
+ if(args->isOptional(4) && NIL_P(varg4)) { arg4 = args->get(4)->getDefaultValue<Arg4_T>(); } else { arg4 = from_ruby<Arg4_T>(varg4); }
803
+ if(args->isOptional(5) && NIL_P(varg5)) { arg5 = args->get(5)->getDefaultValue<Arg5_T>(); } else { arg5 = from_ruby<Arg5_T>(varg5); }
804
+ if(args->isOptional(6) && NIL_P(varg6)) { arg6 = args->get(6)->getDefaultValue<Arg6_T>(); } else { arg6 = from_ruby<Arg6_T>(varg6); }
805
+ if(args->isOptional(7) && NIL_P(varg7)) { arg7 = args->get(7)->getDefaultValue<Arg7_T>(); } else { arg7 = from_ruby<Arg7_T>(varg7); }
806
+ if(args->isOptional(8) && NIL_P(varg8)) { arg8 = args->get(8)->getDefaultValue<Arg8_T>(); } else { arg8 = from_ruby<Arg8_T>(varg8); }
807
+ if(args->isOptional(9) && NIL_P(varg9)) { arg9 = args->get(9)->getDefaultValue<Arg9_T>(); } else { arg9 = from_ruby<Arg9_T>(varg9); }
808
+ if(args->isOptional(10) && NIL_P(varg10)) { arg10 = args->get(10)->getDefaultValue<Arg10_T>(); } else { arg10 = from_ruby<Arg10_T>(varg10); }
809
+
810
+ Func func = wrapper->func_;
811
+ return to_ruby((*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10));
812
+ }
813
+ catch(...)
814
+ {
815
+ RUBY_TRY
816
+ {
817
+ if(wrapper)
818
+ {
819
+ return wrapper->handler_->handle_exception();
820
+ }
821
+ else
822
+ {
823
+ throw;
824
+ }
825
+ }
826
+ RUBY_CATCH
827
+ }
828
+ }
829
+
830
+ template<typename Func_T, typename Self_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>
831
+ Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T>::
832
+ Auto_Member_Function_Wrapper(
833
+ Func func,
834
+ Data_Object<Exception_Handler> handler,
835
+ Arguments* arguments)
836
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
837
+ , func_(func)
838
+ , handler_(handler)
839
+ , handler_guard_(&handler_)
840
+ , arguments_(arguments)
841
+ {
842
+ if(arguments == 0) {
843
+ arguments_ = new Arguments();
844
+ } else {
845
+ arguments_ = arguments;
846
+ }
847
+ }
848
+
849
+ template<typename Func_T, typename Self_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>
850
+ VALUE Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T>::
851
+ call(int argc, VALUE* argv, VALUE self)
852
+ {
853
+ Auto_Member_Function_Wrapper<Func_T, void, Self_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;
854
+ try
855
+ {
856
+ Data_Object<Wrapped_Function> data(detail::method_data());
857
+ wrapper =
858
+ (Auto_Member_Function_Wrapper<Func_T, void, Self_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();
859
+ Arguments* args = wrapper->arguments_;
860
+
861
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10;
862
+ Arg0_T arg0;Arg1_T arg1;Arg2_T arg2;Arg3_T arg3;Arg4_T arg4;Arg5_T arg5;Arg6_T arg6;Arg7_T arg7;Arg8_T arg8;Arg9_T arg9;Arg10_T arg10;
863
+
864
+ rb_scan_args(argc, argv, args->formatString(Num_Args),
865
+ &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10);
866
+
867
+ Self_T * obj = from_ruby<Self_T *>(self);
868
+ if(args->isOptional(0) && NIL_P(varg0)) { arg0 = args->get(0)->getDefaultValue<Arg0_T>(); } else { arg0 = from_ruby<Arg0_T>(varg0); }
869
+ if(args->isOptional(1) && NIL_P(varg1)) { arg1 = args->get(1)->getDefaultValue<Arg1_T>(); } else { arg1 = from_ruby<Arg1_T>(varg1); }
870
+ if(args->isOptional(2) && NIL_P(varg2)) { arg2 = args->get(2)->getDefaultValue<Arg2_T>(); } else { arg2 = from_ruby<Arg2_T>(varg2); }
871
+ if(args->isOptional(3) && NIL_P(varg3)) { arg3 = args->get(3)->getDefaultValue<Arg3_T>(); } else { arg3 = from_ruby<Arg3_T>(varg3); }
872
+ if(args->isOptional(4) && NIL_P(varg4)) { arg4 = args->get(4)->getDefaultValue<Arg4_T>(); } else { arg4 = from_ruby<Arg4_T>(varg4); }
873
+ if(args->isOptional(5) && NIL_P(varg5)) { arg5 = args->get(5)->getDefaultValue<Arg5_T>(); } else { arg5 = from_ruby<Arg5_T>(varg5); }
874
+ if(args->isOptional(6) && NIL_P(varg6)) { arg6 = args->get(6)->getDefaultValue<Arg6_T>(); } else { arg6 = from_ruby<Arg6_T>(varg6); }
875
+ if(args->isOptional(7) && NIL_P(varg7)) { arg7 = args->get(7)->getDefaultValue<Arg7_T>(); } else { arg7 = from_ruby<Arg7_T>(varg7); }
876
+ if(args->isOptional(8) && NIL_P(varg8)) { arg8 = args->get(8)->getDefaultValue<Arg8_T>(); } else { arg8 = from_ruby<Arg8_T>(varg8); }
877
+ if(args->isOptional(9) && NIL_P(varg9)) { arg9 = args->get(9)->getDefaultValue<Arg9_T>(); } else { arg9 = from_ruby<Arg9_T>(varg9); }
878
+ if(args->isOptional(10) && NIL_P(varg10)) { arg10 = args->get(10)->getDefaultValue<Arg10_T>(); } else { arg10 = from_ruby<Arg10_T>(varg10); }
879
+
880
+ Func func = wrapper->func_;
881
+ (*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
882
+ return Qnil;
883
+ }
884
+ catch(...)
885
+ {
886
+ RUBY_TRY
887
+ {
888
+ if(wrapper)
889
+ {
890
+ return wrapper->handler_->handle_exception();
891
+ }
892
+ else
893
+ {
894
+ throw;
895
+ }
896
+ }
897
+ RUBY_CATCH
898
+ }
899
+ }
900
+
901
+ // ---------------------------------------------------------------------
902
+ template<typename Func_T, typename Ret_T, typename Self_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>
903
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T>::
904
+ Auto_Member_Function_Wrapper(
905
+ Func func,
906
+ Data_Object<Exception_Handler> handler,
907
+ Arguments* arguments)
908
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
909
+ , func_(func)
910
+ , handler_(handler)
911
+ , handler_guard_(&handler_)
912
+ , arguments_(arguments)
913
+ {
914
+ if(arguments == 0) {
915
+ arguments_ = new Arguments();
916
+ } else {
917
+ arguments_ = arguments;
918
+ }
919
+ }
920
+
921
+ template<typename Func_T, typename Ret_T, typename Self_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>
922
+ VALUE Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T>::
923
+ call(int argc, VALUE* argv, VALUE self)
924
+ {
925
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T> * wrapper = 0;
926
+ try
927
+ {
928
+ Data_Object<Wrapped_Function> data(detail::method_data());
929
+ wrapper =
930
+ (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T> *)data.get();
931
+ Arguments* args = wrapper->arguments_;
932
+
933
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9;
934
+ Arg0_T arg0;Arg1_T arg1;Arg2_T arg2;Arg3_T arg3;Arg4_T arg4;Arg5_T arg5;Arg6_T arg6;Arg7_T arg7;Arg8_T arg8;Arg9_T arg9;
935
+
936
+ rb_scan_args(argc, argv, args->formatString(Num_Args),
937
+ &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9);
938
+
939
+ Self_T * obj = from_ruby<Self_T *>(self);
940
+ if(args->isOptional(0) && NIL_P(varg0)) { arg0 = args->get(0)->getDefaultValue<Arg0_T>(); } else { arg0 = from_ruby<Arg0_T>(varg0); }
941
+ if(args->isOptional(1) && NIL_P(varg1)) { arg1 = args->get(1)->getDefaultValue<Arg1_T>(); } else { arg1 = from_ruby<Arg1_T>(varg1); }
942
+ if(args->isOptional(2) && NIL_P(varg2)) { arg2 = args->get(2)->getDefaultValue<Arg2_T>(); } else { arg2 = from_ruby<Arg2_T>(varg2); }
943
+ if(args->isOptional(3) && NIL_P(varg3)) { arg3 = args->get(3)->getDefaultValue<Arg3_T>(); } else { arg3 = from_ruby<Arg3_T>(varg3); }
944
+ if(args->isOptional(4) && NIL_P(varg4)) { arg4 = args->get(4)->getDefaultValue<Arg4_T>(); } else { arg4 = from_ruby<Arg4_T>(varg4); }
945
+ if(args->isOptional(5) && NIL_P(varg5)) { arg5 = args->get(5)->getDefaultValue<Arg5_T>(); } else { arg5 = from_ruby<Arg5_T>(varg5); }
946
+ if(args->isOptional(6) && NIL_P(varg6)) { arg6 = args->get(6)->getDefaultValue<Arg6_T>(); } else { arg6 = from_ruby<Arg6_T>(varg6); }
947
+ if(args->isOptional(7) && NIL_P(varg7)) { arg7 = args->get(7)->getDefaultValue<Arg7_T>(); } else { arg7 = from_ruby<Arg7_T>(varg7); }
948
+ if(args->isOptional(8) && NIL_P(varg8)) { arg8 = args->get(8)->getDefaultValue<Arg8_T>(); } else { arg8 = from_ruby<Arg8_T>(varg8); }
949
+ if(args->isOptional(9) && NIL_P(varg9)) { arg9 = args->get(9)->getDefaultValue<Arg9_T>(); } else { arg9 = from_ruby<Arg9_T>(varg9); }
950
+
951
+ Func func = wrapper->func_;
952
+ return to_ruby((*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9));
953
+ }
954
+ catch(...)
955
+ {
956
+ RUBY_TRY
957
+ {
958
+ if(wrapper)
959
+ {
960
+ return wrapper->handler_->handle_exception();
961
+ }
962
+ else
963
+ {
964
+ throw;
965
+ }
966
+ }
967
+ RUBY_CATCH
968
+ }
969
+ }
970
+
971
+ template<typename Func_T, typename Self_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>
972
+ Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T>::
973
+ Auto_Member_Function_Wrapper(
974
+ Func func,
975
+ Data_Object<Exception_Handler> handler,
976
+ Arguments* arguments)
977
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
978
+ , func_(func)
979
+ , handler_(handler)
980
+ , handler_guard_(&handler_)
981
+ , arguments_(arguments)
982
+ {
983
+ if(arguments == 0) {
984
+ arguments_ = new Arguments();
985
+ } else {
986
+ arguments_ = arguments;
987
+ }
988
+ }
989
+
990
+ template<typename Func_T, typename Self_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>
991
+ VALUE Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T>::
992
+ call(int argc, VALUE* argv, VALUE self)
993
+ {
994
+ Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T> * wrapper = 0;
995
+ try
996
+ {
997
+ Data_Object<Wrapped_Function> data(detail::method_data());
998
+ wrapper =
999
+ (Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T> *)data.get();
1000
+ Arguments* args = wrapper->arguments_;
1001
+
1002
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9;
1003
+ Arg0_T arg0;Arg1_T arg1;Arg2_T arg2;Arg3_T arg3;Arg4_T arg4;Arg5_T arg5;Arg6_T arg6;Arg7_T arg7;Arg8_T arg8;Arg9_T arg9;
1004
+
1005
+ rb_scan_args(argc, argv, args->formatString(Num_Args),
1006
+ &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9);
1007
+
1008
+ Self_T * obj = from_ruby<Self_T *>(self);
1009
+ if(args->isOptional(0) && NIL_P(varg0)) { arg0 = args->get(0)->getDefaultValue<Arg0_T>(); } else { arg0 = from_ruby<Arg0_T>(varg0); }
1010
+ if(args->isOptional(1) && NIL_P(varg1)) { arg1 = args->get(1)->getDefaultValue<Arg1_T>(); } else { arg1 = from_ruby<Arg1_T>(varg1); }
1011
+ if(args->isOptional(2) && NIL_P(varg2)) { arg2 = args->get(2)->getDefaultValue<Arg2_T>(); } else { arg2 = from_ruby<Arg2_T>(varg2); }
1012
+ if(args->isOptional(3) && NIL_P(varg3)) { arg3 = args->get(3)->getDefaultValue<Arg3_T>(); } else { arg3 = from_ruby<Arg3_T>(varg3); }
1013
+ if(args->isOptional(4) && NIL_P(varg4)) { arg4 = args->get(4)->getDefaultValue<Arg4_T>(); } else { arg4 = from_ruby<Arg4_T>(varg4); }
1014
+ if(args->isOptional(5) && NIL_P(varg5)) { arg5 = args->get(5)->getDefaultValue<Arg5_T>(); } else { arg5 = from_ruby<Arg5_T>(varg5); }
1015
+ if(args->isOptional(6) && NIL_P(varg6)) { arg6 = args->get(6)->getDefaultValue<Arg6_T>(); } else { arg6 = from_ruby<Arg6_T>(varg6); }
1016
+ if(args->isOptional(7) && NIL_P(varg7)) { arg7 = args->get(7)->getDefaultValue<Arg7_T>(); } else { arg7 = from_ruby<Arg7_T>(varg7); }
1017
+ if(args->isOptional(8) && NIL_P(varg8)) { arg8 = args->get(8)->getDefaultValue<Arg8_T>(); } else { arg8 = from_ruby<Arg8_T>(varg8); }
1018
+ if(args->isOptional(9) && NIL_P(varg9)) { arg9 = args->get(9)->getDefaultValue<Arg9_T>(); } else { arg9 = from_ruby<Arg9_T>(varg9); }
1019
+
1020
+ Func func = wrapper->func_;
1021
+ (*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
1022
+ return Qnil;
1023
+ }
1024
+ catch(...)
1025
+ {
1026
+ RUBY_TRY
1027
+ {
1028
+ if(wrapper)
1029
+ {
1030
+ return wrapper->handler_->handle_exception();
1031
+ }
1032
+ else
1033
+ {
1034
+ throw;
1035
+ }
1036
+ }
1037
+ RUBY_CATCH
1038
+ }
1039
+ }
1040
+
1041
+ // ---------------------------------------------------------------------
1042
+ template<typename Func_T, typename Ret_T, typename Self_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>
1043
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T>::
1044
+ Auto_Member_Function_Wrapper(
1045
+ Func func,
1046
+ Data_Object<Exception_Handler> handler,
1047
+ Arguments* arguments)
1048
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
1049
+ , func_(func)
1050
+ , handler_(handler)
1051
+ , handler_guard_(&handler_)
1052
+ , arguments_(arguments)
1053
+ {
1054
+ if(arguments == 0) {
1055
+ arguments_ = new Arguments();
1056
+ } else {
1057
+ arguments_ = arguments;
1058
+ }
1059
+ }
1060
+
1061
+ template<typename Func_T, typename Ret_T, typename Self_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>
1062
+ VALUE Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T>::
1063
+ call(int argc, VALUE* argv, VALUE self)
1064
+ {
1065
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T> * wrapper = 0;
1066
+ try
1067
+ {
1068
+ Data_Object<Wrapped_Function> data(detail::method_data());
1069
+ wrapper =
1070
+ (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T> *)data.get();
1071
+ Arguments* args = wrapper->arguments_;
1072
+
1073
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8;
1074
+ Arg0_T arg0;Arg1_T arg1;Arg2_T arg2;Arg3_T arg3;Arg4_T arg4;Arg5_T arg5;Arg6_T arg6;Arg7_T arg7;Arg8_T arg8;
1075
+
1076
+ rb_scan_args(argc, argv, args->formatString(Num_Args),
1077
+ &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8);
1078
+
1079
+ Self_T * obj = from_ruby<Self_T *>(self);
1080
+ if(args->isOptional(0) && NIL_P(varg0)) { arg0 = args->get(0)->getDefaultValue<Arg0_T>(); } else { arg0 = from_ruby<Arg0_T>(varg0); }
1081
+ if(args->isOptional(1) && NIL_P(varg1)) { arg1 = args->get(1)->getDefaultValue<Arg1_T>(); } else { arg1 = from_ruby<Arg1_T>(varg1); }
1082
+ if(args->isOptional(2) && NIL_P(varg2)) { arg2 = args->get(2)->getDefaultValue<Arg2_T>(); } else { arg2 = from_ruby<Arg2_T>(varg2); }
1083
+ if(args->isOptional(3) && NIL_P(varg3)) { arg3 = args->get(3)->getDefaultValue<Arg3_T>(); } else { arg3 = from_ruby<Arg3_T>(varg3); }
1084
+ if(args->isOptional(4) && NIL_P(varg4)) { arg4 = args->get(4)->getDefaultValue<Arg4_T>(); } else { arg4 = from_ruby<Arg4_T>(varg4); }
1085
+ if(args->isOptional(5) && NIL_P(varg5)) { arg5 = args->get(5)->getDefaultValue<Arg5_T>(); } else { arg5 = from_ruby<Arg5_T>(varg5); }
1086
+ if(args->isOptional(6) && NIL_P(varg6)) { arg6 = args->get(6)->getDefaultValue<Arg6_T>(); } else { arg6 = from_ruby<Arg6_T>(varg6); }
1087
+ if(args->isOptional(7) && NIL_P(varg7)) { arg7 = args->get(7)->getDefaultValue<Arg7_T>(); } else { arg7 = from_ruby<Arg7_T>(varg7); }
1088
+ if(args->isOptional(8) && NIL_P(varg8)) { arg8 = args->get(8)->getDefaultValue<Arg8_T>(); } else { arg8 = from_ruby<Arg8_T>(varg8); }
1089
+
1090
+ Func func = wrapper->func_;
1091
+ return to_ruby((*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8));
1092
+ }
1093
+ catch(...)
1094
+ {
1095
+ RUBY_TRY
1096
+ {
1097
+ if(wrapper)
1098
+ {
1099
+ return wrapper->handler_->handle_exception();
1100
+ }
1101
+ else
1102
+ {
1103
+ throw;
1104
+ }
1105
+ }
1106
+ RUBY_CATCH
1107
+ }
1108
+ }
1109
+
1110
+ template<typename Func_T, typename Self_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>
1111
+ Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T>::
1112
+ Auto_Member_Function_Wrapper(
1113
+ Func func,
1114
+ Data_Object<Exception_Handler> handler,
1115
+ Arguments* arguments)
1116
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
1117
+ , func_(func)
1118
+ , handler_(handler)
1119
+ , handler_guard_(&handler_)
1120
+ , arguments_(arguments)
1121
+ {
1122
+ if(arguments == 0) {
1123
+ arguments_ = new Arguments();
1124
+ } else {
1125
+ arguments_ = arguments;
1126
+ }
1127
+ }
1128
+
1129
+ template<typename Func_T, typename Self_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>
1130
+ VALUE Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T>::
1131
+ call(int argc, VALUE* argv, VALUE self)
1132
+ {
1133
+ Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T> * wrapper = 0;
1134
+ try
1135
+ {
1136
+ Data_Object<Wrapped_Function> data(detail::method_data());
1137
+ wrapper =
1138
+ (Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T> *)data.get();
1139
+ Arguments* args = wrapper->arguments_;
1140
+
1141
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8;
1142
+ Arg0_T arg0;Arg1_T arg1;Arg2_T arg2;Arg3_T arg3;Arg4_T arg4;Arg5_T arg5;Arg6_T arg6;Arg7_T arg7;Arg8_T arg8;
1143
+
1144
+ rb_scan_args(argc, argv, args->formatString(Num_Args),
1145
+ &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8);
1146
+
1147
+ Self_T * obj = from_ruby<Self_T *>(self);
1148
+ if(args->isOptional(0) && NIL_P(varg0)) { arg0 = args->get(0)->getDefaultValue<Arg0_T>(); } else { arg0 = from_ruby<Arg0_T>(varg0); }
1149
+ if(args->isOptional(1) && NIL_P(varg1)) { arg1 = args->get(1)->getDefaultValue<Arg1_T>(); } else { arg1 = from_ruby<Arg1_T>(varg1); }
1150
+ if(args->isOptional(2) && NIL_P(varg2)) { arg2 = args->get(2)->getDefaultValue<Arg2_T>(); } else { arg2 = from_ruby<Arg2_T>(varg2); }
1151
+ if(args->isOptional(3) && NIL_P(varg3)) { arg3 = args->get(3)->getDefaultValue<Arg3_T>(); } else { arg3 = from_ruby<Arg3_T>(varg3); }
1152
+ if(args->isOptional(4) && NIL_P(varg4)) { arg4 = args->get(4)->getDefaultValue<Arg4_T>(); } else { arg4 = from_ruby<Arg4_T>(varg4); }
1153
+ if(args->isOptional(5) && NIL_P(varg5)) { arg5 = args->get(5)->getDefaultValue<Arg5_T>(); } else { arg5 = from_ruby<Arg5_T>(varg5); }
1154
+ if(args->isOptional(6) && NIL_P(varg6)) { arg6 = args->get(6)->getDefaultValue<Arg6_T>(); } else { arg6 = from_ruby<Arg6_T>(varg6); }
1155
+ if(args->isOptional(7) && NIL_P(varg7)) { arg7 = args->get(7)->getDefaultValue<Arg7_T>(); } else { arg7 = from_ruby<Arg7_T>(varg7); }
1156
+ if(args->isOptional(8) && NIL_P(varg8)) { arg8 = args->get(8)->getDefaultValue<Arg8_T>(); } else { arg8 = from_ruby<Arg8_T>(varg8); }
1157
+
1158
+ Func func = wrapper->func_;
1159
+ (*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
1160
+ return Qnil;
1161
+ }
1162
+ catch(...)
1163
+ {
1164
+ RUBY_TRY
1165
+ {
1166
+ if(wrapper)
1167
+ {
1168
+ return wrapper->handler_->handle_exception();
1169
+ }
1170
+ else
1171
+ {
1172
+ throw;
1173
+ }
1174
+ }
1175
+ RUBY_CATCH
1176
+ }
1177
+ }
1178
+
1179
+ // ---------------------------------------------------------------------
1180
+ template<typename Func_T, typename Ret_T, typename Self_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>
1181
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T>::
1182
+ Auto_Member_Function_Wrapper(
1183
+ Func func,
1184
+ Data_Object<Exception_Handler> handler,
1185
+ Arguments* arguments)
1186
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
1187
+ , func_(func)
1188
+ , handler_(handler)
1189
+ , handler_guard_(&handler_)
1190
+ , arguments_(arguments)
1191
+ {
1192
+ if(arguments == 0) {
1193
+ arguments_ = new Arguments();
1194
+ } else {
1195
+ arguments_ = arguments;
1196
+ }
1197
+ }
1198
+
1199
+ template<typename Func_T, typename Ret_T, typename Self_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>
1200
+ VALUE Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T>::
1201
+ call(int argc, VALUE* argv, VALUE self)
1202
+ {
1203
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T> * wrapper = 0;
1204
+ try
1205
+ {
1206
+ Data_Object<Wrapped_Function> data(detail::method_data());
1207
+ wrapper =
1208
+ (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T> *)data.get();
1209
+ Arguments* args = wrapper->arguments_;
1210
+
1211
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7;
1212
+ Arg0_T arg0;Arg1_T arg1;Arg2_T arg2;Arg3_T arg3;Arg4_T arg4;Arg5_T arg5;Arg6_T arg6;Arg7_T arg7;
1213
+
1214
+ rb_scan_args(argc, argv, args->formatString(Num_Args),
1215
+ &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7);
1216
+
1217
+ Self_T * obj = from_ruby<Self_T *>(self);
1218
+ if(args->isOptional(0) && NIL_P(varg0)) { arg0 = args->get(0)->getDefaultValue<Arg0_T>(); } else { arg0 = from_ruby<Arg0_T>(varg0); }
1219
+ if(args->isOptional(1) && NIL_P(varg1)) { arg1 = args->get(1)->getDefaultValue<Arg1_T>(); } else { arg1 = from_ruby<Arg1_T>(varg1); }
1220
+ if(args->isOptional(2) && NIL_P(varg2)) { arg2 = args->get(2)->getDefaultValue<Arg2_T>(); } else { arg2 = from_ruby<Arg2_T>(varg2); }
1221
+ if(args->isOptional(3) && NIL_P(varg3)) { arg3 = args->get(3)->getDefaultValue<Arg3_T>(); } else { arg3 = from_ruby<Arg3_T>(varg3); }
1222
+ if(args->isOptional(4) && NIL_P(varg4)) { arg4 = args->get(4)->getDefaultValue<Arg4_T>(); } else { arg4 = from_ruby<Arg4_T>(varg4); }
1223
+ if(args->isOptional(5) && NIL_P(varg5)) { arg5 = args->get(5)->getDefaultValue<Arg5_T>(); } else { arg5 = from_ruby<Arg5_T>(varg5); }
1224
+ if(args->isOptional(6) && NIL_P(varg6)) { arg6 = args->get(6)->getDefaultValue<Arg6_T>(); } else { arg6 = from_ruby<Arg6_T>(varg6); }
1225
+ if(args->isOptional(7) && NIL_P(varg7)) { arg7 = args->get(7)->getDefaultValue<Arg7_T>(); } else { arg7 = from_ruby<Arg7_T>(varg7); }
1226
+
1227
+ Func func = wrapper->func_;
1228
+ return to_ruby((*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7));
1229
+ }
1230
+ catch(...)
1231
+ {
1232
+ RUBY_TRY
1233
+ {
1234
+ if(wrapper)
1235
+ {
1236
+ return wrapper->handler_->handle_exception();
1237
+ }
1238
+ else
1239
+ {
1240
+ throw;
1241
+ }
1242
+ }
1243
+ RUBY_CATCH
1244
+ }
1245
+ }
1246
+
1247
+ template<typename Func_T, typename Self_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>
1248
+ Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T>::
1249
+ Auto_Member_Function_Wrapper(
1250
+ Func func,
1251
+ Data_Object<Exception_Handler> handler,
1252
+ Arguments* arguments)
1253
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
1254
+ , func_(func)
1255
+ , handler_(handler)
1256
+ , handler_guard_(&handler_)
1257
+ , arguments_(arguments)
1258
+ {
1259
+ if(arguments == 0) {
1260
+ arguments_ = new Arguments();
1261
+ } else {
1262
+ arguments_ = arguments;
1263
+ }
1264
+ }
1265
+
1266
+ template<typename Func_T, typename Self_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>
1267
+ VALUE Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T>::
1268
+ call(int argc, VALUE* argv, VALUE self)
1269
+ {
1270
+ Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T> * wrapper = 0;
1271
+ try
1272
+ {
1273
+ Data_Object<Wrapped_Function> data(detail::method_data());
1274
+ wrapper =
1275
+ (Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T> *)data.get();
1276
+ Arguments* args = wrapper->arguments_;
1277
+
1278
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7;
1279
+ Arg0_T arg0;Arg1_T arg1;Arg2_T arg2;Arg3_T arg3;Arg4_T arg4;Arg5_T arg5;Arg6_T arg6;Arg7_T arg7;
1280
+
1281
+ rb_scan_args(argc, argv, args->formatString(Num_Args),
1282
+ &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7);
1283
+
1284
+ Self_T * obj = from_ruby<Self_T *>(self);
1285
+ if(args->isOptional(0) && NIL_P(varg0)) { arg0 = args->get(0)->getDefaultValue<Arg0_T>(); } else { arg0 = from_ruby<Arg0_T>(varg0); }
1286
+ if(args->isOptional(1) && NIL_P(varg1)) { arg1 = args->get(1)->getDefaultValue<Arg1_T>(); } else { arg1 = from_ruby<Arg1_T>(varg1); }
1287
+ if(args->isOptional(2) && NIL_P(varg2)) { arg2 = args->get(2)->getDefaultValue<Arg2_T>(); } else { arg2 = from_ruby<Arg2_T>(varg2); }
1288
+ if(args->isOptional(3) && NIL_P(varg3)) { arg3 = args->get(3)->getDefaultValue<Arg3_T>(); } else { arg3 = from_ruby<Arg3_T>(varg3); }
1289
+ if(args->isOptional(4) && NIL_P(varg4)) { arg4 = args->get(4)->getDefaultValue<Arg4_T>(); } else { arg4 = from_ruby<Arg4_T>(varg4); }
1290
+ if(args->isOptional(5) && NIL_P(varg5)) { arg5 = args->get(5)->getDefaultValue<Arg5_T>(); } else { arg5 = from_ruby<Arg5_T>(varg5); }
1291
+ if(args->isOptional(6) && NIL_P(varg6)) { arg6 = args->get(6)->getDefaultValue<Arg6_T>(); } else { arg6 = from_ruby<Arg6_T>(varg6); }
1292
+ if(args->isOptional(7) && NIL_P(varg7)) { arg7 = args->get(7)->getDefaultValue<Arg7_T>(); } else { arg7 = from_ruby<Arg7_T>(varg7); }
1293
+
1294
+ Func func = wrapper->func_;
1295
+ (*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
1296
+ return Qnil;
1297
+ }
1298
+ catch(...)
1299
+ {
1300
+ RUBY_TRY
1301
+ {
1302
+ if(wrapper)
1303
+ {
1304
+ return wrapper->handler_->handle_exception();
1305
+ }
1306
+ else
1307
+ {
1308
+ throw;
1309
+ }
1310
+ }
1311
+ RUBY_CATCH
1312
+ }
1313
+ }
1314
+
1315
+ // ---------------------------------------------------------------------
1316
+ template<typename Func_T, typename Ret_T, typename Self_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T>
1317
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T>::
1318
+ Auto_Member_Function_Wrapper(
1319
+ Func func,
1320
+ Data_Object<Exception_Handler> handler,
1321
+ Arguments* arguments)
1322
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
1323
+ , func_(func)
1324
+ , handler_(handler)
1325
+ , handler_guard_(&handler_)
1326
+ , arguments_(arguments)
1327
+ {
1328
+ if(arguments == 0) {
1329
+ arguments_ = new Arguments();
1330
+ } else {
1331
+ arguments_ = arguments;
1332
+ }
1333
+ }
1334
+
1335
+ template<typename Func_T, typename Ret_T, typename Self_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T>
1336
+ VALUE Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T>::
1337
+ call(int argc, VALUE* argv, VALUE self)
1338
+ {
1339
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T> * wrapper = 0;
1340
+ try
1341
+ {
1342
+ Data_Object<Wrapped_Function> data(detail::method_data());
1343
+ wrapper =
1344
+ (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T> *)data.get();
1345
+ Arguments* args = wrapper->arguments_;
1346
+
1347
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6;
1348
+ Arg0_T arg0;Arg1_T arg1;Arg2_T arg2;Arg3_T arg3;Arg4_T arg4;Arg5_T arg5;Arg6_T arg6;
1349
+
1350
+ rb_scan_args(argc, argv, args->formatString(Num_Args),
1351
+ &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6);
1352
+
1353
+ Self_T * obj = from_ruby<Self_T *>(self);
1354
+ if(args->isOptional(0) && NIL_P(varg0)) { arg0 = args->get(0)->getDefaultValue<Arg0_T>(); } else { arg0 = from_ruby<Arg0_T>(varg0); }
1355
+ if(args->isOptional(1) && NIL_P(varg1)) { arg1 = args->get(1)->getDefaultValue<Arg1_T>(); } else { arg1 = from_ruby<Arg1_T>(varg1); }
1356
+ if(args->isOptional(2) && NIL_P(varg2)) { arg2 = args->get(2)->getDefaultValue<Arg2_T>(); } else { arg2 = from_ruby<Arg2_T>(varg2); }
1357
+ if(args->isOptional(3) && NIL_P(varg3)) { arg3 = args->get(3)->getDefaultValue<Arg3_T>(); } else { arg3 = from_ruby<Arg3_T>(varg3); }
1358
+ if(args->isOptional(4) && NIL_P(varg4)) { arg4 = args->get(4)->getDefaultValue<Arg4_T>(); } else { arg4 = from_ruby<Arg4_T>(varg4); }
1359
+ if(args->isOptional(5) && NIL_P(varg5)) { arg5 = args->get(5)->getDefaultValue<Arg5_T>(); } else { arg5 = from_ruby<Arg5_T>(varg5); }
1360
+ if(args->isOptional(6) && NIL_P(varg6)) { arg6 = args->get(6)->getDefaultValue<Arg6_T>(); } else { arg6 = from_ruby<Arg6_T>(varg6); }
1361
+
1362
+ Func func = wrapper->func_;
1363
+ return to_ruby((*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6));
1364
+ }
1365
+ catch(...)
1366
+ {
1367
+ RUBY_TRY
1368
+ {
1369
+ if(wrapper)
1370
+ {
1371
+ return wrapper->handler_->handle_exception();
1372
+ }
1373
+ else
1374
+ {
1375
+ throw;
1376
+ }
1377
+ }
1378
+ RUBY_CATCH
1379
+ }
1380
+ }
1381
+
1382
+ template<typename Func_T, typename Self_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T>
1383
+ Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T>::
1384
+ Auto_Member_Function_Wrapper(
1385
+ Func func,
1386
+ Data_Object<Exception_Handler> handler,
1387
+ Arguments* arguments)
1388
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
1389
+ , func_(func)
1390
+ , handler_(handler)
1391
+ , handler_guard_(&handler_)
1392
+ , arguments_(arguments)
1393
+ {
1394
+ if(arguments == 0) {
1395
+ arguments_ = new Arguments();
1396
+ } else {
1397
+ arguments_ = arguments;
1398
+ }
1399
+ }
1400
+
1401
+ template<typename Func_T, typename Self_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T>
1402
+ VALUE Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T>::
1403
+ call(int argc, VALUE* argv, VALUE self)
1404
+ {
1405
+ Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T> * wrapper = 0;
1406
+ try
1407
+ {
1408
+ Data_Object<Wrapped_Function> data(detail::method_data());
1409
+ wrapper =
1410
+ (Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T> *)data.get();
1411
+ Arguments* args = wrapper->arguments_;
1412
+
1413
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6;
1414
+ Arg0_T arg0;Arg1_T arg1;Arg2_T arg2;Arg3_T arg3;Arg4_T arg4;Arg5_T arg5;Arg6_T arg6;
1415
+
1416
+ rb_scan_args(argc, argv, args->formatString(Num_Args),
1417
+ &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6);
1418
+
1419
+ Self_T * obj = from_ruby<Self_T *>(self);
1420
+ if(args->isOptional(0) && NIL_P(varg0)) { arg0 = args->get(0)->getDefaultValue<Arg0_T>(); } else { arg0 = from_ruby<Arg0_T>(varg0); }
1421
+ if(args->isOptional(1) && NIL_P(varg1)) { arg1 = args->get(1)->getDefaultValue<Arg1_T>(); } else { arg1 = from_ruby<Arg1_T>(varg1); }
1422
+ if(args->isOptional(2) && NIL_P(varg2)) { arg2 = args->get(2)->getDefaultValue<Arg2_T>(); } else { arg2 = from_ruby<Arg2_T>(varg2); }
1423
+ if(args->isOptional(3) && NIL_P(varg3)) { arg3 = args->get(3)->getDefaultValue<Arg3_T>(); } else { arg3 = from_ruby<Arg3_T>(varg3); }
1424
+ if(args->isOptional(4) && NIL_P(varg4)) { arg4 = args->get(4)->getDefaultValue<Arg4_T>(); } else { arg4 = from_ruby<Arg4_T>(varg4); }
1425
+ if(args->isOptional(5) && NIL_P(varg5)) { arg5 = args->get(5)->getDefaultValue<Arg5_T>(); } else { arg5 = from_ruby<Arg5_T>(varg5); }
1426
+ if(args->isOptional(6) && NIL_P(varg6)) { arg6 = args->get(6)->getDefaultValue<Arg6_T>(); } else { arg6 = from_ruby<Arg6_T>(varg6); }
1427
+
1428
+ Func func = wrapper->func_;
1429
+ (*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
1430
+ return Qnil;
1431
+ }
1432
+ catch(...)
1433
+ {
1434
+ RUBY_TRY
1435
+ {
1436
+ if(wrapper)
1437
+ {
1438
+ return wrapper->handler_->handle_exception();
1439
+ }
1440
+ else
1441
+ {
1442
+ throw;
1443
+ }
1444
+ }
1445
+ RUBY_CATCH
1446
+ }
1447
+ }
1448
+
1449
+ // ---------------------------------------------------------------------
1450
+ template<typename Func_T, typename Ret_T, typename Self_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T>
1451
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T>::
1452
+ Auto_Member_Function_Wrapper(
1453
+ Func func,
1454
+ Data_Object<Exception_Handler> handler,
1455
+ Arguments* arguments)
1456
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
1457
+ , func_(func)
1458
+ , handler_(handler)
1459
+ , handler_guard_(&handler_)
1460
+ , arguments_(arguments)
1461
+ {
1462
+ if(arguments == 0) {
1463
+ arguments_ = new Arguments();
1464
+ } else {
1465
+ arguments_ = arguments;
1466
+ }
1467
+ }
1468
+
1469
+ template<typename Func_T, typename Ret_T, typename Self_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T>
1470
+ VALUE Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T>::
1471
+ call(int argc, VALUE* argv, VALUE self)
1472
+ {
1473
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T> * wrapper = 0;
1474
+ try
1475
+ {
1476
+ Data_Object<Wrapped_Function> data(detail::method_data());
1477
+ wrapper =
1478
+ (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T> *)data.get();
1479
+ Arguments* args = wrapper->arguments_;
1480
+
1481
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5;
1482
+ Arg0_T arg0;Arg1_T arg1;Arg2_T arg2;Arg3_T arg3;Arg4_T arg4;Arg5_T arg5;
1483
+
1484
+ rb_scan_args(argc, argv, args->formatString(Num_Args),
1485
+ &varg0, &varg1, &varg2, &varg3, &varg4, &varg5);
1486
+
1487
+ Self_T * obj = from_ruby<Self_T *>(self);
1488
+ if(args->isOptional(0) && NIL_P(varg0)) { arg0 = args->get(0)->getDefaultValue<Arg0_T>(); } else { arg0 = from_ruby<Arg0_T>(varg0); }
1489
+ if(args->isOptional(1) && NIL_P(varg1)) { arg1 = args->get(1)->getDefaultValue<Arg1_T>(); } else { arg1 = from_ruby<Arg1_T>(varg1); }
1490
+ if(args->isOptional(2) && NIL_P(varg2)) { arg2 = args->get(2)->getDefaultValue<Arg2_T>(); } else { arg2 = from_ruby<Arg2_T>(varg2); }
1491
+ if(args->isOptional(3) && NIL_P(varg3)) { arg3 = args->get(3)->getDefaultValue<Arg3_T>(); } else { arg3 = from_ruby<Arg3_T>(varg3); }
1492
+ if(args->isOptional(4) && NIL_P(varg4)) { arg4 = args->get(4)->getDefaultValue<Arg4_T>(); } else { arg4 = from_ruby<Arg4_T>(varg4); }
1493
+ if(args->isOptional(5) && NIL_P(varg5)) { arg5 = args->get(5)->getDefaultValue<Arg5_T>(); } else { arg5 = from_ruby<Arg5_T>(varg5); }
1494
+
1495
+ Func func = wrapper->func_;
1496
+ return to_ruby((*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5));
1497
+ }
1498
+ catch(...)
1499
+ {
1500
+ RUBY_TRY
1501
+ {
1502
+ if(wrapper)
1503
+ {
1504
+ return wrapper->handler_->handle_exception();
1505
+ }
1506
+ else
1507
+ {
1508
+ throw;
1509
+ }
1510
+ }
1511
+ RUBY_CATCH
1512
+ }
1513
+ }
1514
+
1515
+ template<typename Func_T, typename Self_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T>
1516
+ Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T>::
1517
+ Auto_Member_Function_Wrapper(
1518
+ Func func,
1519
+ Data_Object<Exception_Handler> handler,
1520
+ Arguments* arguments)
1521
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
1522
+ , func_(func)
1523
+ , handler_(handler)
1524
+ , handler_guard_(&handler_)
1525
+ , arguments_(arguments)
1526
+ {
1527
+ if(arguments == 0) {
1528
+ arguments_ = new Arguments();
1529
+ } else {
1530
+ arguments_ = arguments;
1531
+ }
1532
+ }
1533
+
1534
+ template<typename Func_T, typename Self_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T>
1535
+ VALUE Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T>::
1536
+ call(int argc, VALUE* argv, VALUE self)
1537
+ {
1538
+ Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T> * wrapper = 0;
1539
+ try
1540
+ {
1541
+ Data_Object<Wrapped_Function> data(detail::method_data());
1542
+ wrapper =
1543
+ (Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T> *)data.get();
1544
+ Arguments* args = wrapper->arguments_;
1545
+
1546
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5;
1547
+ Arg0_T arg0;Arg1_T arg1;Arg2_T arg2;Arg3_T arg3;Arg4_T arg4;Arg5_T arg5;
1548
+
1549
+ rb_scan_args(argc, argv, args->formatString(Num_Args),
1550
+ &varg0, &varg1, &varg2, &varg3, &varg4, &varg5);
1551
+
1552
+ Self_T * obj = from_ruby<Self_T *>(self);
1553
+ if(args->isOptional(0) && NIL_P(varg0)) { arg0 = args->get(0)->getDefaultValue<Arg0_T>(); } else { arg0 = from_ruby<Arg0_T>(varg0); }
1554
+ if(args->isOptional(1) && NIL_P(varg1)) { arg1 = args->get(1)->getDefaultValue<Arg1_T>(); } else { arg1 = from_ruby<Arg1_T>(varg1); }
1555
+ if(args->isOptional(2) && NIL_P(varg2)) { arg2 = args->get(2)->getDefaultValue<Arg2_T>(); } else { arg2 = from_ruby<Arg2_T>(varg2); }
1556
+ if(args->isOptional(3) && NIL_P(varg3)) { arg3 = args->get(3)->getDefaultValue<Arg3_T>(); } else { arg3 = from_ruby<Arg3_T>(varg3); }
1557
+ if(args->isOptional(4) && NIL_P(varg4)) { arg4 = args->get(4)->getDefaultValue<Arg4_T>(); } else { arg4 = from_ruby<Arg4_T>(varg4); }
1558
+ if(args->isOptional(5) && NIL_P(varg5)) { arg5 = args->get(5)->getDefaultValue<Arg5_T>(); } else { arg5 = from_ruby<Arg5_T>(varg5); }
1559
+
1560
+ Func func = wrapper->func_;
1561
+ (*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5);
1562
+ return Qnil;
1563
+ }
1564
+ catch(...)
1565
+ {
1566
+ RUBY_TRY
1567
+ {
1568
+ if(wrapper)
1569
+ {
1570
+ return wrapper->handler_->handle_exception();
1571
+ }
1572
+ else
1573
+ {
1574
+ throw;
1575
+ }
1576
+ }
1577
+ RUBY_CATCH
1578
+ }
1579
+ }
1580
+
1581
+ // ---------------------------------------------------------------------
1582
+ template<typename Func_T, typename Ret_T, typename Self_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T>
1583
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T>::
1584
+ Auto_Member_Function_Wrapper(
1585
+ Func func,
1586
+ Data_Object<Exception_Handler> handler,
1587
+ Arguments* arguments)
1588
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
1589
+ , func_(func)
1590
+ , handler_(handler)
1591
+ , handler_guard_(&handler_)
1592
+ , arguments_(arguments)
1593
+ {
1594
+ if(arguments == 0) {
1595
+ arguments_ = new Arguments();
1596
+ } else {
1597
+ arguments_ = arguments;
1598
+ }
1599
+ }
1600
+
1601
+ template<typename Func_T, typename Ret_T, typename Self_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T>
1602
+ VALUE Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T>::
1603
+ call(int argc, VALUE* argv, VALUE self)
1604
+ {
1605
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T> * wrapper = 0;
1606
+ try
1607
+ {
1608
+ Data_Object<Wrapped_Function> data(detail::method_data());
1609
+ wrapper =
1610
+ (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T> *)data.get();
1611
+ Arguments* args = wrapper->arguments_;
1612
+
1613
+ VALUE varg0, varg1, varg2, varg3, varg4;
1614
+ Arg0_T arg0;Arg1_T arg1;Arg2_T arg2;Arg3_T arg3;Arg4_T arg4;
1615
+
1616
+ rb_scan_args(argc, argv, args->formatString(Num_Args),
1617
+ &varg0, &varg1, &varg2, &varg3, &varg4);
1618
+
1619
+ Self_T * obj = from_ruby<Self_T *>(self);
1620
+ if(args->isOptional(0) && NIL_P(varg0)) { arg0 = args->get(0)->getDefaultValue<Arg0_T>(); } else { arg0 = from_ruby<Arg0_T>(varg0); }
1621
+ if(args->isOptional(1) && NIL_P(varg1)) { arg1 = args->get(1)->getDefaultValue<Arg1_T>(); } else { arg1 = from_ruby<Arg1_T>(varg1); }
1622
+ if(args->isOptional(2) && NIL_P(varg2)) { arg2 = args->get(2)->getDefaultValue<Arg2_T>(); } else { arg2 = from_ruby<Arg2_T>(varg2); }
1623
+ if(args->isOptional(3) && NIL_P(varg3)) { arg3 = args->get(3)->getDefaultValue<Arg3_T>(); } else { arg3 = from_ruby<Arg3_T>(varg3); }
1624
+ if(args->isOptional(4) && NIL_P(varg4)) { arg4 = args->get(4)->getDefaultValue<Arg4_T>(); } else { arg4 = from_ruby<Arg4_T>(varg4); }
1625
+
1626
+ Func func = wrapper->func_;
1627
+ return to_ruby((*obj.*func)(arg0, arg1, arg2, arg3, arg4));
1628
+ }
1629
+ catch(...)
1630
+ {
1631
+ RUBY_TRY
1632
+ {
1633
+ if(wrapper)
1634
+ {
1635
+ return wrapper->handler_->handle_exception();
1636
+ }
1637
+ else
1638
+ {
1639
+ throw;
1640
+ }
1641
+ }
1642
+ RUBY_CATCH
1643
+ }
1644
+ }
1645
+
1646
+ template<typename Func_T, typename Self_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T>
1647
+ Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T>::
1648
+ Auto_Member_Function_Wrapper(
1649
+ Func func,
1650
+ Data_Object<Exception_Handler> handler,
1651
+ Arguments* arguments)
1652
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
1653
+ , func_(func)
1654
+ , handler_(handler)
1655
+ , handler_guard_(&handler_)
1656
+ , arguments_(arguments)
1657
+ {
1658
+ if(arguments == 0) {
1659
+ arguments_ = new Arguments();
1660
+ } else {
1661
+ arguments_ = arguments;
1662
+ }
1663
+ }
1664
+
1665
+ template<typename Func_T, typename Self_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T>
1666
+ VALUE Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T>::
1667
+ call(int argc, VALUE* argv, VALUE self)
1668
+ {
1669
+ Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T> * wrapper = 0;
1670
+ try
1671
+ {
1672
+ Data_Object<Wrapped_Function> data(detail::method_data());
1673
+ wrapper =
1674
+ (Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T> *)data.get();
1675
+ Arguments* args = wrapper->arguments_;
1676
+
1677
+ VALUE varg0, varg1, varg2, varg3, varg4;
1678
+ Arg0_T arg0;Arg1_T arg1;Arg2_T arg2;Arg3_T arg3;Arg4_T arg4;
1679
+
1680
+ rb_scan_args(argc, argv, args->formatString(Num_Args),
1681
+ &varg0, &varg1, &varg2, &varg3, &varg4);
1682
+
1683
+ Self_T * obj = from_ruby<Self_T *>(self);
1684
+ if(args->isOptional(0) && NIL_P(varg0)) { arg0 = args->get(0)->getDefaultValue<Arg0_T>(); } else { arg0 = from_ruby<Arg0_T>(varg0); }
1685
+ if(args->isOptional(1) && NIL_P(varg1)) { arg1 = args->get(1)->getDefaultValue<Arg1_T>(); } else { arg1 = from_ruby<Arg1_T>(varg1); }
1686
+ if(args->isOptional(2) && NIL_P(varg2)) { arg2 = args->get(2)->getDefaultValue<Arg2_T>(); } else { arg2 = from_ruby<Arg2_T>(varg2); }
1687
+ if(args->isOptional(3) && NIL_P(varg3)) { arg3 = args->get(3)->getDefaultValue<Arg3_T>(); } else { arg3 = from_ruby<Arg3_T>(varg3); }
1688
+ if(args->isOptional(4) && NIL_P(varg4)) { arg4 = args->get(4)->getDefaultValue<Arg4_T>(); } else { arg4 = from_ruby<Arg4_T>(varg4); }
1689
+
1690
+ Func func = wrapper->func_;
1691
+ (*obj.*func)(arg0, arg1, arg2, arg3, arg4);
1692
+ return Qnil;
1693
+ }
1694
+ catch(...)
1695
+ {
1696
+ RUBY_TRY
1697
+ {
1698
+ if(wrapper)
1699
+ {
1700
+ return wrapper->handler_->handle_exception();
1701
+ }
1702
+ else
1703
+ {
1704
+ throw;
1705
+ }
1706
+ }
1707
+ RUBY_CATCH
1708
+ }
1709
+ }
1710
+
1711
+ // ---------------------------------------------------------------------
1712
+ template<typename Func_T, typename Ret_T, typename Self_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T>
1713
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T>::
1714
+ Auto_Member_Function_Wrapper(
1715
+ Func func,
1716
+ Data_Object<Exception_Handler> handler,
1717
+ Arguments* arguments)
1718
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
1719
+ , func_(func)
1720
+ , handler_(handler)
1721
+ , handler_guard_(&handler_)
1722
+ , arguments_(arguments)
1723
+ {
1724
+ if(arguments == 0) {
1725
+ arguments_ = new Arguments();
1726
+ } else {
1727
+ arguments_ = arguments;
1728
+ }
1729
+ }
1730
+
1731
+ template<typename Func_T, typename Ret_T, typename Self_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T>
1732
+ VALUE Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T>::
1733
+ call(int argc, VALUE* argv, VALUE self)
1734
+ {
1735
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T> * wrapper = 0;
1736
+ try
1737
+ {
1738
+ Data_Object<Wrapped_Function> data(detail::method_data());
1739
+ wrapper =
1740
+ (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T> *)data.get();
1741
+ Arguments* args = wrapper->arguments_;
1742
+
1743
+ VALUE varg0, varg1, varg2, varg3;
1744
+ Arg0_T arg0;Arg1_T arg1;Arg2_T arg2;Arg3_T arg3;
1745
+
1746
+ rb_scan_args(argc, argv, args->formatString(Num_Args),
1747
+ &varg0, &varg1, &varg2, &varg3);
1748
+
1749
+ Self_T * obj = from_ruby<Self_T *>(self);
1750
+ if(args->isOptional(0) && NIL_P(varg0)) { arg0 = args->get(0)->getDefaultValue<Arg0_T>(); } else { arg0 = from_ruby<Arg0_T>(varg0); }
1751
+ if(args->isOptional(1) && NIL_P(varg1)) { arg1 = args->get(1)->getDefaultValue<Arg1_T>(); } else { arg1 = from_ruby<Arg1_T>(varg1); }
1752
+ if(args->isOptional(2) && NIL_P(varg2)) { arg2 = args->get(2)->getDefaultValue<Arg2_T>(); } else { arg2 = from_ruby<Arg2_T>(varg2); }
1753
+ if(args->isOptional(3) && NIL_P(varg3)) { arg3 = args->get(3)->getDefaultValue<Arg3_T>(); } else { arg3 = from_ruby<Arg3_T>(varg3); }
1754
+
1755
+ Func func = wrapper->func_;
1756
+ return to_ruby((*obj.*func)(arg0, arg1, arg2, arg3));
1757
+ }
1758
+ catch(...)
1759
+ {
1760
+ RUBY_TRY
1761
+ {
1762
+ if(wrapper)
1763
+ {
1764
+ return wrapper->handler_->handle_exception();
1765
+ }
1766
+ else
1767
+ {
1768
+ throw;
1769
+ }
1770
+ }
1771
+ RUBY_CATCH
1772
+ }
1773
+ }
1774
+
1775
+ template<typename Func_T, typename Self_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T>
1776
+ Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T>::
1777
+ Auto_Member_Function_Wrapper(
1778
+ Func func,
1779
+ Data_Object<Exception_Handler> handler,
1780
+ Arguments* arguments)
1781
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
1782
+ , func_(func)
1783
+ , handler_(handler)
1784
+ , handler_guard_(&handler_)
1785
+ , arguments_(arguments)
1786
+ {
1787
+ if(arguments == 0) {
1788
+ arguments_ = new Arguments();
1789
+ } else {
1790
+ arguments_ = arguments;
1791
+ }
1792
+ }
1793
+
1794
+ template<typename Func_T, typename Self_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T>
1795
+ VALUE Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T>::
1796
+ call(int argc, VALUE* argv, VALUE self)
1797
+ {
1798
+ Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T> * wrapper = 0;
1799
+ try
1800
+ {
1801
+ Data_Object<Wrapped_Function> data(detail::method_data());
1802
+ wrapper =
1803
+ (Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T> *)data.get();
1804
+ Arguments* args = wrapper->arguments_;
1805
+
1806
+ VALUE varg0, varg1, varg2, varg3;
1807
+ Arg0_T arg0;Arg1_T arg1;Arg2_T arg2;Arg3_T arg3;
1808
+
1809
+ rb_scan_args(argc, argv, args->formatString(Num_Args),
1810
+ &varg0, &varg1, &varg2, &varg3);
1811
+
1812
+ Self_T * obj = from_ruby<Self_T *>(self);
1813
+ if(args->isOptional(0) && NIL_P(varg0)) { arg0 = args->get(0)->getDefaultValue<Arg0_T>(); } else { arg0 = from_ruby<Arg0_T>(varg0); }
1814
+ if(args->isOptional(1) && NIL_P(varg1)) { arg1 = args->get(1)->getDefaultValue<Arg1_T>(); } else { arg1 = from_ruby<Arg1_T>(varg1); }
1815
+ if(args->isOptional(2) && NIL_P(varg2)) { arg2 = args->get(2)->getDefaultValue<Arg2_T>(); } else { arg2 = from_ruby<Arg2_T>(varg2); }
1816
+ if(args->isOptional(3) && NIL_P(varg3)) { arg3 = args->get(3)->getDefaultValue<Arg3_T>(); } else { arg3 = from_ruby<Arg3_T>(varg3); }
1817
+
1818
+ Func func = wrapper->func_;
1819
+ (*obj.*func)(arg0, arg1, arg2, arg3);
1820
+ return Qnil;
1821
+ }
1822
+ catch(...)
1823
+ {
1824
+ RUBY_TRY
1825
+ {
1826
+ if(wrapper)
1827
+ {
1828
+ return wrapper->handler_->handle_exception();
1829
+ }
1830
+ else
1831
+ {
1832
+ throw;
1833
+ }
1834
+ }
1835
+ RUBY_CATCH
1836
+ }
1837
+ }
1838
+
1839
+ // ---------------------------------------------------------------------
1840
+ template<typename Func_T, typename Ret_T, typename Self_T, typename Arg0_T, typename Arg1_T, typename Arg2_T>
1841
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T>::
1842
+ Auto_Member_Function_Wrapper(
1843
+ Func func,
1844
+ Data_Object<Exception_Handler> handler,
1845
+ Arguments* arguments)
1846
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
1847
+ , func_(func)
1848
+ , handler_(handler)
1849
+ , handler_guard_(&handler_)
1850
+ , arguments_(arguments)
1851
+ {
1852
+ if(arguments == 0) {
1853
+ arguments_ = new Arguments();
1854
+ } else {
1855
+ arguments_ = arguments;
1856
+ }
1857
+ }
1858
+
1859
+ template<typename Func_T, typename Ret_T, typename Self_T, typename Arg0_T, typename Arg1_T, typename Arg2_T>
1860
+ VALUE Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T>::
1861
+ call(int argc, VALUE* argv, VALUE self)
1862
+ {
1863
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T> * wrapper = 0;
1864
+ try
1865
+ {
1866
+ Data_Object<Wrapped_Function> data(detail::method_data());
1867
+ wrapper =
1868
+ (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T> *)data.get();
1869
+ Arguments* args = wrapper->arguments_;
1870
+
1871
+ VALUE varg0, varg1, varg2;
1872
+ Arg0_T arg0;Arg1_T arg1;Arg2_T arg2;
1873
+
1874
+ rb_scan_args(argc, argv, args->formatString(Num_Args),
1875
+ &varg0, &varg1, &varg2);
1876
+
1877
+ Self_T * obj = from_ruby<Self_T *>(self);
1878
+ if(args->isOptional(0) && NIL_P(varg0)) { arg0 = args->get(0)->getDefaultValue<Arg0_T>(); } else { arg0 = from_ruby<Arg0_T>(varg0); }
1879
+ if(args->isOptional(1) && NIL_P(varg1)) { arg1 = args->get(1)->getDefaultValue<Arg1_T>(); } else { arg1 = from_ruby<Arg1_T>(varg1); }
1880
+ if(args->isOptional(2) && NIL_P(varg2)) { arg2 = args->get(2)->getDefaultValue<Arg2_T>(); } else { arg2 = from_ruby<Arg2_T>(varg2); }
1881
+
1882
+ Func func = wrapper->func_;
1883
+ return to_ruby((*obj.*func)(arg0, arg1, arg2));
1884
+ }
1885
+ catch(...)
1886
+ {
1887
+ RUBY_TRY
1888
+ {
1889
+ if(wrapper)
1890
+ {
1891
+ return wrapper->handler_->handle_exception();
1892
+ }
1893
+ else
1894
+ {
1895
+ throw;
1896
+ }
1897
+ }
1898
+ RUBY_CATCH
1899
+ }
1900
+ }
1901
+
1902
+ template<typename Func_T, typename Self_T, typename Arg0_T, typename Arg1_T, typename Arg2_T>
1903
+ Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T>::
1904
+ Auto_Member_Function_Wrapper(
1905
+ Func func,
1906
+ Data_Object<Exception_Handler> handler,
1907
+ Arguments* arguments)
1908
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
1909
+ , func_(func)
1910
+ , handler_(handler)
1911
+ , handler_guard_(&handler_)
1912
+ , arguments_(arguments)
1913
+ {
1914
+ if(arguments == 0) {
1915
+ arguments_ = new Arguments();
1916
+ } else {
1917
+ arguments_ = arguments;
1918
+ }
1919
+ }
1920
+
1921
+ template<typename Func_T, typename Self_T, typename Arg0_T, typename Arg1_T, typename Arg2_T>
1922
+ VALUE Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T>::
1923
+ call(int argc, VALUE* argv, VALUE self)
1924
+ {
1925
+ Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T> * wrapper = 0;
1926
+ try
1927
+ {
1928
+ Data_Object<Wrapped_Function> data(detail::method_data());
1929
+ wrapper =
1930
+ (Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T> *)data.get();
1931
+ Arguments* args = wrapper->arguments_;
1932
+
1933
+ VALUE varg0, varg1, varg2;
1934
+ Arg0_T arg0;Arg1_T arg1;Arg2_T arg2;
1935
+
1936
+ rb_scan_args(argc, argv, args->formatString(Num_Args),
1937
+ &varg0, &varg1, &varg2);
1938
+
1939
+ Self_T * obj = from_ruby<Self_T *>(self);
1940
+ if(args->isOptional(0) && NIL_P(varg0)) { arg0 = args->get(0)->getDefaultValue<Arg0_T>(); } else { arg0 = from_ruby<Arg0_T>(varg0); }
1941
+ if(args->isOptional(1) && NIL_P(varg1)) { arg1 = args->get(1)->getDefaultValue<Arg1_T>(); } else { arg1 = from_ruby<Arg1_T>(varg1); }
1942
+ if(args->isOptional(2) && NIL_P(varg2)) { arg2 = args->get(2)->getDefaultValue<Arg2_T>(); } else { arg2 = from_ruby<Arg2_T>(varg2); }
1943
+
1944
+ Func func = wrapper->func_;
1945
+ (*obj.*func)(arg0, arg1, arg2);
1946
+ return Qnil;
1947
+ }
1948
+ catch(...)
1949
+ {
1950
+ RUBY_TRY
1951
+ {
1952
+ if(wrapper)
1953
+ {
1954
+ return wrapper->handler_->handle_exception();
1955
+ }
1956
+ else
1957
+ {
1958
+ throw;
1959
+ }
1960
+ }
1961
+ RUBY_CATCH
1962
+ }
1963
+ }
1964
+
1965
+ // ---------------------------------------------------------------------
1966
+ template<typename Func_T, typename Ret_T, typename Self_T, typename Arg0_T, typename Arg1_T>
1967
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T>::
1968
+ Auto_Member_Function_Wrapper(
1969
+ Func func,
1970
+ Data_Object<Exception_Handler> handler,
1971
+ Arguments* arguments)
1972
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
1973
+ , func_(func)
1974
+ , handler_(handler)
1975
+ , handler_guard_(&handler_)
1976
+ , arguments_(arguments)
1977
+ {
1978
+ if(arguments == 0) {
1979
+ arguments_ = new Arguments();
1980
+ } else {
1981
+ arguments_ = arguments;
1982
+ }
1983
+ }
1984
+
1985
+ template<typename Func_T, typename Ret_T, typename Self_T, typename Arg0_T, typename Arg1_T>
1986
+ VALUE Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T>::
1987
+ call(int argc, VALUE* argv, VALUE self)
1988
+ {
1989
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T> * wrapper = 0;
1990
+ try
1991
+ {
1992
+ Data_Object<Wrapped_Function> data(detail::method_data());
1993
+ wrapper =
1994
+ (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T> *)data.get();
1995
+ Arguments* args = wrapper->arguments_;
1996
+
1997
+ VALUE varg0, varg1;
1998
+ Arg0_T arg0;Arg1_T arg1;
1999
+
2000
+ rb_scan_args(argc, argv, args->formatString(Num_Args),
2001
+ &varg0, &varg1);
2002
+
2003
+ Self_T * obj = from_ruby<Self_T *>(self);
2004
+ if(args->isOptional(0) && NIL_P(varg0)) { arg0 = args->get(0)->getDefaultValue<Arg0_T>(); } else { arg0 = from_ruby<Arg0_T>(varg0); }
2005
+ if(args->isOptional(1) && NIL_P(varg1)) { arg1 = args->get(1)->getDefaultValue<Arg1_T>(); } else { arg1 = from_ruby<Arg1_T>(varg1); }
2006
+
2007
+ Func func = wrapper->func_;
2008
+ return to_ruby((*obj.*func)(arg0, arg1));
2009
+ }
2010
+ catch(...)
2011
+ {
2012
+ RUBY_TRY
2013
+ {
2014
+ if(wrapper)
2015
+ {
2016
+ return wrapper->handler_->handle_exception();
2017
+ }
2018
+ else
2019
+ {
2020
+ throw;
2021
+ }
2022
+ }
2023
+ RUBY_CATCH
2024
+ }
2025
+ }
2026
+
2027
+ template<typename Func_T, typename Self_T, typename Arg0_T, typename Arg1_T>
2028
+ Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T>::
2029
+ Auto_Member_Function_Wrapper(
2030
+ Func func,
2031
+ Data_Object<Exception_Handler> handler,
2032
+ Arguments* arguments)
2033
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
2034
+ , func_(func)
2035
+ , handler_(handler)
2036
+ , handler_guard_(&handler_)
2037
+ , arguments_(arguments)
2038
+ {
2039
+ if(arguments == 0) {
2040
+ arguments_ = new Arguments();
2041
+ } else {
2042
+ arguments_ = arguments;
2043
+ }
2044
+ }
2045
+
2046
+ template<typename Func_T, typename Self_T, typename Arg0_T, typename Arg1_T>
2047
+ VALUE Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T>::
2048
+ call(int argc, VALUE* argv, VALUE self)
2049
+ {
2050
+ Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T> * wrapper = 0;
2051
+ try
2052
+ {
2053
+ Data_Object<Wrapped_Function> data(detail::method_data());
2054
+ wrapper =
2055
+ (Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T> *)data.get();
2056
+ Arguments* args = wrapper->arguments_;
2057
+
2058
+ VALUE varg0, varg1;
2059
+ Arg0_T arg0;Arg1_T arg1;
2060
+
2061
+ rb_scan_args(argc, argv, args->formatString(Num_Args),
2062
+ &varg0, &varg1);
2063
+
2064
+ Self_T * obj = from_ruby<Self_T *>(self);
2065
+ if(args->isOptional(0) && NIL_P(varg0)) { arg0 = args->get(0)->getDefaultValue<Arg0_T>(); } else { arg0 = from_ruby<Arg0_T>(varg0); }
2066
+ if(args->isOptional(1) && NIL_P(varg1)) { arg1 = args->get(1)->getDefaultValue<Arg1_T>(); } else { arg1 = from_ruby<Arg1_T>(varg1); }
2067
+
2068
+ Func func = wrapper->func_;
2069
+ (*obj.*func)(arg0, arg1);
2070
+ return Qnil;
2071
+ }
2072
+ catch(...)
2073
+ {
2074
+ RUBY_TRY
2075
+ {
2076
+ if(wrapper)
2077
+ {
2078
+ return wrapper->handler_->handle_exception();
2079
+ }
2080
+ else
2081
+ {
2082
+ throw;
2083
+ }
2084
+ }
2085
+ RUBY_CATCH
2086
+ }
2087
+ }
2088
+
2089
+ // ---------------------------------------------------------------------
2090
+ template<typename Func_T, typename Ret_T, typename Self_T, typename Arg0_T>
2091
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T>::
2092
+ Auto_Member_Function_Wrapper(
2093
+ Func func,
2094
+ Data_Object<Exception_Handler> handler,
2095
+ Arguments* arguments)
2096
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
2097
+ , func_(func)
2098
+ , handler_(handler)
2099
+ , handler_guard_(&handler_)
2100
+ , arguments_(arguments)
2101
+ {
2102
+ if(arguments == 0) {
2103
+ arguments_ = new Arguments();
2104
+ } else {
2105
+ arguments_ = arguments;
2106
+ }
2107
+ }
2108
+
2109
+ template<typename Func_T, typename Ret_T, typename Self_T, typename Arg0_T>
2110
+ VALUE Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T>::
2111
+ call(int argc, VALUE* argv, VALUE self)
2112
+ {
2113
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T> * wrapper = 0;
2114
+ try
2115
+ {
2116
+ Data_Object<Wrapped_Function> data(detail::method_data());
2117
+ wrapper =
2118
+ (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T> *)data.get();
2119
+ Arguments* args = wrapper->arguments_;
2120
+
2121
+ VALUE varg0;
2122
+ Arg0_T arg0;
2123
+
2124
+ rb_scan_args(argc, argv, args->formatString(Num_Args),
2125
+ &varg0);
2126
+
2127
+ Self_T * obj = from_ruby<Self_T *>(self);
2128
+ if(args->isOptional(0) && NIL_P(varg0)) { arg0 = args->get(0)->getDefaultValue<Arg0_T>(); } else { arg0 = from_ruby<Arg0_T>(varg0); }
2129
+
2130
+ Func func = wrapper->func_;
2131
+ return to_ruby((*obj.*func)(arg0));
2132
+ }
2133
+ catch(...)
2134
+ {
2135
+ RUBY_TRY
2136
+ {
2137
+ if(wrapper)
2138
+ {
2139
+ return wrapper->handler_->handle_exception();
2140
+ }
2141
+ else
2142
+ {
2143
+ throw;
2144
+ }
2145
+ }
2146
+ RUBY_CATCH
2147
+ }
2148
+ }
2149
+
2150
+ template<typename Func_T, typename Self_T, typename Arg0_T>
2151
+ Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T>::
2152
+ Auto_Member_Function_Wrapper(
2153
+ Func func,
2154
+ Data_Object<Exception_Handler> handler,
2155
+ Arguments* arguments)
2156
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
2157
+ , func_(func)
2158
+ , handler_(handler)
2159
+ , handler_guard_(&handler_)
2160
+ , arguments_(arguments)
2161
+ {
2162
+ if(arguments == 0) {
2163
+ arguments_ = new Arguments();
2164
+ } else {
2165
+ arguments_ = arguments;
2166
+ }
2167
+ }
2168
+
2169
+ template<typename Func_T, typename Self_T, typename Arg0_T>
2170
+ VALUE Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T>::
2171
+ call(int argc, VALUE* argv, VALUE self)
2172
+ {
2173
+ Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T> * wrapper = 0;
2174
+ try
2175
+ {
2176
+ Data_Object<Wrapped_Function> data(detail::method_data());
2177
+ wrapper =
2178
+ (Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T> *)data.get();
2179
+ Arguments* args = wrapper->arguments_;
2180
+
2181
+ VALUE varg0;
2182
+ Arg0_T arg0;
2183
+
2184
+ rb_scan_args(argc, argv, args->formatString(Num_Args),
2185
+ &varg0);
2186
+
2187
+ Self_T * obj = from_ruby<Self_T *>(self);
2188
+ if(args->isOptional(0) && NIL_P(varg0)) { arg0 = args->get(0)->getDefaultValue<Arg0_T>(); } else { arg0 = from_ruby<Arg0_T>(varg0); }
2189
+
2190
+ Func func = wrapper->func_;
2191
+ (*obj.*func)(arg0);
2192
+ return Qnil;
2193
+ }
2194
+ catch(...)
2195
+ {
2196
+ RUBY_TRY
2197
+ {
2198
+ if(wrapper)
2199
+ {
2200
+ return wrapper->handler_->handle_exception();
2201
+ }
2202
+ else
2203
+ {
2204
+ throw;
2205
+ }
2206
+ }
2207
+ RUBY_CATCH
2208
+ }
2209
+ }
2210
+
2211
+ // ---------------------------------------------------------------------
2212
+ template<typename Func_T, typename Ret_T, typename Self_T>
2213
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T>::
2214
+ Auto_Member_Function_Wrapper(
2215
+ Func func,
2216
+ Data_Object<Exception_Handler> handler,
2217
+ Arguments* arguments)
2218
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
2219
+ , func_(func)
2220
+ , handler_(handler)
2221
+ , handler_guard_(&handler_)
2222
+ , arguments_(arguments)
2223
+ {
2224
+ if(arguments == 0) {
2225
+ arguments_ = new Arguments();
2226
+ } else {
2227
+ arguments_ = arguments;
2228
+ }
2229
+ }
2230
+
2231
+ template<typename Func_T, typename Ret_T, typename Self_T>
2232
+ VALUE Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T>::
2233
+ call(int argc, VALUE* argv, VALUE self)
2234
+ {
2235
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T> * wrapper = 0;
2236
+ try
2237
+ {
2238
+ Data_Object<Wrapped_Function> data(detail::method_data());
2239
+ wrapper =
2240
+ (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T> *)data.get();
2241
+
2242
+ rb_scan_args(argc, argv, "0");
2243
+ Self_T * obj = from_ruby<Self_T *>(self);
2244
+
2245
+ Func func = wrapper->func_;
2246
+ return to_ruby((*obj.*func)());
2247
+ }
2248
+ catch(...)
2249
+ {
2250
+ RUBY_TRY
2251
+ {
2252
+ if(wrapper)
2253
+ {
2254
+ return wrapper->handler_->handle_exception();
2255
+ }
2256
+ else
2257
+ {
2258
+ throw;
2259
+ }
2260
+ }
2261
+ RUBY_CATCH
2262
+ }
2263
+ }
2264
+
2265
+ template<typename Func_T, typename Self_T>
2266
+ Auto_Member_Function_Wrapper<Func_T, void, Self_T>::
2267
+ Auto_Member_Function_Wrapper(
2268
+ Func func,
2269
+ Data_Object<Exception_Handler> handler,
2270
+ Arguments* arguments)
2271
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
2272
+ , func_(func)
2273
+ , handler_(handler)
2274
+ , handler_guard_(&handler_)
2275
+ , arguments_(arguments)
2276
+ {
2277
+ if(arguments == 0) {
2278
+ arguments_ = new Arguments();
2279
+ } else {
2280
+ arguments_ = arguments;
2281
+ }
2282
+ }
2283
+
2284
+ template<typename Func_T, typename Self_T>
2285
+ VALUE Auto_Member_Function_Wrapper<Func_T, void, Self_T>::
2286
+ call(int argc, VALUE* argv, VALUE self)
2287
+ {
2288
+ Auto_Member_Function_Wrapper<Func_T, void, Self_T> * wrapper = 0;
2289
+ try
2290
+ {
2291
+ Data_Object<Wrapped_Function> data(detail::method_data());
2292
+ wrapper =
2293
+ (Auto_Member_Function_Wrapper<Func_T, void, Self_T> *)data.get();
2294
+ rb_scan_args(argc, argv, "0");
2295
+ Self_T * obj = from_ruby<Self_T *>(self);
2296
+
2297
+ Func func = wrapper->func_;
2298
+ (*obj.*func)();
2299
+ return Qnil;
2300
+ }
2301
+ catch(...)
2302
+ {
2303
+ RUBY_TRY
2304
+ {
2305
+ if(wrapper)
2306
+ {
2307
+ return wrapper->handler_->handle_exception();
2308
+ }
2309
+ else
2310
+ {
2311
+ throw;
2312
+ }
2313
+ }
2314
+ RUBY_CATCH
2315
+ }
2316
+ }
2317
+
2318
+ // ---------------------------------------------------------------------
2319
+
2320
+ } // namespace detail
2321
+
2322
+ } // namespace Rice
2323
+
2324
+
2325
+ #endif // Rice__detail__Auto_Member_Function_Wrapper__ipp_
2326
+