rice 3.0.0 → 4.0.3
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +4 -4
- data/CHANGELOG.md +121 -0
- data/CONTRIBUTORS.md +19 -0
- data/Gemfile +3 -0
- data/README.md +44 -1025
- data/Rakefile +95 -12
- data/include/rice/rice.hpp +7766 -0
- data/include/rice/stl.hpp +1113 -0
- data/lib/mkmf-rice.rb +127 -0
- data/lib/version.rb +3 -0
- data/rice/Address_Registration_Guard.ipp +75 -32
- data/rice/Address_Registration_Guard_defn.hpp +60 -56
- data/rice/Arg.hpp +80 -4
- data/rice/Arg.ipp +51 -0
- data/rice/Constructor.hpp +12 -14
- data/rice/Data_Object.ipp +234 -107
- data/rice/Data_Object_defn.hpp +77 -117
- data/rice/Data_Type.hpp +1 -2
- data/rice/Data_Type.ipp +251 -295
- data/rice/Data_Type_defn.hpp +175 -243
- data/rice/Director.hpp +11 -6
- data/rice/Enum.hpp +54 -104
- data/rice/Enum.ipp +104 -230
- data/rice/Exception.hpp +2 -8
- data/rice/Exception.ipp +65 -0
- data/rice/Exception_defn.hpp +46 -47
- data/rice/Identifier.hpp +28 -28
- data/rice/Identifier.ipp +23 -27
- data/rice/Return.hpp +39 -0
- data/rice/Return.ipp +33 -0
- data/rice/detail/Exception_Handler.ipp +22 -62
- data/rice/detail/Exception_Handler_defn.hpp +76 -91
- data/rice/detail/Iterator.hpp +18 -88
- data/rice/detail/Iterator.ipp +47 -0
- data/rice/detail/Jump_Tag.hpp +21 -0
- data/rice/detail/MethodInfo.hpp +44 -0
- data/rice/detail/MethodInfo.ipp +78 -0
- data/rice/detail/NativeAttribute.hpp +53 -0
- data/rice/detail/NativeAttribute.ipp +83 -0
- data/rice/detail/NativeFunction.hpp +69 -0
- data/rice/detail/NativeFunction.ipp +248 -0
- data/rice/detail/RubyFunction.hpp +39 -0
- data/rice/detail/RubyFunction.ipp +92 -0
- data/rice/detail/Type.hpp +29 -0
- data/rice/detail/Type.ipp +138 -0
- data/rice/detail/TypeRegistry.hpp +50 -0
- data/rice/detail/TypeRegistry.ipp +106 -0
- data/rice/detail/Wrapper.hpp +51 -0
- data/rice/detail/Wrapper.ipp +151 -0
- data/rice/detail/default_allocation_func.hpp +8 -19
- data/rice/detail/default_allocation_func.ipp +9 -8
- data/rice/detail/from_ruby.hpp +2 -37
- data/rice/detail/from_ruby.ipp +1020 -46
- data/rice/detail/from_ruby_defn.hpp +38 -0
- data/rice/detail/function_traits.hpp +124 -0
- data/rice/detail/method_data.hpp +23 -15
- data/rice/detail/method_data.ipp +53 -0
- data/rice/detail/rice_traits.hpp +116 -0
- data/rice/detail/ruby.hpp +9 -46
- data/rice/detail/to_ruby.hpp +3 -17
- data/rice/detail/to_ruby.ipp +409 -31
- data/rice/detail/to_ruby_defn.hpp +48 -0
- data/rice/forward_declares.ipp +82 -0
- data/rice/global_function.hpp +16 -20
- data/rice/global_function.ipp +8 -17
- data/rice/rice.hpp +59 -0
- data/rice/ruby_mark.hpp +5 -3
- data/rice/ruby_try_catch.hpp +4 -4
- data/rice/stl.hpp +11 -0
- data/sample/callbacks/extconf.rb +3 -0
- data/sample/callbacks/sample_callbacks.cpp +10 -13
- data/sample/enum/extconf.rb +3 -0
- data/sample/enum/sample_enum.cpp +3 -17
- data/sample/enum/test.rb +2 -2
- data/sample/inheritance/animals.cpp +8 -24
- data/sample/inheritance/extconf.rb +3 -0
- data/sample/inheritance/test.rb +1 -1
- data/sample/map/extconf.rb +3 -0
- data/sample/map/map.cpp +10 -18
- data/sample/map/test.rb +1 -1
- data/test/embed_ruby.cpp +18 -5
- data/test/ext/t1/extconf.rb +3 -0
- data/test/ext/t1/t1.cpp +1 -3
- data/test/ext/t2/extconf.rb +3 -0
- data/test/ext/t2/t2.cpp +1 -1
- data/test/extconf.rb +23 -0
- data/test/ruby/test_callbacks_sample.rb +28 -0
- data/test/ruby/test_multiple_extensions.rb +18 -0
- data/test/ruby/test_multiple_extensions_same_class.rb +14 -0
- data/test/ruby/test_multiple_extensions_with_inheritance.rb +20 -0
- data/test/test_Address_Registration_Guard.cpp +23 -10
- data/test/test_Array.cpp +129 -73
- data/test/test_Attribute.cpp +147 -0
- data/test/test_Builtin_Object.cpp +34 -14
- data/test/test_Class.cpp +149 -275
- data/test/test_Constructor.cpp +10 -9
- data/test/test_Data_Object.cpp +133 -192
- data/test/test_Data_Type.cpp +322 -252
- data/test/test_Director.cpp +54 -41
- data/test/test_Enum.cpp +228 -103
- data/test/test_Exception.cpp +5 -6
- data/test/test_Hash.cpp +31 -30
- data/test/test_Identifier.cpp +4 -5
- data/test/test_Inheritance.cpp +221 -0
- data/test/test_Iterator.cpp +161 -0
- data/test/test_Jump_Tag.cpp +1 -1
- data/test/test_Keep_Alive.cpp +161 -0
- data/test/test_Memory_Management.cpp +2 -4
- data/test/test_Module.cpp +167 -110
- data/test/test_Object.cpp +41 -21
- data/test/test_Ownership.cpp +275 -0
- data/test/test_Self.cpp +205 -0
- data/test/test_Stl_Optional.cpp +90 -0
- data/test/test_Stl_Pair.cpp +144 -0
- data/test/test_Stl_SmartPointer.cpp +200 -0
- data/test/test_Stl_String.cpp +74 -0
- data/test/test_Stl_Vector.cpp +652 -0
- data/test/test_String.cpp +1 -2
- data/test/test_Struct.cpp +29 -39
- data/test/test_Symbol.cpp +1 -2
- data/test/test_To_From_Ruby.cpp +249 -285
- data/test/test_global_functions.cpp +39 -19
- data/test/unittest.hpp +0 -4
- metadata +70 -141
- data/Doxyfile +0 -2268
- data/Makefile.am +0 -26
- data/Makefile.in +0 -931
- data/README.mingw +0 -8
- data/aclocal.m4 +0 -1085
- data/ax_cxx_compile_stdcxx.m4 +0 -951
- data/bootstrap +0 -8
- data/config.guess +0 -1421
- data/config.sub +0 -1807
- data/configure +0 -7792
- data/configure.ac +0 -55
- data/depcomp +0 -791
- data/doxygen.ac +0 -314
- data/doxygen.am +0 -186
- data/extconf.rb +0 -70
- data/install-sh +0 -501
- data/missing +0 -215
- data/post-autoconf.rb +0 -22
- data/post-automake.rb +0 -28
- data/rice/Address_Registration_Guard.cpp +0 -22
- data/rice/Arg_impl.hpp +0 -129
- data/rice/Arg_operators.cpp +0 -21
- data/rice/Arg_operators.hpp +0 -19
- data/rice/Array.hpp +0 -214
- data/rice/Array.ipp +0 -256
- data/rice/Builtin_Object.hpp +0 -8
- data/rice/Builtin_Object.ipp +0 -50
- data/rice/Builtin_Object_defn.hpp +0 -50
- data/rice/Class.cpp +0 -57
- data/rice/Class.hpp +0 -8
- data/rice/Class.ipp +0 -6
- data/rice/Class_defn.hpp +0 -84
- data/rice/Data_Type.cpp +0 -54
- data/rice/Data_Type_fwd.hpp +0 -12
- data/rice/Director.cpp +0 -13
- data/rice/Exception.cpp +0 -54
- data/rice/Exception_Base.hpp +0 -8
- data/rice/Exception_Base.ipp +0 -13
- data/rice/Exception_Base_defn.hpp +0 -27
- data/rice/Hash.hpp +0 -230
- data/rice/Hash.ipp +0 -329
- data/rice/Identifier.cpp +0 -8
- data/rice/Jump_Tag.hpp +0 -24
- data/rice/Makefile.am +0 -121
- data/rice/Makefile.in +0 -884
- data/rice/Module.cpp +0 -84
- data/rice/Module.hpp +0 -8
- data/rice/Module.ipp +0 -6
- data/rice/Module_defn.hpp +0 -88
- data/rice/Module_impl.hpp +0 -281
- data/rice/Module_impl.ipp +0 -345
- data/rice/Object.cpp +0 -169
- data/rice/Object.hpp +0 -8
- data/rice/Object.ipp +0 -33
- data/rice/Object_defn.hpp +0 -214
- data/rice/Require_Guard.hpp +0 -21
- data/rice/String.cpp +0 -89
- data/rice/String.hpp +0 -91
- data/rice/Struct.cpp +0 -117
- data/rice/Struct.hpp +0 -162
- data/rice/Struct.ipp +0 -26
- data/rice/Symbol.cpp +0 -25
- data/rice/Symbol.hpp +0 -66
- data/rice/Symbol.ipp +0 -44
- data/rice/config.hpp +0 -47
- data/rice/config.hpp.in +0 -46
- data/rice/detail/Arguments.hpp +0 -118
- data/rice/detail/Auto_Function_Wrapper.hpp +0 -898
- data/rice/detail/Auto_Function_Wrapper.ipp +0 -3181
- data/rice/detail/Auto_Member_Function_Wrapper.hpp +0 -897
- data/rice/detail/Auto_Member_Function_Wrapper.ipp +0 -2501
- data/rice/detail/Caster.hpp +0 -103
- data/rice/detail/Not_Copyable.hpp +0 -25
- data/rice/detail/Wrapped_Function.hpp +0 -33
- data/rice/detail/cfp.hpp +0 -24
- data/rice/detail/cfp.ipp +0 -51
- data/rice/detail/check_ruby_type.cpp +0 -27
- data/rice/detail/check_ruby_type.hpp +0 -23
- data/rice/detail/creation_funcs.hpp +0 -37
- data/rice/detail/creation_funcs.ipp +0 -36
- data/rice/detail/define_method_and_auto_wrap.hpp +0 -31
- data/rice/detail/define_method_and_auto_wrap.ipp +0 -30
- data/rice/detail/demangle.cpp +0 -56
- data/rice/detail/demangle.hpp +0 -19
- data/rice/detail/env.hpp +0 -11
- data/rice/detail/method_data.cpp +0 -92
- data/rice/detail/node.hpp +0 -13
- data/rice/detail/protect.cpp +0 -29
- data/rice/detail/protect.hpp +0 -34
- data/rice/detail/ruby_version_code.hpp +0 -6
- data/rice/detail/ruby_version_code.hpp.in +0 -6
- data/rice/detail/st.hpp +0 -22
- data/rice/detail/win32.hpp +0 -16
- data/rice/detail/wrap_function.hpp +0 -66
- data/rice/protect.hpp +0 -38
- data/rice/protect.ipp +0 -1134
- data/rice/rubypp.rb +0 -97
- data/rice/to_from_ruby.hpp +0 -8
- data/rice/to_from_ruby.ipp +0 -418
- data/rice/to_from_ruby_defn.hpp +0 -70
- data/ruby/Makefile.am +0 -1
- data/ruby/Makefile.in +0 -628
- data/ruby/lib/Makefile.am +0 -3
- data/ruby/lib/Makefile.in +0 -506
- data/ruby/lib/mkmf-rice.rb.in +0 -217
- data/ruby/lib/version.rb +0 -3
- data/ruby.ac +0 -135
- data/sample/Makefile.am +0 -53
- data/sample/Makefile.in +0 -495
- data/test/Makefile.am +0 -73
- data/test/Makefile.in +0 -1219
- data/test/ext/Makefile.am +0 -41
- data/test/ext/Makefile.in +0 -483
- data/test/test_rice.rb +0 -45
|
@@ -1,3181 +0,0 @@
|
|
|
1
|
-
#ifndef Rice__detail__Auto_Function_Wrapper__ipp_
|
|
2
|
-
#define Rice__detail__Auto_Function_Wrapper__ipp_
|
|
3
|
-
|
|
4
|
-
// This is a generated file. DO NOT EDIT!!
|
|
5
|
-
|
|
6
|
-
|
|
7
|
-
// This causes problems with certain C++ libraries
|
|
8
|
-
#undef TYPE
|
|
9
|
-
|
|
10
|
-
#include "method_data.hpp"
|
|
11
|
-
#include "../ruby_try_catch.hpp"
|
|
12
|
-
#include "../to_from_ruby.hpp"
|
|
13
|
-
namespace Rice
|
|
14
|
-
{
|
|
15
|
-
|
|
16
|
-
namespace detail
|
|
17
|
-
{
|
|
18
|
-
|
|
19
|
-
template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T, typename Arg13_T, typename Arg14_T, typename Arg15_T>
|
|
20
|
-
Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T, Arg14_T, Arg15_T>::
|
|
21
|
-
Auto_Function_Wrapper(
|
|
22
|
-
Func func,
|
|
23
|
-
Data_Object<Exception_Handler> handler,
|
|
24
|
-
Arguments* arguments)
|
|
25
|
-
: Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
|
|
26
|
-
, func_(func)
|
|
27
|
-
, handler_(handler)
|
|
28
|
-
, handler_guard_(&handler_)
|
|
29
|
-
{
|
|
30
|
-
if(arguments == 0) {
|
|
31
|
-
arguments_ = new Arguments();
|
|
32
|
-
} else {
|
|
33
|
-
arguments_ = arguments;
|
|
34
|
-
}
|
|
35
|
-
}
|
|
36
|
-
|
|
37
|
-
template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T, typename Arg13_T, typename Arg14_T, typename Arg15_T>
|
|
38
|
-
Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T, Arg14_T, Arg15_T>::
|
|
39
|
-
~Auto_Function_Wrapper()
|
|
40
|
-
{
|
|
41
|
-
if(arguments_) { delete arguments_; }
|
|
42
|
-
}
|
|
43
|
-
|
|
44
|
-
template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T, typename Arg13_T, typename Arg14_T, typename Arg15_T>
|
|
45
|
-
VALUE Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T, Arg14_T, Arg15_T>::
|
|
46
|
-
call(int argc, VALUE *argv, VALUE self)
|
|
47
|
-
{
|
|
48
|
-
Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T, Arg14_T, Arg15_T> * wrapper = 0;
|
|
49
|
-
try
|
|
50
|
-
{
|
|
51
|
-
Data_Object<Wrapped_Function> data(detail::method_data());
|
|
52
|
-
wrapper = (Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T, Arg14_T, Arg15_T> *)data.get();
|
|
53
|
-
Arguments* args = wrapper->arguments_;
|
|
54
|
-
|
|
55
|
-
bool hasSelf = (self && self != Qnil);
|
|
56
|
-
if(args->count() >= 0) {
|
|
57
|
-
hasSelf = hasSelf && args->count() == Num_Args - 1;
|
|
58
|
-
} else {
|
|
59
|
-
hasSelf = hasSelf && argc == Num_Args -1;
|
|
60
|
-
}
|
|
61
|
-
|
|
62
|
-
VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12, varg13, varg14, varg15;
|
|
63
|
-
|
|
64
|
-
if(hasSelf) {
|
|
65
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args - 1).c_str()
|
|
66
|
-
, &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14, &varg15);
|
|
67
|
-
|
|
68
|
-
Arg0_T arg0 = from_ruby<Arg0_T>(self);
|
|
69
|
-
|
|
70
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
|
|
71
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
|
|
72
|
-
Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
|
|
73
|
-
Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
|
|
74
|
-
Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
|
|
75
|
-
Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
|
|
76
|
-
Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
|
|
77
|
-
Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
|
|
78
|
-
Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
|
|
79
|
-
Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(9, varg9);
|
|
80
|
-
Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(10, varg10);
|
|
81
|
-
Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(11, varg11);
|
|
82
|
-
Arg13_T arg13 = args->getArgumentOrDefault<Arg13_T>(12, varg12);
|
|
83
|
-
Arg14_T arg14 = args->getArgumentOrDefault<Arg14_T>(13, varg13);
|
|
84
|
-
Arg15_T arg15 = args->getArgumentOrDefault<Arg15_T>(14, varg14);
|
|
85
|
-
|
|
86
|
-
return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15));
|
|
87
|
-
} else {
|
|
88
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
|
|
89
|
-
, &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14, &varg15);
|
|
90
|
-
|
|
91
|
-
Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
|
|
92
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
|
|
93
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
|
|
94
|
-
Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
|
|
95
|
-
Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
|
|
96
|
-
Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
|
|
97
|
-
Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
|
|
98
|
-
Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
|
|
99
|
-
Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
|
|
100
|
-
Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
|
|
101
|
-
Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(10, varg10);
|
|
102
|
-
Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(11, varg11);
|
|
103
|
-
Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(12, varg12);
|
|
104
|
-
Arg13_T arg13 = args->getArgumentOrDefault<Arg13_T>(13, varg13);
|
|
105
|
-
Arg14_T arg14 = args->getArgumentOrDefault<Arg14_T>(14, varg14);
|
|
106
|
-
Arg15_T arg15 = args->getArgumentOrDefault<Arg15_T>(15, varg15);
|
|
107
|
-
|
|
108
|
-
return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15));
|
|
109
|
-
}
|
|
110
|
-
}
|
|
111
|
-
catch(...)
|
|
112
|
-
{
|
|
113
|
-
RUBY_TRY
|
|
114
|
-
{
|
|
115
|
-
if(wrapper)
|
|
116
|
-
{
|
|
117
|
-
return wrapper->handler_->handle_exception();
|
|
118
|
-
}
|
|
119
|
-
else
|
|
120
|
-
{
|
|
121
|
-
throw;
|
|
122
|
-
}
|
|
123
|
-
}
|
|
124
|
-
RUBY_CATCH
|
|
125
|
-
}
|
|
126
|
-
}
|
|
127
|
-
|
|
128
|
-
template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T, typename Arg13_T, typename Arg14_T, typename Arg15_T>
|
|
129
|
-
Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T, Arg14_T, Arg15_T>::
|
|
130
|
-
Auto_Function_Wrapper(
|
|
131
|
-
Func func,
|
|
132
|
-
Data_Object<Exception_Handler> handler,
|
|
133
|
-
Arguments* arguments)
|
|
134
|
-
: Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
|
|
135
|
-
, func_(func)
|
|
136
|
-
, handler_(handler)
|
|
137
|
-
, handler_guard_(&handler_)
|
|
138
|
-
{
|
|
139
|
-
if(arguments == 0) {
|
|
140
|
-
arguments_ = new Arguments();
|
|
141
|
-
} else {
|
|
142
|
-
arguments_ = arguments;
|
|
143
|
-
}
|
|
144
|
-
}
|
|
145
|
-
|
|
146
|
-
template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T, typename Arg13_T, typename Arg14_T, typename Arg15_T>
|
|
147
|
-
Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T, Arg14_T, Arg15_T>::
|
|
148
|
-
~Auto_Function_Wrapper()
|
|
149
|
-
{
|
|
150
|
-
if(arguments_) { delete arguments_; }
|
|
151
|
-
}
|
|
152
|
-
|
|
153
|
-
template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T, typename Arg13_T, typename Arg14_T, typename Arg15_T>
|
|
154
|
-
VALUE Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T, Arg14_T, Arg15_T>::
|
|
155
|
-
call(int argc, VALUE* argv, VALUE self)
|
|
156
|
-
{
|
|
157
|
-
Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T, Arg14_T, Arg15_T> * wrapper = 0;
|
|
158
|
-
try
|
|
159
|
-
{
|
|
160
|
-
Data_Object<Wrapped_Function> data(detail::method_data());
|
|
161
|
-
wrapper = (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T, Arg14_T, Arg15_T> *)data.get();
|
|
162
|
-
Arguments* args = wrapper->arguments_;
|
|
163
|
-
|
|
164
|
-
bool hasSelf = (self && self != Qnil);
|
|
165
|
-
if(args->count() >= 0) {
|
|
166
|
-
hasSelf = hasSelf && args->count() == Num_Args - 1;
|
|
167
|
-
} else {
|
|
168
|
-
hasSelf = hasSelf && argc == Num_Args -1;
|
|
169
|
-
}
|
|
170
|
-
|
|
171
|
-
VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12, varg13, varg14, varg15;
|
|
172
|
-
|
|
173
|
-
if(hasSelf) {
|
|
174
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args - 1) .c_str()
|
|
175
|
-
, &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14, &varg15);
|
|
176
|
-
|
|
177
|
-
Arg0_T arg0 = from_ruby<Arg0_T>(self);
|
|
178
|
-
|
|
179
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
|
|
180
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
|
|
181
|
-
Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
|
|
182
|
-
Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
|
|
183
|
-
Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
|
|
184
|
-
Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
|
|
185
|
-
Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
|
|
186
|
-
Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
|
|
187
|
-
Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
|
|
188
|
-
Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(9, varg9);
|
|
189
|
-
Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(10, varg10);
|
|
190
|
-
Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(11, varg11);
|
|
191
|
-
Arg13_T arg13 = args->getArgumentOrDefault<Arg13_T>(12, varg12);
|
|
192
|
-
Arg14_T arg14 = args->getArgumentOrDefault<Arg14_T>(13, varg13);
|
|
193
|
-
Arg15_T arg15 = args->getArgumentOrDefault<Arg15_T>(14, varg14);
|
|
194
|
-
|
|
195
|
-
wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15);
|
|
196
|
-
return Qnil;
|
|
197
|
-
} else {
|
|
198
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
|
|
199
|
-
, &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14, &varg15);
|
|
200
|
-
|
|
201
|
-
Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
|
|
202
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
|
|
203
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
|
|
204
|
-
Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
|
|
205
|
-
Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
|
|
206
|
-
Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
|
|
207
|
-
Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
|
|
208
|
-
Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
|
|
209
|
-
Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
|
|
210
|
-
Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
|
|
211
|
-
Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(10, varg10);
|
|
212
|
-
Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(11, varg11);
|
|
213
|
-
Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(12, varg12);
|
|
214
|
-
Arg13_T arg13 = args->getArgumentOrDefault<Arg13_T>(13, varg13);
|
|
215
|
-
Arg14_T arg14 = args->getArgumentOrDefault<Arg14_T>(14, varg14);
|
|
216
|
-
Arg15_T arg15 = args->getArgumentOrDefault<Arg15_T>(15, varg15);
|
|
217
|
-
|
|
218
|
-
wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15);
|
|
219
|
-
return Qnil;
|
|
220
|
-
}
|
|
221
|
-
}
|
|
222
|
-
catch(...)
|
|
223
|
-
{
|
|
224
|
-
RUBY_TRY
|
|
225
|
-
{
|
|
226
|
-
if(wrapper)
|
|
227
|
-
{
|
|
228
|
-
return wrapper->handler_->handle_exception();
|
|
229
|
-
}
|
|
230
|
-
else
|
|
231
|
-
{
|
|
232
|
-
throw;
|
|
233
|
-
}
|
|
234
|
-
}
|
|
235
|
-
RUBY_CATCH
|
|
236
|
-
}
|
|
237
|
-
}
|
|
238
|
-
|
|
239
|
-
// ---------------------------------------------------------------------
|
|
240
|
-
template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T, typename Arg13_T, typename Arg14_T>
|
|
241
|
-
Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T, Arg14_T>::
|
|
242
|
-
Auto_Function_Wrapper(
|
|
243
|
-
Func func,
|
|
244
|
-
Data_Object<Exception_Handler> handler,
|
|
245
|
-
Arguments* arguments)
|
|
246
|
-
: Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
|
|
247
|
-
, func_(func)
|
|
248
|
-
, handler_(handler)
|
|
249
|
-
, handler_guard_(&handler_)
|
|
250
|
-
{
|
|
251
|
-
if(arguments == 0) {
|
|
252
|
-
arguments_ = new Arguments();
|
|
253
|
-
} else {
|
|
254
|
-
arguments_ = arguments;
|
|
255
|
-
}
|
|
256
|
-
}
|
|
257
|
-
|
|
258
|
-
template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T, typename Arg13_T, typename Arg14_T>
|
|
259
|
-
Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T, Arg14_T>::
|
|
260
|
-
~Auto_Function_Wrapper()
|
|
261
|
-
{
|
|
262
|
-
if(arguments_) { delete arguments_; }
|
|
263
|
-
}
|
|
264
|
-
|
|
265
|
-
template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T, typename Arg13_T, typename Arg14_T>
|
|
266
|
-
VALUE Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T, Arg14_T>::
|
|
267
|
-
call(int argc, VALUE *argv, VALUE self)
|
|
268
|
-
{
|
|
269
|
-
Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T, Arg14_T> * wrapper = 0;
|
|
270
|
-
try
|
|
271
|
-
{
|
|
272
|
-
Data_Object<Wrapped_Function> data(detail::method_data());
|
|
273
|
-
wrapper = (Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T, Arg14_T> *)data.get();
|
|
274
|
-
Arguments* args = wrapper->arguments_;
|
|
275
|
-
|
|
276
|
-
bool hasSelf = (self && self != Qnil);
|
|
277
|
-
if(args->count() >= 0) {
|
|
278
|
-
hasSelf = hasSelf && args->count() == Num_Args - 1;
|
|
279
|
-
} else {
|
|
280
|
-
hasSelf = hasSelf && argc == Num_Args -1;
|
|
281
|
-
}
|
|
282
|
-
|
|
283
|
-
VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12, varg13, varg14;
|
|
284
|
-
|
|
285
|
-
if(hasSelf) {
|
|
286
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args - 1).c_str()
|
|
287
|
-
, &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14);
|
|
288
|
-
|
|
289
|
-
Arg0_T arg0 = from_ruby<Arg0_T>(self);
|
|
290
|
-
|
|
291
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
|
|
292
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
|
|
293
|
-
Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
|
|
294
|
-
Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
|
|
295
|
-
Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
|
|
296
|
-
Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
|
|
297
|
-
Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
|
|
298
|
-
Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
|
|
299
|
-
Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
|
|
300
|
-
Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(9, varg9);
|
|
301
|
-
Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(10, varg10);
|
|
302
|
-
Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(11, varg11);
|
|
303
|
-
Arg13_T arg13 = args->getArgumentOrDefault<Arg13_T>(12, varg12);
|
|
304
|
-
Arg14_T arg14 = args->getArgumentOrDefault<Arg14_T>(13, varg13);
|
|
305
|
-
|
|
306
|
-
return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14));
|
|
307
|
-
} else {
|
|
308
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
|
|
309
|
-
, &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14);
|
|
310
|
-
|
|
311
|
-
Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
|
|
312
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
|
|
313
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
|
|
314
|
-
Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
|
|
315
|
-
Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
|
|
316
|
-
Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
|
|
317
|
-
Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
|
|
318
|
-
Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
|
|
319
|
-
Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
|
|
320
|
-
Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
|
|
321
|
-
Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(10, varg10);
|
|
322
|
-
Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(11, varg11);
|
|
323
|
-
Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(12, varg12);
|
|
324
|
-
Arg13_T arg13 = args->getArgumentOrDefault<Arg13_T>(13, varg13);
|
|
325
|
-
Arg14_T arg14 = args->getArgumentOrDefault<Arg14_T>(14, varg14);
|
|
326
|
-
|
|
327
|
-
return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14));
|
|
328
|
-
}
|
|
329
|
-
}
|
|
330
|
-
catch(...)
|
|
331
|
-
{
|
|
332
|
-
RUBY_TRY
|
|
333
|
-
{
|
|
334
|
-
if(wrapper)
|
|
335
|
-
{
|
|
336
|
-
return wrapper->handler_->handle_exception();
|
|
337
|
-
}
|
|
338
|
-
else
|
|
339
|
-
{
|
|
340
|
-
throw;
|
|
341
|
-
}
|
|
342
|
-
}
|
|
343
|
-
RUBY_CATCH
|
|
344
|
-
}
|
|
345
|
-
}
|
|
346
|
-
|
|
347
|
-
template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T, typename Arg13_T, typename Arg14_T>
|
|
348
|
-
Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T, Arg14_T>::
|
|
349
|
-
Auto_Function_Wrapper(
|
|
350
|
-
Func func,
|
|
351
|
-
Data_Object<Exception_Handler> handler,
|
|
352
|
-
Arguments* arguments)
|
|
353
|
-
: Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
|
|
354
|
-
, func_(func)
|
|
355
|
-
, handler_(handler)
|
|
356
|
-
, handler_guard_(&handler_)
|
|
357
|
-
{
|
|
358
|
-
if(arguments == 0) {
|
|
359
|
-
arguments_ = new Arguments();
|
|
360
|
-
} else {
|
|
361
|
-
arguments_ = arguments;
|
|
362
|
-
}
|
|
363
|
-
}
|
|
364
|
-
|
|
365
|
-
template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T, typename Arg13_T, typename Arg14_T>
|
|
366
|
-
Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T, Arg14_T>::
|
|
367
|
-
~Auto_Function_Wrapper()
|
|
368
|
-
{
|
|
369
|
-
if(arguments_) { delete arguments_; }
|
|
370
|
-
}
|
|
371
|
-
|
|
372
|
-
template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T, typename Arg13_T, typename Arg14_T>
|
|
373
|
-
VALUE Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T, Arg14_T>::
|
|
374
|
-
call(int argc, VALUE* argv, VALUE self)
|
|
375
|
-
{
|
|
376
|
-
Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T, Arg14_T> * wrapper = 0;
|
|
377
|
-
try
|
|
378
|
-
{
|
|
379
|
-
Data_Object<Wrapped_Function> data(detail::method_data());
|
|
380
|
-
wrapper = (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T, Arg14_T> *)data.get();
|
|
381
|
-
Arguments* args = wrapper->arguments_;
|
|
382
|
-
|
|
383
|
-
bool hasSelf = (self && self != Qnil);
|
|
384
|
-
if(args->count() >= 0) {
|
|
385
|
-
hasSelf = hasSelf && args->count() == Num_Args - 1;
|
|
386
|
-
} else {
|
|
387
|
-
hasSelf = hasSelf && argc == Num_Args -1;
|
|
388
|
-
}
|
|
389
|
-
|
|
390
|
-
VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12, varg13, varg14;
|
|
391
|
-
|
|
392
|
-
if(hasSelf) {
|
|
393
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args - 1) .c_str()
|
|
394
|
-
, &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14);
|
|
395
|
-
|
|
396
|
-
Arg0_T arg0 = from_ruby<Arg0_T>(self);
|
|
397
|
-
|
|
398
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
|
|
399
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
|
|
400
|
-
Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
|
|
401
|
-
Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
|
|
402
|
-
Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
|
|
403
|
-
Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
|
|
404
|
-
Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
|
|
405
|
-
Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
|
|
406
|
-
Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
|
|
407
|
-
Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(9, varg9);
|
|
408
|
-
Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(10, varg10);
|
|
409
|
-
Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(11, varg11);
|
|
410
|
-
Arg13_T arg13 = args->getArgumentOrDefault<Arg13_T>(12, varg12);
|
|
411
|
-
Arg14_T arg14 = args->getArgumentOrDefault<Arg14_T>(13, varg13);
|
|
412
|
-
|
|
413
|
-
wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
|
|
414
|
-
return Qnil;
|
|
415
|
-
} else {
|
|
416
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
|
|
417
|
-
, &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14);
|
|
418
|
-
|
|
419
|
-
Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
|
|
420
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
|
|
421
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
|
|
422
|
-
Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
|
|
423
|
-
Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
|
|
424
|
-
Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
|
|
425
|
-
Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
|
|
426
|
-
Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
|
|
427
|
-
Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
|
|
428
|
-
Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
|
|
429
|
-
Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(10, varg10);
|
|
430
|
-
Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(11, varg11);
|
|
431
|
-
Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(12, varg12);
|
|
432
|
-
Arg13_T arg13 = args->getArgumentOrDefault<Arg13_T>(13, varg13);
|
|
433
|
-
Arg14_T arg14 = args->getArgumentOrDefault<Arg14_T>(14, varg14);
|
|
434
|
-
|
|
435
|
-
wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
|
|
436
|
-
return Qnil;
|
|
437
|
-
}
|
|
438
|
-
}
|
|
439
|
-
catch(...)
|
|
440
|
-
{
|
|
441
|
-
RUBY_TRY
|
|
442
|
-
{
|
|
443
|
-
if(wrapper)
|
|
444
|
-
{
|
|
445
|
-
return wrapper->handler_->handle_exception();
|
|
446
|
-
}
|
|
447
|
-
else
|
|
448
|
-
{
|
|
449
|
-
throw;
|
|
450
|
-
}
|
|
451
|
-
}
|
|
452
|
-
RUBY_CATCH
|
|
453
|
-
}
|
|
454
|
-
}
|
|
455
|
-
|
|
456
|
-
// ---------------------------------------------------------------------
|
|
457
|
-
template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T, typename Arg13_T>
|
|
458
|
-
Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T>::
|
|
459
|
-
Auto_Function_Wrapper(
|
|
460
|
-
Func func,
|
|
461
|
-
Data_Object<Exception_Handler> handler,
|
|
462
|
-
Arguments* arguments)
|
|
463
|
-
: Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
|
|
464
|
-
, func_(func)
|
|
465
|
-
, handler_(handler)
|
|
466
|
-
, handler_guard_(&handler_)
|
|
467
|
-
{
|
|
468
|
-
if(arguments == 0) {
|
|
469
|
-
arguments_ = new Arguments();
|
|
470
|
-
} else {
|
|
471
|
-
arguments_ = arguments;
|
|
472
|
-
}
|
|
473
|
-
}
|
|
474
|
-
|
|
475
|
-
template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T, typename Arg13_T>
|
|
476
|
-
Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T>::
|
|
477
|
-
~Auto_Function_Wrapper()
|
|
478
|
-
{
|
|
479
|
-
if(arguments_) { delete arguments_; }
|
|
480
|
-
}
|
|
481
|
-
|
|
482
|
-
template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T, typename Arg13_T>
|
|
483
|
-
VALUE Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T>::
|
|
484
|
-
call(int argc, VALUE *argv, VALUE self)
|
|
485
|
-
{
|
|
486
|
-
Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T> * wrapper = 0;
|
|
487
|
-
try
|
|
488
|
-
{
|
|
489
|
-
Data_Object<Wrapped_Function> data(detail::method_data());
|
|
490
|
-
wrapper = (Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T> *)data.get();
|
|
491
|
-
Arguments* args = wrapper->arguments_;
|
|
492
|
-
|
|
493
|
-
bool hasSelf = (self && self != Qnil);
|
|
494
|
-
if(args->count() >= 0) {
|
|
495
|
-
hasSelf = hasSelf && args->count() == Num_Args - 1;
|
|
496
|
-
} else {
|
|
497
|
-
hasSelf = hasSelf && argc == Num_Args -1;
|
|
498
|
-
}
|
|
499
|
-
|
|
500
|
-
VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12, varg13;
|
|
501
|
-
|
|
502
|
-
if(hasSelf) {
|
|
503
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args - 1).c_str()
|
|
504
|
-
, &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13);
|
|
505
|
-
|
|
506
|
-
Arg0_T arg0 = from_ruby<Arg0_T>(self);
|
|
507
|
-
|
|
508
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
|
|
509
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
|
|
510
|
-
Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
|
|
511
|
-
Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
|
|
512
|
-
Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
|
|
513
|
-
Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
|
|
514
|
-
Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
|
|
515
|
-
Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
|
|
516
|
-
Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
|
|
517
|
-
Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(9, varg9);
|
|
518
|
-
Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(10, varg10);
|
|
519
|
-
Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(11, varg11);
|
|
520
|
-
Arg13_T arg13 = args->getArgumentOrDefault<Arg13_T>(12, varg12);
|
|
521
|
-
|
|
522
|
-
return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13));
|
|
523
|
-
} else {
|
|
524
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
|
|
525
|
-
, &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13);
|
|
526
|
-
|
|
527
|
-
Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
|
|
528
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
|
|
529
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
|
|
530
|
-
Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
|
|
531
|
-
Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
|
|
532
|
-
Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
|
|
533
|
-
Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
|
|
534
|
-
Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
|
|
535
|
-
Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
|
|
536
|
-
Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
|
|
537
|
-
Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(10, varg10);
|
|
538
|
-
Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(11, varg11);
|
|
539
|
-
Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(12, varg12);
|
|
540
|
-
Arg13_T arg13 = args->getArgumentOrDefault<Arg13_T>(13, varg13);
|
|
541
|
-
|
|
542
|
-
return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13));
|
|
543
|
-
}
|
|
544
|
-
}
|
|
545
|
-
catch(...)
|
|
546
|
-
{
|
|
547
|
-
RUBY_TRY
|
|
548
|
-
{
|
|
549
|
-
if(wrapper)
|
|
550
|
-
{
|
|
551
|
-
return wrapper->handler_->handle_exception();
|
|
552
|
-
}
|
|
553
|
-
else
|
|
554
|
-
{
|
|
555
|
-
throw;
|
|
556
|
-
}
|
|
557
|
-
}
|
|
558
|
-
RUBY_CATCH
|
|
559
|
-
}
|
|
560
|
-
}
|
|
561
|
-
|
|
562
|
-
template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T, typename Arg13_T>
|
|
563
|
-
Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T>::
|
|
564
|
-
Auto_Function_Wrapper(
|
|
565
|
-
Func func,
|
|
566
|
-
Data_Object<Exception_Handler> handler,
|
|
567
|
-
Arguments* arguments)
|
|
568
|
-
: Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
|
|
569
|
-
, func_(func)
|
|
570
|
-
, handler_(handler)
|
|
571
|
-
, handler_guard_(&handler_)
|
|
572
|
-
{
|
|
573
|
-
if(arguments == 0) {
|
|
574
|
-
arguments_ = new Arguments();
|
|
575
|
-
} else {
|
|
576
|
-
arguments_ = arguments;
|
|
577
|
-
}
|
|
578
|
-
}
|
|
579
|
-
|
|
580
|
-
template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T, typename Arg13_T>
|
|
581
|
-
Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T>::
|
|
582
|
-
~Auto_Function_Wrapper()
|
|
583
|
-
{
|
|
584
|
-
if(arguments_) { delete arguments_; }
|
|
585
|
-
}
|
|
586
|
-
|
|
587
|
-
template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T, typename Arg13_T>
|
|
588
|
-
VALUE Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T>::
|
|
589
|
-
call(int argc, VALUE* argv, VALUE self)
|
|
590
|
-
{
|
|
591
|
-
Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T> * wrapper = 0;
|
|
592
|
-
try
|
|
593
|
-
{
|
|
594
|
-
Data_Object<Wrapped_Function> data(detail::method_data());
|
|
595
|
-
wrapper = (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T> *)data.get();
|
|
596
|
-
Arguments* args = wrapper->arguments_;
|
|
597
|
-
|
|
598
|
-
bool hasSelf = (self && self != Qnil);
|
|
599
|
-
if(args->count() >= 0) {
|
|
600
|
-
hasSelf = hasSelf && args->count() == Num_Args - 1;
|
|
601
|
-
} else {
|
|
602
|
-
hasSelf = hasSelf && argc == Num_Args -1;
|
|
603
|
-
}
|
|
604
|
-
|
|
605
|
-
VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12, varg13;
|
|
606
|
-
|
|
607
|
-
if(hasSelf) {
|
|
608
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args - 1) .c_str()
|
|
609
|
-
, &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13);
|
|
610
|
-
|
|
611
|
-
Arg0_T arg0 = from_ruby<Arg0_T>(self);
|
|
612
|
-
|
|
613
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
|
|
614
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
|
|
615
|
-
Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
|
|
616
|
-
Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
|
|
617
|
-
Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
|
|
618
|
-
Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
|
|
619
|
-
Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
|
|
620
|
-
Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
|
|
621
|
-
Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
|
|
622
|
-
Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(9, varg9);
|
|
623
|
-
Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(10, varg10);
|
|
624
|
-
Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(11, varg11);
|
|
625
|
-
Arg13_T arg13 = args->getArgumentOrDefault<Arg13_T>(12, varg12);
|
|
626
|
-
|
|
627
|
-
wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
|
|
628
|
-
return Qnil;
|
|
629
|
-
} else {
|
|
630
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
|
|
631
|
-
, &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13);
|
|
632
|
-
|
|
633
|
-
Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
|
|
634
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
|
|
635
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
|
|
636
|
-
Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
|
|
637
|
-
Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
|
|
638
|
-
Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
|
|
639
|
-
Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
|
|
640
|
-
Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
|
|
641
|
-
Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
|
|
642
|
-
Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
|
|
643
|
-
Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(10, varg10);
|
|
644
|
-
Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(11, varg11);
|
|
645
|
-
Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(12, varg12);
|
|
646
|
-
Arg13_T arg13 = args->getArgumentOrDefault<Arg13_T>(13, varg13);
|
|
647
|
-
|
|
648
|
-
wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
|
|
649
|
-
return Qnil;
|
|
650
|
-
}
|
|
651
|
-
}
|
|
652
|
-
catch(...)
|
|
653
|
-
{
|
|
654
|
-
RUBY_TRY
|
|
655
|
-
{
|
|
656
|
-
if(wrapper)
|
|
657
|
-
{
|
|
658
|
-
return wrapper->handler_->handle_exception();
|
|
659
|
-
}
|
|
660
|
-
else
|
|
661
|
-
{
|
|
662
|
-
throw;
|
|
663
|
-
}
|
|
664
|
-
}
|
|
665
|
-
RUBY_CATCH
|
|
666
|
-
}
|
|
667
|
-
}
|
|
668
|
-
|
|
669
|
-
// ---------------------------------------------------------------------
|
|
670
|
-
template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T>
|
|
671
|
-
Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T>::
|
|
672
|
-
Auto_Function_Wrapper(
|
|
673
|
-
Func func,
|
|
674
|
-
Data_Object<Exception_Handler> handler,
|
|
675
|
-
Arguments* arguments)
|
|
676
|
-
: Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
|
|
677
|
-
, func_(func)
|
|
678
|
-
, handler_(handler)
|
|
679
|
-
, handler_guard_(&handler_)
|
|
680
|
-
{
|
|
681
|
-
if(arguments == 0) {
|
|
682
|
-
arguments_ = new Arguments();
|
|
683
|
-
} else {
|
|
684
|
-
arguments_ = arguments;
|
|
685
|
-
}
|
|
686
|
-
}
|
|
687
|
-
|
|
688
|
-
template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T>
|
|
689
|
-
Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T>::
|
|
690
|
-
~Auto_Function_Wrapper()
|
|
691
|
-
{
|
|
692
|
-
if(arguments_) { delete arguments_; }
|
|
693
|
-
}
|
|
694
|
-
|
|
695
|
-
template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T>
|
|
696
|
-
VALUE Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T>::
|
|
697
|
-
call(int argc, VALUE *argv, VALUE self)
|
|
698
|
-
{
|
|
699
|
-
Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T> * wrapper = 0;
|
|
700
|
-
try
|
|
701
|
-
{
|
|
702
|
-
Data_Object<Wrapped_Function> data(detail::method_data());
|
|
703
|
-
wrapper = (Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T> *)data.get();
|
|
704
|
-
Arguments* args = wrapper->arguments_;
|
|
705
|
-
|
|
706
|
-
bool hasSelf = (self && self != Qnil);
|
|
707
|
-
if(args->count() >= 0) {
|
|
708
|
-
hasSelf = hasSelf && args->count() == Num_Args - 1;
|
|
709
|
-
} else {
|
|
710
|
-
hasSelf = hasSelf && argc == Num_Args -1;
|
|
711
|
-
}
|
|
712
|
-
|
|
713
|
-
VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12;
|
|
714
|
-
|
|
715
|
-
if(hasSelf) {
|
|
716
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args - 1).c_str()
|
|
717
|
-
, &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12);
|
|
718
|
-
|
|
719
|
-
Arg0_T arg0 = from_ruby<Arg0_T>(self);
|
|
720
|
-
|
|
721
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
|
|
722
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
|
|
723
|
-
Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
|
|
724
|
-
Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
|
|
725
|
-
Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
|
|
726
|
-
Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
|
|
727
|
-
Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
|
|
728
|
-
Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
|
|
729
|
-
Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
|
|
730
|
-
Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(9, varg9);
|
|
731
|
-
Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(10, varg10);
|
|
732
|
-
Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(11, varg11);
|
|
733
|
-
|
|
734
|
-
return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12));
|
|
735
|
-
} else {
|
|
736
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
|
|
737
|
-
, &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12);
|
|
738
|
-
|
|
739
|
-
Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
|
|
740
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
|
|
741
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
|
|
742
|
-
Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
|
|
743
|
-
Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
|
|
744
|
-
Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
|
|
745
|
-
Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
|
|
746
|
-
Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
|
|
747
|
-
Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
|
|
748
|
-
Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
|
|
749
|
-
Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(10, varg10);
|
|
750
|
-
Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(11, varg11);
|
|
751
|
-
Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(12, varg12);
|
|
752
|
-
|
|
753
|
-
return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12));
|
|
754
|
-
}
|
|
755
|
-
}
|
|
756
|
-
catch(...)
|
|
757
|
-
{
|
|
758
|
-
RUBY_TRY
|
|
759
|
-
{
|
|
760
|
-
if(wrapper)
|
|
761
|
-
{
|
|
762
|
-
return wrapper->handler_->handle_exception();
|
|
763
|
-
}
|
|
764
|
-
else
|
|
765
|
-
{
|
|
766
|
-
throw;
|
|
767
|
-
}
|
|
768
|
-
}
|
|
769
|
-
RUBY_CATCH
|
|
770
|
-
}
|
|
771
|
-
}
|
|
772
|
-
|
|
773
|
-
template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T>
|
|
774
|
-
Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T>::
|
|
775
|
-
Auto_Function_Wrapper(
|
|
776
|
-
Func func,
|
|
777
|
-
Data_Object<Exception_Handler> handler,
|
|
778
|
-
Arguments* arguments)
|
|
779
|
-
: Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
|
|
780
|
-
, func_(func)
|
|
781
|
-
, handler_(handler)
|
|
782
|
-
, handler_guard_(&handler_)
|
|
783
|
-
{
|
|
784
|
-
if(arguments == 0) {
|
|
785
|
-
arguments_ = new Arguments();
|
|
786
|
-
} else {
|
|
787
|
-
arguments_ = arguments;
|
|
788
|
-
}
|
|
789
|
-
}
|
|
790
|
-
|
|
791
|
-
template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T>
|
|
792
|
-
Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T>::
|
|
793
|
-
~Auto_Function_Wrapper()
|
|
794
|
-
{
|
|
795
|
-
if(arguments_) { delete arguments_; }
|
|
796
|
-
}
|
|
797
|
-
|
|
798
|
-
template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T>
|
|
799
|
-
VALUE Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T>::
|
|
800
|
-
call(int argc, VALUE* argv, VALUE self)
|
|
801
|
-
{
|
|
802
|
-
Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T> * wrapper = 0;
|
|
803
|
-
try
|
|
804
|
-
{
|
|
805
|
-
Data_Object<Wrapped_Function> data(detail::method_data());
|
|
806
|
-
wrapper = (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T> *)data.get();
|
|
807
|
-
Arguments* args = wrapper->arguments_;
|
|
808
|
-
|
|
809
|
-
bool hasSelf = (self && self != Qnil);
|
|
810
|
-
if(args->count() >= 0) {
|
|
811
|
-
hasSelf = hasSelf && args->count() == Num_Args - 1;
|
|
812
|
-
} else {
|
|
813
|
-
hasSelf = hasSelf && argc == Num_Args -1;
|
|
814
|
-
}
|
|
815
|
-
|
|
816
|
-
VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12;
|
|
817
|
-
|
|
818
|
-
if(hasSelf) {
|
|
819
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args - 1) .c_str()
|
|
820
|
-
, &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12);
|
|
821
|
-
|
|
822
|
-
Arg0_T arg0 = from_ruby<Arg0_T>(self);
|
|
823
|
-
|
|
824
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
|
|
825
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
|
|
826
|
-
Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
|
|
827
|
-
Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
|
|
828
|
-
Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
|
|
829
|
-
Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
|
|
830
|
-
Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
|
|
831
|
-
Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
|
|
832
|
-
Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
|
|
833
|
-
Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(9, varg9);
|
|
834
|
-
Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(10, varg10);
|
|
835
|
-
Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(11, varg11);
|
|
836
|
-
|
|
837
|
-
wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
|
|
838
|
-
return Qnil;
|
|
839
|
-
} else {
|
|
840
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
|
|
841
|
-
, &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12);
|
|
842
|
-
|
|
843
|
-
Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
|
|
844
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
|
|
845
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
|
|
846
|
-
Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
|
|
847
|
-
Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
|
|
848
|
-
Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
|
|
849
|
-
Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
|
|
850
|
-
Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
|
|
851
|
-
Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
|
|
852
|
-
Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
|
|
853
|
-
Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(10, varg10);
|
|
854
|
-
Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(11, varg11);
|
|
855
|
-
Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(12, varg12);
|
|
856
|
-
|
|
857
|
-
wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
|
|
858
|
-
return Qnil;
|
|
859
|
-
}
|
|
860
|
-
}
|
|
861
|
-
catch(...)
|
|
862
|
-
{
|
|
863
|
-
RUBY_TRY
|
|
864
|
-
{
|
|
865
|
-
if(wrapper)
|
|
866
|
-
{
|
|
867
|
-
return wrapper->handler_->handle_exception();
|
|
868
|
-
}
|
|
869
|
-
else
|
|
870
|
-
{
|
|
871
|
-
throw;
|
|
872
|
-
}
|
|
873
|
-
}
|
|
874
|
-
RUBY_CATCH
|
|
875
|
-
}
|
|
876
|
-
}
|
|
877
|
-
|
|
878
|
-
// ---------------------------------------------------------------------
|
|
879
|
-
template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T>
|
|
880
|
-
Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T>::
|
|
881
|
-
Auto_Function_Wrapper(
|
|
882
|
-
Func func,
|
|
883
|
-
Data_Object<Exception_Handler> handler,
|
|
884
|
-
Arguments* arguments)
|
|
885
|
-
: Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
|
|
886
|
-
, func_(func)
|
|
887
|
-
, handler_(handler)
|
|
888
|
-
, handler_guard_(&handler_)
|
|
889
|
-
{
|
|
890
|
-
if(arguments == 0) {
|
|
891
|
-
arguments_ = new Arguments();
|
|
892
|
-
} else {
|
|
893
|
-
arguments_ = arguments;
|
|
894
|
-
}
|
|
895
|
-
}
|
|
896
|
-
|
|
897
|
-
template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T>
|
|
898
|
-
Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T>::
|
|
899
|
-
~Auto_Function_Wrapper()
|
|
900
|
-
{
|
|
901
|
-
if(arguments_) { delete arguments_; }
|
|
902
|
-
}
|
|
903
|
-
|
|
904
|
-
template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T>
|
|
905
|
-
VALUE Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T>::
|
|
906
|
-
call(int argc, VALUE *argv, VALUE self)
|
|
907
|
-
{
|
|
908
|
-
Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T> * wrapper = 0;
|
|
909
|
-
try
|
|
910
|
-
{
|
|
911
|
-
Data_Object<Wrapped_Function> data(detail::method_data());
|
|
912
|
-
wrapper = (Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T> *)data.get();
|
|
913
|
-
Arguments* args = wrapper->arguments_;
|
|
914
|
-
|
|
915
|
-
bool hasSelf = (self && self != Qnil);
|
|
916
|
-
if(args->count() >= 0) {
|
|
917
|
-
hasSelf = hasSelf && args->count() == Num_Args - 1;
|
|
918
|
-
} else {
|
|
919
|
-
hasSelf = hasSelf && argc == Num_Args -1;
|
|
920
|
-
}
|
|
921
|
-
|
|
922
|
-
VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11;
|
|
923
|
-
|
|
924
|
-
if(hasSelf) {
|
|
925
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args - 1).c_str()
|
|
926
|
-
, &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11);
|
|
927
|
-
|
|
928
|
-
Arg0_T arg0 = from_ruby<Arg0_T>(self);
|
|
929
|
-
|
|
930
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
|
|
931
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
|
|
932
|
-
Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
|
|
933
|
-
Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
|
|
934
|
-
Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
|
|
935
|
-
Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
|
|
936
|
-
Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
|
|
937
|
-
Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
|
|
938
|
-
Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
|
|
939
|
-
Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(9, varg9);
|
|
940
|
-
Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(10, varg10);
|
|
941
|
-
|
|
942
|
-
return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11));
|
|
943
|
-
} else {
|
|
944
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
|
|
945
|
-
, &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11);
|
|
946
|
-
|
|
947
|
-
Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
|
|
948
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
|
|
949
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
|
|
950
|
-
Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
|
|
951
|
-
Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
|
|
952
|
-
Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
|
|
953
|
-
Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
|
|
954
|
-
Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
|
|
955
|
-
Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
|
|
956
|
-
Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
|
|
957
|
-
Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(10, varg10);
|
|
958
|
-
Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(11, varg11);
|
|
959
|
-
|
|
960
|
-
return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11));
|
|
961
|
-
}
|
|
962
|
-
}
|
|
963
|
-
catch(...)
|
|
964
|
-
{
|
|
965
|
-
RUBY_TRY
|
|
966
|
-
{
|
|
967
|
-
if(wrapper)
|
|
968
|
-
{
|
|
969
|
-
return wrapper->handler_->handle_exception();
|
|
970
|
-
}
|
|
971
|
-
else
|
|
972
|
-
{
|
|
973
|
-
throw;
|
|
974
|
-
}
|
|
975
|
-
}
|
|
976
|
-
RUBY_CATCH
|
|
977
|
-
}
|
|
978
|
-
}
|
|
979
|
-
|
|
980
|
-
template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T>
|
|
981
|
-
Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T>::
|
|
982
|
-
Auto_Function_Wrapper(
|
|
983
|
-
Func func,
|
|
984
|
-
Data_Object<Exception_Handler> handler,
|
|
985
|
-
Arguments* arguments)
|
|
986
|
-
: Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
|
|
987
|
-
, func_(func)
|
|
988
|
-
, handler_(handler)
|
|
989
|
-
, handler_guard_(&handler_)
|
|
990
|
-
{
|
|
991
|
-
if(arguments == 0) {
|
|
992
|
-
arguments_ = new Arguments();
|
|
993
|
-
} else {
|
|
994
|
-
arguments_ = arguments;
|
|
995
|
-
}
|
|
996
|
-
}
|
|
997
|
-
|
|
998
|
-
template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T>
|
|
999
|
-
Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T>::
|
|
1000
|
-
~Auto_Function_Wrapper()
|
|
1001
|
-
{
|
|
1002
|
-
if(arguments_) { delete arguments_; }
|
|
1003
|
-
}
|
|
1004
|
-
|
|
1005
|
-
template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T>
|
|
1006
|
-
VALUE Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T>::
|
|
1007
|
-
call(int argc, VALUE* argv, VALUE self)
|
|
1008
|
-
{
|
|
1009
|
-
Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T> * wrapper = 0;
|
|
1010
|
-
try
|
|
1011
|
-
{
|
|
1012
|
-
Data_Object<Wrapped_Function> data(detail::method_data());
|
|
1013
|
-
wrapper = (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T> *)data.get();
|
|
1014
|
-
Arguments* args = wrapper->arguments_;
|
|
1015
|
-
|
|
1016
|
-
bool hasSelf = (self && self != Qnil);
|
|
1017
|
-
if(args->count() >= 0) {
|
|
1018
|
-
hasSelf = hasSelf && args->count() == Num_Args - 1;
|
|
1019
|
-
} else {
|
|
1020
|
-
hasSelf = hasSelf && argc == Num_Args -1;
|
|
1021
|
-
}
|
|
1022
|
-
|
|
1023
|
-
VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11;
|
|
1024
|
-
|
|
1025
|
-
if(hasSelf) {
|
|
1026
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args - 1) .c_str()
|
|
1027
|
-
, &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11);
|
|
1028
|
-
|
|
1029
|
-
Arg0_T arg0 = from_ruby<Arg0_T>(self);
|
|
1030
|
-
|
|
1031
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
|
|
1032
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
|
|
1033
|
-
Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
|
|
1034
|
-
Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
|
|
1035
|
-
Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
|
|
1036
|
-
Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
|
|
1037
|
-
Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
|
|
1038
|
-
Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
|
|
1039
|
-
Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
|
|
1040
|
-
Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(9, varg9);
|
|
1041
|
-
Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(10, varg10);
|
|
1042
|
-
|
|
1043
|
-
wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
|
|
1044
|
-
return Qnil;
|
|
1045
|
-
} else {
|
|
1046
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
|
|
1047
|
-
, &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11);
|
|
1048
|
-
|
|
1049
|
-
Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
|
|
1050
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
|
|
1051
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
|
|
1052
|
-
Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
|
|
1053
|
-
Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
|
|
1054
|
-
Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
|
|
1055
|
-
Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
|
|
1056
|
-
Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
|
|
1057
|
-
Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
|
|
1058
|
-
Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
|
|
1059
|
-
Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(10, varg10);
|
|
1060
|
-
Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(11, varg11);
|
|
1061
|
-
|
|
1062
|
-
wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
|
|
1063
|
-
return Qnil;
|
|
1064
|
-
}
|
|
1065
|
-
}
|
|
1066
|
-
catch(...)
|
|
1067
|
-
{
|
|
1068
|
-
RUBY_TRY
|
|
1069
|
-
{
|
|
1070
|
-
if(wrapper)
|
|
1071
|
-
{
|
|
1072
|
-
return wrapper->handler_->handle_exception();
|
|
1073
|
-
}
|
|
1074
|
-
else
|
|
1075
|
-
{
|
|
1076
|
-
throw;
|
|
1077
|
-
}
|
|
1078
|
-
}
|
|
1079
|
-
RUBY_CATCH
|
|
1080
|
-
}
|
|
1081
|
-
}
|
|
1082
|
-
|
|
1083
|
-
// ---------------------------------------------------------------------
|
|
1084
|
-
template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T>
|
|
1085
|
-
Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T>::
|
|
1086
|
-
Auto_Function_Wrapper(
|
|
1087
|
-
Func func,
|
|
1088
|
-
Data_Object<Exception_Handler> handler,
|
|
1089
|
-
Arguments* arguments)
|
|
1090
|
-
: Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
|
|
1091
|
-
, func_(func)
|
|
1092
|
-
, handler_(handler)
|
|
1093
|
-
, handler_guard_(&handler_)
|
|
1094
|
-
{
|
|
1095
|
-
if(arguments == 0) {
|
|
1096
|
-
arguments_ = new Arguments();
|
|
1097
|
-
} else {
|
|
1098
|
-
arguments_ = arguments;
|
|
1099
|
-
}
|
|
1100
|
-
}
|
|
1101
|
-
|
|
1102
|
-
template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T>
|
|
1103
|
-
Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T>::
|
|
1104
|
-
~Auto_Function_Wrapper()
|
|
1105
|
-
{
|
|
1106
|
-
if(arguments_) { delete arguments_; }
|
|
1107
|
-
}
|
|
1108
|
-
|
|
1109
|
-
template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T>
|
|
1110
|
-
VALUE Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T>::
|
|
1111
|
-
call(int argc, VALUE *argv, VALUE self)
|
|
1112
|
-
{
|
|
1113
|
-
Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T> * wrapper = 0;
|
|
1114
|
-
try
|
|
1115
|
-
{
|
|
1116
|
-
Data_Object<Wrapped_Function> data(detail::method_data());
|
|
1117
|
-
wrapper = (Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T> *)data.get();
|
|
1118
|
-
Arguments* args = wrapper->arguments_;
|
|
1119
|
-
|
|
1120
|
-
bool hasSelf = (self && self != Qnil);
|
|
1121
|
-
if(args->count() >= 0) {
|
|
1122
|
-
hasSelf = hasSelf && args->count() == Num_Args - 1;
|
|
1123
|
-
} else {
|
|
1124
|
-
hasSelf = hasSelf && argc == Num_Args -1;
|
|
1125
|
-
}
|
|
1126
|
-
|
|
1127
|
-
VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10;
|
|
1128
|
-
|
|
1129
|
-
if(hasSelf) {
|
|
1130
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args - 1).c_str()
|
|
1131
|
-
, &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10);
|
|
1132
|
-
|
|
1133
|
-
Arg0_T arg0 = from_ruby<Arg0_T>(self);
|
|
1134
|
-
|
|
1135
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
|
|
1136
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
|
|
1137
|
-
Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
|
|
1138
|
-
Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
|
|
1139
|
-
Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
|
|
1140
|
-
Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
|
|
1141
|
-
Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
|
|
1142
|
-
Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
|
|
1143
|
-
Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
|
|
1144
|
-
Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(9, varg9);
|
|
1145
|
-
|
|
1146
|
-
return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10));
|
|
1147
|
-
} else {
|
|
1148
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
|
|
1149
|
-
, &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10);
|
|
1150
|
-
|
|
1151
|
-
Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
|
|
1152
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
|
|
1153
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
|
|
1154
|
-
Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
|
|
1155
|
-
Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
|
|
1156
|
-
Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
|
|
1157
|
-
Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
|
|
1158
|
-
Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
|
|
1159
|
-
Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
|
|
1160
|
-
Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
|
|
1161
|
-
Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(10, varg10);
|
|
1162
|
-
|
|
1163
|
-
return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10));
|
|
1164
|
-
}
|
|
1165
|
-
}
|
|
1166
|
-
catch(...)
|
|
1167
|
-
{
|
|
1168
|
-
RUBY_TRY
|
|
1169
|
-
{
|
|
1170
|
-
if(wrapper)
|
|
1171
|
-
{
|
|
1172
|
-
return wrapper->handler_->handle_exception();
|
|
1173
|
-
}
|
|
1174
|
-
else
|
|
1175
|
-
{
|
|
1176
|
-
throw;
|
|
1177
|
-
}
|
|
1178
|
-
}
|
|
1179
|
-
RUBY_CATCH
|
|
1180
|
-
}
|
|
1181
|
-
}
|
|
1182
|
-
|
|
1183
|
-
template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T>
|
|
1184
|
-
Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T>::
|
|
1185
|
-
Auto_Function_Wrapper(
|
|
1186
|
-
Func func,
|
|
1187
|
-
Data_Object<Exception_Handler> handler,
|
|
1188
|
-
Arguments* arguments)
|
|
1189
|
-
: Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
|
|
1190
|
-
, func_(func)
|
|
1191
|
-
, handler_(handler)
|
|
1192
|
-
, handler_guard_(&handler_)
|
|
1193
|
-
{
|
|
1194
|
-
if(arguments == 0) {
|
|
1195
|
-
arguments_ = new Arguments();
|
|
1196
|
-
} else {
|
|
1197
|
-
arguments_ = arguments;
|
|
1198
|
-
}
|
|
1199
|
-
}
|
|
1200
|
-
|
|
1201
|
-
template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T>
|
|
1202
|
-
Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T>::
|
|
1203
|
-
~Auto_Function_Wrapper()
|
|
1204
|
-
{
|
|
1205
|
-
if(arguments_) { delete arguments_; }
|
|
1206
|
-
}
|
|
1207
|
-
|
|
1208
|
-
template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T>
|
|
1209
|
-
VALUE Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T>::
|
|
1210
|
-
call(int argc, VALUE* argv, VALUE self)
|
|
1211
|
-
{
|
|
1212
|
-
Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T> * wrapper = 0;
|
|
1213
|
-
try
|
|
1214
|
-
{
|
|
1215
|
-
Data_Object<Wrapped_Function> data(detail::method_data());
|
|
1216
|
-
wrapper = (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T> *)data.get();
|
|
1217
|
-
Arguments* args = wrapper->arguments_;
|
|
1218
|
-
|
|
1219
|
-
bool hasSelf = (self && self != Qnil);
|
|
1220
|
-
if(args->count() >= 0) {
|
|
1221
|
-
hasSelf = hasSelf && args->count() == Num_Args - 1;
|
|
1222
|
-
} else {
|
|
1223
|
-
hasSelf = hasSelf && argc == Num_Args -1;
|
|
1224
|
-
}
|
|
1225
|
-
|
|
1226
|
-
VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10;
|
|
1227
|
-
|
|
1228
|
-
if(hasSelf) {
|
|
1229
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args - 1) .c_str()
|
|
1230
|
-
, &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10);
|
|
1231
|
-
|
|
1232
|
-
Arg0_T arg0 = from_ruby<Arg0_T>(self);
|
|
1233
|
-
|
|
1234
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
|
|
1235
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
|
|
1236
|
-
Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
|
|
1237
|
-
Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
|
|
1238
|
-
Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
|
|
1239
|
-
Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
|
|
1240
|
-
Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
|
|
1241
|
-
Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
|
|
1242
|
-
Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
|
|
1243
|
-
Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(9, varg9);
|
|
1244
|
-
|
|
1245
|
-
wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
|
|
1246
|
-
return Qnil;
|
|
1247
|
-
} else {
|
|
1248
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
|
|
1249
|
-
, &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10);
|
|
1250
|
-
|
|
1251
|
-
Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
|
|
1252
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
|
|
1253
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
|
|
1254
|
-
Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
|
|
1255
|
-
Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
|
|
1256
|
-
Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
|
|
1257
|
-
Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
|
|
1258
|
-
Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
|
|
1259
|
-
Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
|
|
1260
|
-
Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
|
|
1261
|
-
Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(10, varg10);
|
|
1262
|
-
|
|
1263
|
-
wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
|
|
1264
|
-
return Qnil;
|
|
1265
|
-
}
|
|
1266
|
-
}
|
|
1267
|
-
catch(...)
|
|
1268
|
-
{
|
|
1269
|
-
RUBY_TRY
|
|
1270
|
-
{
|
|
1271
|
-
if(wrapper)
|
|
1272
|
-
{
|
|
1273
|
-
return wrapper->handler_->handle_exception();
|
|
1274
|
-
}
|
|
1275
|
-
else
|
|
1276
|
-
{
|
|
1277
|
-
throw;
|
|
1278
|
-
}
|
|
1279
|
-
}
|
|
1280
|
-
RUBY_CATCH
|
|
1281
|
-
}
|
|
1282
|
-
}
|
|
1283
|
-
|
|
1284
|
-
// ---------------------------------------------------------------------
|
|
1285
|
-
template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T>
|
|
1286
|
-
Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T>::
|
|
1287
|
-
Auto_Function_Wrapper(
|
|
1288
|
-
Func func,
|
|
1289
|
-
Data_Object<Exception_Handler> handler,
|
|
1290
|
-
Arguments* arguments)
|
|
1291
|
-
: Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
|
|
1292
|
-
, func_(func)
|
|
1293
|
-
, handler_(handler)
|
|
1294
|
-
, handler_guard_(&handler_)
|
|
1295
|
-
{
|
|
1296
|
-
if(arguments == 0) {
|
|
1297
|
-
arguments_ = new Arguments();
|
|
1298
|
-
} else {
|
|
1299
|
-
arguments_ = arguments;
|
|
1300
|
-
}
|
|
1301
|
-
}
|
|
1302
|
-
|
|
1303
|
-
template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T>
|
|
1304
|
-
Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T>::
|
|
1305
|
-
~Auto_Function_Wrapper()
|
|
1306
|
-
{
|
|
1307
|
-
if(arguments_) { delete arguments_; }
|
|
1308
|
-
}
|
|
1309
|
-
|
|
1310
|
-
template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T>
|
|
1311
|
-
VALUE Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T>::
|
|
1312
|
-
call(int argc, VALUE *argv, VALUE self)
|
|
1313
|
-
{
|
|
1314
|
-
Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T> * wrapper = 0;
|
|
1315
|
-
try
|
|
1316
|
-
{
|
|
1317
|
-
Data_Object<Wrapped_Function> data(detail::method_data());
|
|
1318
|
-
wrapper = (Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T> *)data.get();
|
|
1319
|
-
Arguments* args = wrapper->arguments_;
|
|
1320
|
-
|
|
1321
|
-
bool hasSelf = (self && self != Qnil);
|
|
1322
|
-
if(args->count() >= 0) {
|
|
1323
|
-
hasSelf = hasSelf && args->count() == Num_Args - 1;
|
|
1324
|
-
} else {
|
|
1325
|
-
hasSelf = hasSelf && argc == Num_Args -1;
|
|
1326
|
-
}
|
|
1327
|
-
|
|
1328
|
-
VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9;
|
|
1329
|
-
|
|
1330
|
-
if(hasSelf) {
|
|
1331
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args - 1).c_str()
|
|
1332
|
-
, &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9);
|
|
1333
|
-
|
|
1334
|
-
Arg0_T arg0 = from_ruby<Arg0_T>(self);
|
|
1335
|
-
|
|
1336
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
|
|
1337
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
|
|
1338
|
-
Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
|
|
1339
|
-
Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
|
|
1340
|
-
Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
|
|
1341
|
-
Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
|
|
1342
|
-
Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
|
|
1343
|
-
Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
|
|
1344
|
-
Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
|
|
1345
|
-
|
|
1346
|
-
return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9));
|
|
1347
|
-
} else {
|
|
1348
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
|
|
1349
|
-
, &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9);
|
|
1350
|
-
|
|
1351
|
-
Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
|
|
1352
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
|
|
1353
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
|
|
1354
|
-
Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
|
|
1355
|
-
Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
|
|
1356
|
-
Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
|
|
1357
|
-
Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
|
|
1358
|
-
Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
|
|
1359
|
-
Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
|
|
1360
|
-
Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
|
|
1361
|
-
|
|
1362
|
-
return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9));
|
|
1363
|
-
}
|
|
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 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>
|
|
1383
|
-
Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T>::
|
|
1384
|
-
Auto_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
|
-
{
|
|
1393
|
-
if(arguments == 0) {
|
|
1394
|
-
arguments_ = new Arguments();
|
|
1395
|
-
} else {
|
|
1396
|
-
arguments_ = arguments;
|
|
1397
|
-
}
|
|
1398
|
-
}
|
|
1399
|
-
|
|
1400
|
-
template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T>
|
|
1401
|
-
Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T>::
|
|
1402
|
-
~Auto_Function_Wrapper()
|
|
1403
|
-
{
|
|
1404
|
-
if(arguments_) { delete arguments_; }
|
|
1405
|
-
}
|
|
1406
|
-
|
|
1407
|
-
template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T>
|
|
1408
|
-
VALUE Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T>::
|
|
1409
|
-
call(int argc, VALUE* argv, VALUE self)
|
|
1410
|
-
{
|
|
1411
|
-
Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T> * wrapper = 0;
|
|
1412
|
-
try
|
|
1413
|
-
{
|
|
1414
|
-
Data_Object<Wrapped_Function> data(detail::method_data());
|
|
1415
|
-
wrapper = (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T> *)data.get();
|
|
1416
|
-
Arguments* args = wrapper->arguments_;
|
|
1417
|
-
|
|
1418
|
-
bool hasSelf = (self && self != Qnil);
|
|
1419
|
-
if(args->count() >= 0) {
|
|
1420
|
-
hasSelf = hasSelf && args->count() == Num_Args - 1;
|
|
1421
|
-
} else {
|
|
1422
|
-
hasSelf = hasSelf && argc == Num_Args -1;
|
|
1423
|
-
}
|
|
1424
|
-
|
|
1425
|
-
VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9;
|
|
1426
|
-
|
|
1427
|
-
if(hasSelf) {
|
|
1428
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args - 1) .c_str()
|
|
1429
|
-
, &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9);
|
|
1430
|
-
|
|
1431
|
-
Arg0_T arg0 = from_ruby<Arg0_T>(self);
|
|
1432
|
-
|
|
1433
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
|
|
1434
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
|
|
1435
|
-
Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
|
|
1436
|
-
Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
|
|
1437
|
-
Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
|
|
1438
|
-
Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
|
|
1439
|
-
Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
|
|
1440
|
-
Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
|
|
1441
|
-
Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
|
|
1442
|
-
|
|
1443
|
-
wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
|
|
1444
|
-
return Qnil;
|
|
1445
|
-
} else {
|
|
1446
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
|
|
1447
|
-
, &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9);
|
|
1448
|
-
|
|
1449
|
-
Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
|
|
1450
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
|
|
1451
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
|
|
1452
|
-
Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
|
|
1453
|
-
Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
|
|
1454
|
-
Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
|
|
1455
|
-
Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
|
|
1456
|
-
Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
|
|
1457
|
-
Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
|
|
1458
|
-
Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
|
|
1459
|
-
|
|
1460
|
-
wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
|
|
1461
|
-
return Qnil;
|
|
1462
|
-
}
|
|
1463
|
-
}
|
|
1464
|
-
catch(...)
|
|
1465
|
-
{
|
|
1466
|
-
RUBY_TRY
|
|
1467
|
-
{
|
|
1468
|
-
if(wrapper)
|
|
1469
|
-
{
|
|
1470
|
-
return wrapper->handler_->handle_exception();
|
|
1471
|
-
}
|
|
1472
|
-
else
|
|
1473
|
-
{
|
|
1474
|
-
throw;
|
|
1475
|
-
}
|
|
1476
|
-
}
|
|
1477
|
-
RUBY_CATCH
|
|
1478
|
-
}
|
|
1479
|
-
}
|
|
1480
|
-
|
|
1481
|
-
// ---------------------------------------------------------------------
|
|
1482
|
-
template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T>
|
|
1483
|
-
Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T>::
|
|
1484
|
-
Auto_Function_Wrapper(
|
|
1485
|
-
Func func,
|
|
1486
|
-
Data_Object<Exception_Handler> handler,
|
|
1487
|
-
Arguments* arguments)
|
|
1488
|
-
: Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
|
|
1489
|
-
, func_(func)
|
|
1490
|
-
, handler_(handler)
|
|
1491
|
-
, handler_guard_(&handler_)
|
|
1492
|
-
{
|
|
1493
|
-
if(arguments == 0) {
|
|
1494
|
-
arguments_ = new Arguments();
|
|
1495
|
-
} else {
|
|
1496
|
-
arguments_ = arguments;
|
|
1497
|
-
}
|
|
1498
|
-
}
|
|
1499
|
-
|
|
1500
|
-
template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T>
|
|
1501
|
-
Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T>::
|
|
1502
|
-
~Auto_Function_Wrapper()
|
|
1503
|
-
{
|
|
1504
|
-
if(arguments_) { delete arguments_; }
|
|
1505
|
-
}
|
|
1506
|
-
|
|
1507
|
-
template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T>
|
|
1508
|
-
VALUE Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T>::
|
|
1509
|
-
call(int argc, VALUE *argv, VALUE self)
|
|
1510
|
-
{
|
|
1511
|
-
Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T> * wrapper = 0;
|
|
1512
|
-
try
|
|
1513
|
-
{
|
|
1514
|
-
Data_Object<Wrapped_Function> data(detail::method_data());
|
|
1515
|
-
wrapper = (Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T> *)data.get();
|
|
1516
|
-
Arguments* args = wrapper->arguments_;
|
|
1517
|
-
|
|
1518
|
-
bool hasSelf = (self && self != Qnil);
|
|
1519
|
-
if(args->count() >= 0) {
|
|
1520
|
-
hasSelf = hasSelf && args->count() == Num_Args - 1;
|
|
1521
|
-
} else {
|
|
1522
|
-
hasSelf = hasSelf && argc == Num_Args -1;
|
|
1523
|
-
}
|
|
1524
|
-
|
|
1525
|
-
VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8;
|
|
1526
|
-
|
|
1527
|
-
if(hasSelf) {
|
|
1528
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args - 1).c_str()
|
|
1529
|
-
, &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8);
|
|
1530
|
-
|
|
1531
|
-
Arg0_T arg0 = from_ruby<Arg0_T>(self);
|
|
1532
|
-
|
|
1533
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
|
|
1534
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
|
|
1535
|
-
Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
|
|
1536
|
-
Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
|
|
1537
|
-
Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
|
|
1538
|
-
Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
|
|
1539
|
-
Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
|
|
1540
|
-
Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
|
|
1541
|
-
|
|
1542
|
-
return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8));
|
|
1543
|
-
} else {
|
|
1544
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
|
|
1545
|
-
, &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8);
|
|
1546
|
-
|
|
1547
|
-
Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
|
|
1548
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
|
|
1549
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
|
|
1550
|
-
Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
|
|
1551
|
-
Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
|
|
1552
|
-
Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
|
|
1553
|
-
Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
|
|
1554
|
-
Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
|
|
1555
|
-
Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
|
|
1556
|
-
|
|
1557
|
-
return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8));
|
|
1558
|
-
}
|
|
1559
|
-
}
|
|
1560
|
-
catch(...)
|
|
1561
|
-
{
|
|
1562
|
-
RUBY_TRY
|
|
1563
|
-
{
|
|
1564
|
-
if(wrapper)
|
|
1565
|
-
{
|
|
1566
|
-
return wrapper->handler_->handle_exception();
|
|
1567
|
-
}
|
|
1568
|
-
else
|
|
1569
|
-
{
|
|
1570
|
-
throw;
|
|
1571
|
-
}
|
|
1572
|
-
}
|
|
1573
|
-
RUBY_CATCH
|
|
1574
|
-
}
|
|
1575
|
-
}
|
|
1576
|
-
|
|
1577
|
-
template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T>
|
|
1578
|
-
Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T>::
|
|
1579
|
-
Auto_Function_Wrapper(
|
|
1580
|
-
Func func,
|
|
1581
|
-
Data_Object<Exception_Handler> handler,
|
|
1582
|
-
Arguments* arguments)
|
|
1583
|
-
: Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
|
|
1584
|
-
, func_(func)
|
|
1585
|
-
, handler_(handler)
|
|
1586
|
-
, handler_guard_(&handler_)
|
|
1587
|
-
{
|
|
1588
|
-
if(arguments == 0) {
|
|
1589
|
-
arguments_ = new Arguments();
|
|
1590
|
-
} else {
|
|
1591
|
-
arguments_ = arguments;
|
|
1592
|
-
}
|
|
1593
|
-
}
|
|
1594
|
-
|
|
1595
|
-
template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T>
|
|
1596
|
-
Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T>::
|
|
1597
|
-
~Auto_Function_Wrapper()
|
|
1598
|
-
{
|
|
1599
|
-
if(arguments_) { delete arguments_; }
|
|
1600
|
-
}
|
|
1601
|
-
|
|
1602
|
-
template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T>
|
|
1603
|
-
VALUE Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T>::
|
|
1604
|
-
call(int argc, VALUE* argv, VALUE self)
|
|
1605
|
-
{
|
|
1606
|
-
Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T> * wrapper = 0;
|
|
1607
|
-
try
|
|
1608
|
-
{
|
|
1609
|
-
Data_Object<Wrapped_Function> data(detail::method_data());
|
|
1610
|
-
wrapper = (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T> *)data.get();
|
|
1611
|
-
Arguments* args = wrapper->arguments_;
|
|
1612
|
-
|
|
1613
|
-
bool hasSelf = (self && self != Qnil);
|
|
1614
|
-
if(args->count() >= 0) {
|
|
1615
|
-
hasSelf = hasSelf && args->count() == Num_Args - 1;
|
|
1616
|
-
} else {
|
|
1617
|
-
hasSelf = hasSelf && argc == Num_Args -1;
|
|
1618
|
-
}
|
|
1619
|
-
|
|
1620
|
-
VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8;
|
|
1621
|
-
|
|
1622
|
-
if(hasSelf) {
|
|
1623
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args - 1) .c_str()
|
|
1624
|
-
, &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8);
|
|
1625
|
-
|
|
1626
|
-
Arg0_T arg0 = from_ruby<Arg0_T>(self);
|
|
1627
|
-
|
|
1628
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
|
|
1629
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
|
|
1630
|
-
Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
|
|
1631
|
-
Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
|
|
1632
|
-
Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
|
|
1633
|
-
Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
|
|
1634
|
-
Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
|
|
1635
|
-
Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
|
|
1636
|
-
|
|
1637
|
-
wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
|
|
1638
|
-
return Qnil;
|
|
1639
|
-
} else {
|
|
1640
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
|
|
1641
|
-
, &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8);
|
|
1642
|
-
|
|
1643
|
-
Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
|
|
1644
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
|
|
1645
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
|
|
1646
|
-
Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
|
|
1647
|
-
Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
|
|
1648
|
-
Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
|
|
1649
|
-
Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
|
|
1650
|
-
Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
|
|
1651
|
-
Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
|
|
1652
|
-
|
|
1653
|
-
wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
|
|
1654
|
-
return Qnil;
|
|
1655
|
-
}
|
|
1656
|
-
}
|
|
1657
|
-
catch(...)
|
|
1658
|
-
{
|
|
1659
|
-
RUBY_TRY
|
|
1660
|
-
{
|
|
1661
|
-
if(wrapper)
|
|
1662
|
-
{
|
|
1663
|
-
return wrapper->handler_->handle_exception();
|
|
1664
|
-
}
|
|
1665
|
-
else
|
|
1666
|
-
{
|
|
1667
|
-
throw;
|
|
1668
|
-
}
|
|
1669
|
-
}
|
|
1670
|
-
RUBY_CATCH
|
|
1671
|
-
}
|
|
1672
|
-
}
|
|
1673
|
-
|
|
1674
|
-
// ---------------------------------------------------------------------
|
|
1675
|
-
template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T>
|
|
1676
|
-
Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T>::
|
|
1677
|
-
Auto_Function_Wrapper(
|
|
1678
|
-
Func func,
|
|
1679
|
-
Data_Object<Exception_Handler> handler,
|
|
1680
|
-
Arguments* arguments)
|
|
1681
|
-
: Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
|
|
1682
|
-
, func_(func)
|
|
1683
|
-
, handler_(handler)
|
|
1684
|
-
, handler_guard_(&handler_)
|
|
1685
|
-
{
|
|
1686
|
-
if(arguments == 0) {
|
|
1687
|
-
arguments_ = new Arguments();
|
|
1688
|
-
} else {
|
|
1689
|
-
arguments_ = arguments;
|
|
1690
|
-
}
|
|
1691
|
-
}
|
|
1692
|
-
|
|
1693
|
-
template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T>
|
|
1694
|
-
Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T>::
|
|
1695
|
-
~Auto_Function_Wrapper()
|
|
1696
|
-
{
|
|
1697
|
-
if(arguments_) { delete arguments_; }
|
|
1698
|
-
}
|
|
1699
|
-
|
|
1700
|
-
template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T>
|
|
1701
|
-
VALUE Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T>::
|
|
1702
|
-
call(int argc, VALUE *argv, VALUE self)
|
|
1703
|
-
{
|
|
1704
|
-
Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T> * wrapper = 0;
|
|
1705
|
-
try
|
|
1706
|
-
{
|
|
1707
|
-
Data_Object<Wrapped_Function> data(detail::method_data());
|
|
1708
|
-
wrapper = (Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T> *)data.get();
|
|
1709
|
-
Arguments* args = wrapper->arguments_;
|
|
1710
|
-
|
|
1711
|
-
bool hasSelf = (self && self != Qnil);
|
|
1712
|
-
if(args->count() >= 0) {
|
|
1713
|
-
hasSelf = hasSelf && args->count() == Num_Args - 1;
|
|
1714
|
-
} else {
|
|
1715
|
-
hasSelf = hasSelf && argc == Num_Args -1;
|
|
1716
|
-
}
|
|
1717
|
-
|
|
1718
|
-
VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7;
|
|
1719
|
-
|
|
1720
|
-
if(hasSelf) {
|
|
1721
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args - 1).c_str()
|
|
1722
|
-
, &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7);
|
|
1723
|
-
|
|
1724
|
-
Arg0_T arg0 = from_ruby<Arg0_T>(self);
|
|
1725
|
-
|
|
1726
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
|
|
1727
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
|
|
1728
|
-
Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
|
|
1729
|
-
Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
|
|
1730
|
-
Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
|
|
1731
|
-
Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
|
|
1732
|
-
Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
|
|
1733
|
-
|
|
1734
|
-
return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7));
|
|
1735
|
-
} else {
|
|
1736
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
|
|
1737
|
-
, &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7);
|
|
1738
|
-
|
|
1739
|
-
Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
|
|
1740
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
|
|
1741
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
|
|
1742
|
-
Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
|
|
1743
|
-
Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
|
|
1744
|
-
Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
|
|
1745
|
-
Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
|
|
1746
|
-
Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
|
|
1747
|
-
|
|
1748
|
-
return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7));
|
|
1749
|
-
}
|
|
1750
|
-
}
|
|
1751
|
-
catch(...)
|
|
1752
|
-
{
|
|
1753
|
-
RUBY_TRY
|
|
1754
|
-
{
|
|
1755
|
-
if(wrapper)
|
|
1756
|
-
{
|
|
1757
|
-
return wrapper->handler_->handle_exception();
|
|
1758
|
-
}
|
|
1759
|
-
else
|
|
1760
|
-
{
|
|
1761
|
-
throw;
|
|
1762
|
-
}
|
|
1763
|
-
}
|
|
1764
|
-
RUBY_CATCH
|
|
1765
|
-
}
|
|
1766
|
-
}
|
|
1767
|
-
|
|
1768
|
-
template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T>
|
|
1769
|
-
Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T>::
|
|
1770
|
-
Auto_Function_Wrapper(
|
|
1771
|
-
Func func,
|
|
1772
|
-
Data_Object<Exception_Handler> handler,
|
|
1773
|
-
Arguments* arguments)
|
|
1774
|
-
: Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
|
|
1775
|
-
, func_(func)
|
|
1776
|
-
, handler_(handler)
|
|
1777
|
-
, handler_guard_(&handler_)
|
|
1778
|
-
{
|
|
1779
|
-
if(arguments == 0) {
|
|
1780
|
-
arguments_ = new Arguments();
|
|
1781
|
-
} else {
|
|
1782
|
-
arguments_ = arguments;
|
|
1783
|
-
}
|
|
1784
|
-
}
|
|
1785
|
-
|
|
1786
|
-
template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T>
|
|
1787
|
-
Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T>::
|
|
1788
|
-
~Auto_Function_Wrapper()
|
|
1789
|
-
{
|
|
1790
|
-
if(arguments_) { delete arguments_; }
|
|
1791
|
-
}
|
|
1792
|
-
|
|
1793
|
-
template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T>
|
|
1794
|
-
VALUE Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T>::
|
|
1795
|
-
call(int argc, VALUE* argv, VALUE self)
|
|
1796
|
-
{
|
|
1797
|
-
Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T> * wrapper = 0;
|
|
1798
|
-
try
|
|
1799
|
-
{
|
|
1800
|
-
Data_Object<Wrapped_Function> data(detail::method_data());
|
|
1801
|
-
wrapper = (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T> *)data.get();
|
|
1802
|
-
Arguments* args = wrapper->arguments_;
|
|
1803
|
-
|
|
1804
|
-
bool hasSelf = (self && self != Qnil);
|
|
1805
|
-
if(args->count() >= 0) {
|
|
1806
|
-
hasSelf = hasSelf && args->count() == Num_Args - 1;
|
|
1807
|
-
} else {
|
|
1808
|
-
hasSelf = hasSelf && argc == Num_Args -1;
|
|
1809
|
-
}
|
|
1810
|
-
|
|
1811
|
-
VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7;
|
|
1812
|
-
|
|
1813
|
-
if(hasSelf) {
|
|
1814
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args - 1) .c_str()
|
|
1815
|
-
, &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7);
|
|
1816
|
-
|
|
1817
|
-
Arg0_T arg0 = from_ruby<Arg0_T>(self);
|
|
1818
|
-
|
|
1819
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
|
|
1820
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
|
|
1821
|
-
Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
|
|
1822
|
-
Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
|
|
1823
|
-
Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
|
|
1824
|
-
Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
|
|
1825
|
-
Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
|
|
1826
|
-
|
|
1827
|
-
wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
|
|
1828
|
-
return Qnil;
|
|
1829
|
-
} else {
|
|
1830
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
|
|
1831
|
-
, &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7);
|
|
1832
|
-
|
|
1833
|
-
Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
|
|
1834
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
|
|
1835
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
|
|
1836
|
-
Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
|
|
1837
|
-
Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
|
|
1838
|
-
Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
|
|
1839
|
-
Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
|
|
1840
|
-
Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
|
|
1841
|
-
|
|
1842
|
-
wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
|
|
1843
|
-
return Qnil;
|
|
1844
|
-
}
|
|
1845
|
-
}
|
|
1846
|
-
catch(...)
|
|
1847
|
-
{
|
|
1848
|
-
RUBY_TRY
|
|
1849
|
-
{
|
|
1850
|
-
if(wrapper)
|
|
1851
|
-
{
|
|
1852
|
-
return wrapper->handler_->handle_exception();
|
|
1853
|
-
}
|
|
1854
|
-
else
|
|
1855
|
-
{
|
|
1856
|
-
throw;
|
|
1857
|
-
}
|
|
1858
|
-
}
|
|
1859
|
-
RUBY_CATCH
|
|
1860
|
-
}
|
|
1861
|
-
}
|
|
1862
|
-
|
|
1863
|
-
// ---------------------------------------------------------------------
|
|
1864
|
-
template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T>
|
|
1865
|
-
Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T>::
|
|
1866
|
-
Auto_Function_Wrapper(
|
|
1867
|
-
Func func,
|
|
1868
|
-
Data_Object<Exception_Handler> handler,
|
|
1869
|
-
Arguments* arguments)
|
|
1870
|
-
: Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
|
|
1871
|
-
, func_(func)
|
|
1872
|
-
, handler_(handler)
|
|
1873
|
-
, handler_guard_(&handler_)
|
|
1874
|
-
{
|
|
1875
|
-
if(arguments == 0) {
|
|
1876
|
-
arguments_ = new Arguments();
|
|
1877
|
-
} else {
|
|
1878
|
-
arguments_ = arguments;
|
|
1879
|
-
}
|
|
1880
|
-
}
|
|
1881
|
-
|
|
1882
|
-
template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T>
|
|
1883
|
-
Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T>::
|
|
1884
|
-
~Auto_Function_Wrapper()
|
|
1885
|
-
{
|
|
1886
|
-
if(arguments_) { delete arguments_; }
|
|
1887
|
-
}
|
|
1888
|
-
|
|
1889
|
-
template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T>
|
|
1890
|
-
VALUE Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T>::
|
|
1891
|
-
call(int argc, VALUE *argv, VALUE self)
|
|
1892
|
-
{
|
|
1893
|
-
Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T> * wrapper = 0;
|
|
1894
|
-
try
|
|
1895
|
-
{
|
|
1896
|
-
Data_Object<Wrapped_Function> data(detail::method_data());
|
|
1897
|
-
wrapper = (Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T> *)data.get();
|
|
1898
|
-
Arguments* args = wrapper->arguments_;
|
|
1899
|
-
|
|
1900
|
-
bool hasSelf = (self && self != Qnil);
|
|
1901
|
-
if(args->count() >= 0) {
|
|
1902
|
-
hasSelf = hasSelf && args->count() == Num_Args - 1;
|
|
1903
|
-
} else {
|
|
1904
|
-
hasSelf = hasSelf && argc == Num_Args -1;
|
|
1905
|
-
}
|
|
1906
|
-
|
|
1907
|
-
VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6;
|
|
1908
|
-
|
|
1909
|
-
if(hasSelf) {
|
|
1910
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args - 1).c_str()
|
|
1911
|
-
, &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6);
|
|
1912
|
-
|
|
1913
|
-
Arg0_T arg0 = from_ruby<Arg0_T>(self);
|
|
1914
|
-
|
|
1915
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
|
|
1916
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
|
|
1917
|
-
Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
|
|
1918
|
-
Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
|
|
1919
|
-
Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
|
|
1920
|
-
Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
|
|
1921
|
-
|
|
1922
|
-
return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6));
|
|
1923
|
-
} else {
|
|
1924
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
|
|
1925
|
-
, &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6);
|
|
1926
|
-
|
|
1927
|
-
Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
|
|
1928
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
|
|
1929
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
|
|
1930
|
-
Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
|
|
1931
|
-
Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
|
|
1932
|
-
Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
|
|
1933
|
-
Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
|
|
1934
|
-
|
|
1935
|
-
return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6));
|
|
1936
|
-
}
|
|
1937
|
-
}
|
|
1938
|
-
catch(...)
|
|
1939
|
-
{
|
|
1940
|
-
RUBY_TRY
|
|
1941
|
-
{
|
|
1942
|
-
if(wrapper)
|
|
1943
|
-
{
|
|
1944
|
-
return wrapper->handler_->handle_exception();
|
|
1945
|
-
}
|
|
1946
|
-
else
|
|
1947
|
-
{
|
|
1948
|
-
throw;
|
|
1949
|
-
}
|
|
1950
|
-
}
|
|
1951
|
-
RUBY_CATCH
|
|
1952
|
-
}
|
|
1953
|
-
}
|
|
1954
|
-
|
|
1955
|
-
template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T>
|
|
1956
|
-
Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T>::
|
|
1957
|
-
Auto_Function_Wrapper(
|
|
1958
|
-
Func func,
|
|
1959
|
-
Data_Object<Exception_Handler> handler,
|
|
1960
|
-
Arguments* arguments)
|
|
1961
|
-
: Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
|
|
1962
|
-
, func_(func)
|
|
1963
|
-
, handler_(handler)
|
|
1964
|
-
, handler_guard_(&handler_)
|
|
1965
|
-
{
|
|
1966
|
-
if(arguments == 0) {
|
|
1967
|
-
arguments_ = new Arguments();
|
|
1968
|
-
} else {
|
|
1969
|
-
arguments_ = arguments;
|
|
1970
|
-
}
|
|
1971
|
-
}
|
|
1972
|
-
|
|
1973
|
-
template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T>
|
|
1974
|
-
Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T>::
|
|
1975
|
-
~Auto_Function_Wrapper()
|
|
1976
|
-
{
|
|
1977
|
-
if(arguments_) { delete arguments_; }
|
|
1978
|
-
}
|
|
1979
|
-
|
|
1980
|
-
template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T>
|
|
1981
|
-
VALUE Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T>::
|
|
1982
|
-
call(int argc, VALUE* argv, VALUE self)
|
|
1983
|
-
{
|
|
1984
|
-
Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T> * wrapper = 0;
|
|
1985
|
-
try
|
|
1986
|
-
{
|
|
1987
|
-
Data_Object<Wrapped_Function> data(detail::method_data());
|
|
1988
|
-
wrapper = (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T> *)data.get();
|
|
1989
|
-
Arguments* args = wrapper->arguments_;
|
|
1990
|
-
|
|
1991
|
-
bool hasSelf = (self && self != Qnil);
|
|
1992
|
-
if(args->count() >= 0) {
|
|
1993
|
-
hasSelf = hasSelf && args->count() == Num_Args - 1;
|
|
1994
|
-
} else {
|
|
1995
|
-
hasSelf = hasSelf && argc == Num_Args -1;
|
|
1996
|
-
}
|
|
1997
|
-
|
|
1998
|
-
VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6;
|
|
1999
|
-
|
|
2000
|
-
if(hasSelf) {
|
|
2001
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args - 1) .c_str()
|
|
2002
|
-
, &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6);
|
|
2003
|
-
|
|
2004
|
-
Arg0_T arg0 = from_ruby<Arg0_T>(self);
|
|
2005
|
-
|
|
2006
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
|
|
2007
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
|
|
2008
|
-
Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
|
|
2009
|
-
Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
|
|
2010
|
-
Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
|
|
2011
|
-
Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
|
|
2012
|
-
|
|
2013
|
-
wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
|
|
2014
|
-
return Qnil;
|
|
2015
|
-
} else {
|
|
2016
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
|
|
2017
|
-
, &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6);
|
|
2018
|
-
|
|
2019
|
-
Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
|
|
2020
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
|
|
2021
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
|
|
2022
|
-
Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
|
|
2023
|
-
Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
|
|
2024
|
-
Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
|
|
2025
|
-
Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
|
|
2026
|
-
|
|
2027
|
-
wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
|
|
2028
|
-
return Qnil;
|
|
2029
|
-
}
|
|
2030
|
-
}
|
|
2031
|
-
catch(...)
|
|
2032
|
-
{
|
|
2033
|
-
RUBY_TRY
|
|
2034
|
-
{
|
|
2035
|
-
if(wrapper)
|
|
2036
|
-
{
|
|
2037
|
-
return wrapper->handler_->handle_exception();
|
|
2038
|
-
}
|
|
2039
|
-
else
|
|
2040
|
-
{
|
|
2041
|
-
throw;
|
|
2042
|
-
}
|
|
2043
|
-
}
|
|
2044
|
-
RUBY_CATCH
|
|
2045
|
-
}
|
|
2046
|
-
}
|
|
2047
|
-
|
|
2048
|
-
// ---------------------------------------------------------------------
|
|
2049
|
-
template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T>
|
|
2050
|
-
Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T>::
|
|
2051
|
-
Auto_Function_Wrapper(
|
|
2052
|
-
Func func,
|
|
2053
|
-
Data_Object<Exception_Handler> handler,
|
|
2054
|
-
Arguments* arguments)
|
|
2055
|
-
: Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
|
|
2056
|
-
, func_(func)
|
|
2057
|
-
, handler_(handler)
|
|
2058
|
-
, handler_guard_(&handler_)
|
|
2059
|
-
{
|
|
2060
|
-
if(arguments == 0) {
|
|
2061
|
-
arguments_ = new Arguments();
|
|
2062
|
-
} else {
|
|
2063
|
-
arguments_ = arguments;
|
|
2064
|
-
}
|
|
2065
|
-
}
|
|
2066
|
-
|
|
2067
|
-
template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T>
|
|
2068
|
-
Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T>::
|
|
2069
|
-
~Auto_Function_Wrapper()
|
|
2070
|
-
{
|
|
2071
|
-
if(arguments_) { delete arguments_; }
|
|
2072
|
-
}
|
|
2073
|
-
|
|
2074
|
-
template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T>
|
|
2075
|
-
VALUE Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T>::
|
|
2076
|
-
call(int argc, VALUE *argv, VALUE self)
|
|
2077
|
-
{
|
|
2078
|
-
Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T> * wrapper = 0;
|
|
2079
|
-
try
|
|
2080
|
-
{
|
|
2081
|
-
Data_Object<Wrapped_Function> data(detail::method_data());
|
|
2082
|
-
wrapper = (Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T> *)data.get();
|
|
2083
|
-
Arguments* args = wrapper->arguments_;
|
|
2084
|
-
|
|
2085
|
-
bool hasSelf = (self && self != Qnil);
|
|
2086
|
-
if(args->count() >= 0) {
|
|
2087
|
-
hasSelf = hasSelf && args->count() == Num_Args - 1;
|
|
2088
|
-
} else {
|
|
2089
|
-
hasSelf = hasSelf && argc == Num_Args -1;
|
|
2090
|
-
}
|
|
2091
|
-
|
|
2092
|
-
VALUE varg0, varg1, varg2, varg3, varg4, varg5;
|
|
2093
|
-
|
|
2094
|
-
if(hasSelf) {
|
|
2095
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args - 1).c_str()
|
|
2096
|
-
, &varg0, &varg1, &varg2, &varg3, &varg4, &varg5);
|
|
2097
|
-
|
|
2098
|
-
Arg0_T arg0 = from_ruby<Arg0_T>(self);
|
|
2099
|
-
|
|
2100
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
|
|
2101
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
|
|
2102
|
-
Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
|
|
2103
|
-
Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
|
|
2104
|
-
Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
|
|
2105
|
-
|
|
2106
|
-
return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5));
|
|
2107
|
-
} else {
|
|
2108
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
|
|
2109
|
-
, &varg0, &varg1, &varg2, &varg3, &varg4, &varg5);
|
|
2110
|
-
|
|
2111
|
-
Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
|
|
2112
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
|
|
2113
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
|
|
2114
|
-
Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
|
|
2115
|
-
Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
|
|
2116
|
-
Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
|
|
2117
|
-
|
|
2118
|
-
return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5));
|
|
2119
|
-
}
|
|
2120
|
-
}
|
|
2121
|
-
catch(...)
|
|
2122
|
-
{
|
|
2123
|
-
RUBY_TRY
|
|
2124
|
-
{
|
|
2125
|
-
if(wrapper)
|
|
2126
|
-
{
|
|
2127
|
-
return wrapper->handler_->handle_exception();
|
|
2128
|
-
}
|
|
2129
|
-
else
|
|
2130
|
-
{
|
|
2131
|
-
throw;
|
|
2132
|
-
}
|
|
2133
|
-
}
|
|
2134
|
-
RUBY_CATCH
|
|
2135
|
-
}
|
|
2136
|
-
}
|
|
2137
|
-
|
|
2138
|
-
template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T>
|
|
2139
|
-
Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T>::
|
|
2140
|
-
Auto_Function_Wrapper(
|
|
2141
|
-
Func func,
|
|
2142
|
-
Data_Object<Exception_Handler> handler,
|
|
2143
|
-
Arguments* arguments)
|
|
2144
|
-
: Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
|
|
2145
|
-
, func_(func)
|
|
2146
|
-
, handler_(handler)
|
|
2147
|
-
, handler_guard_(&handler_)
|
|
2148
|
-
{
|
|
2149
|
-
if(arguments == 0) {
|
|
2150
|
-
arguments_ = new Arguments();
|
|
2151
|
-
} else {
|
|
2152
|
-
arguments_ = arguments;
|
|
2153
|
-
}
|
|
2154
|
-
}
|
|
2155
|
-
|
|
2156
|
-
template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T>
|
|
2157
|
-
Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T>::
|
|
2158
|
-
~Auto_Function_Wrapper()
|
|
2159
|
-
{
|
|
2160
|
-
if(arguments_) { delete arguments_; }
|
|
2161
|
-
}
|
|
2162
|
-
|
|
2163
|
-
template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T>
|
|
2164
|
-
VALUE Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T>::
|
|
2165
|
-
call(int argc, VALUE* argv, VALUE self)
|
|
2166
|
-
{
|
|
2167
|
-
Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T> * wrapper = 0;
|
|
2168
|
-
try
|
|
2169
|
-
{
|
|
2170
|
-
Data_Object<Wrapped_Function> data(detail::method_data());
|
|
2171
|
-
wrapper = (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T> *)data.get();
|
|
2172
|
-
Arguments* args = wrapper->arguments_;
|
|
2173
|
-
|
|
2174
|
-
bool hasSelf = (self && self != Qnil);
|
|
2175
|
-
if(args->count() >= 0) {
|
|
2176
|
-
hasSelf = hasSelf && args->count() == Num_Args - 1;
|
|
2177
|
-
} else {
|
|
2178
|
-
hasSelf = hasSelf && argc == Num_Args -1;
|
|
2179
|
-
}
|
|
2180
|
-
|
|
2181
|
-
VALUE varg0, varg1, varg2, varg3, varg4, varg5;
|
|
2182
|
-
|
|
2183
|
-
if(hasSelf) {
|
|
2184
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args - 1) .c_str()
|
|
2185
|
-
, &varg0, &varg1, &varg2, &varg3, &varg4, &varg5);
|
|
2186
|
-
|
|
2187
|
-
Arg0_T arg0 = from_ruby<Arg0_T>(self);
|
|
2188
|
-
|
|
2189
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
|
|
2190
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
|
|
2191
|
-
Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
|
|
2192
|
-
Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
|
|
2193
|
-
Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
|
|
2194
|
-
|
|
2195
|
-
wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5);
|
|
2196
|
-
return Qnil;
|
|
2197
|
-
} else {
|
|
2198
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
|
|
2199
|
-
, &varg0, &varg1, &varg2, &varg3, &varg4, &varg5);
|
|
2200
|
-
|
|
2201
|
-
Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
|
|
2202
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
|
|
2203
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
|
|
2204
|
-
Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
|
|
2205
|
-
Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
|
|
2206
|
-
Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
|
|
2207
|
-
|
|
2208
|
-
wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5);
|
|
2209
|
-
return Qnil;
|
|
2210
|
-
}
|
|
2211
|
-
}
|
|
2212
|
-
catch(...)
|
|
2213
|
-
{
|
|
2214
|
-
RUBY_TRY
|
|
2215
|
-
{
|
|
2216
|
-
if(wrapper)
|
|
2217
|
-
{
|
|
2218
|
-
return wrapper->handler_->handle_exception();
|
|
2219
|
-
}
|
|
2220
|
-
else
|
|
2221
|
-
{
|
|
2222
|
-
throw;
|
|
2223
|
-
}
|
|
2224
|
-
}
|
|
2225
|
-
RUBY_CATCH
|
|
2226
|
-
}
|
|
2227
|
-
}
|
|
2228
|
-
|
|
2229
|
-
// ---------------------------------------------------------------------
|
|
2230
|
-
template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T>
|
|
2231
|
-
Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T>::
|
|
2232
|
-
Auto_Function_Wrapper(
|
|
2233
|
-
Func func,
|
|
2234
|
-
Data_Object<Exception_Handler> handler,
|
|
2235
|
-
Arguments* arguments)
|
|
2236
|
-
: Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
|
|
2237
|
-
, func_(func)
|
|
2238
|
-
, handler_(handler)
|
|
2239
|
-
, handler_guard_(&handler_)
|
|
2240
|
-
{
|
|
2241
|
-
if(arguments == 0) {
|
|
2242
|
-
arguments_ = new Arguments();
|
|
2243
|
-
} else {
|
|
2244
|
-
arguments_ = arguments;
|
|
2245
|
-
}
|
|
2246
|
-
}
|
|
2247
|
-
|
|
2248
|
-
template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T>
|
|
2249
|
-
Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T>::
|
|
2250
|
-
~Auto_Function_Wrapper()
|
|
2251
|
-
{
|
|
2252
|
-
if(arguments_) { delete arguments_; }
|
|
2253
|
-
}
|
|
2254
|
-
|
|
2255
|
-
template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T>
|
|
2256
|
-
VALUE Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T>::
|
|
2257
|
-
call(int argc, VALUE *argv, VALUE self)
|
|
2258
|
-
{
|
|
2259
|
-
Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T> * wrapper = 0;
|
|
2260
|
-
try
|
|
2261
|
-
{
|
|
2262
|
-
Data_Object<Wrapped_Function> data(detail::method_data());
|
|
2263
|
-
wrapper = (Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T> *)data.get();
|
|
2264
|
-
Arguments* args = wrapper->arguments_;
|
|
2265
|
-
|
|
2266
|
-
bool hasSelf = (self && self != Qnil);
|
|
2267
|
-
if(args->count() >= 0) {
|
|
2268
|
-
hasSelf = hasSelf && args->count() == Num_Args - 1;
|
|
2269
|
-
} else {
|
|
2270
|
-
hasSelf = hasSelf && argc == Num_Args -1;
|
|
2271
|
-
}
|
|
2272
|
-
|
|
2273
|
-
VALUE varg0, varg1, varg2, varg3, varg4;
|
|
2274
|
-
|
|
2275
|
-
if(hasSelf) {
|
|
2276
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args - 1).c_str()
|
|
2277
|
-
, &varg0, &varg1, &varg2, &varg3, &varg4);
|
|
2278
|
-
|
|
2279
|
-
Arg0_T arg0 = from_ruby<Arg0_T>(self);
|
|
2280
|
-
|
|
2281
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
|
|
2282
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
|
|
2283
|
-
Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
|
|
2284
|
-
Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
|
|
2285
|
-
|
|
2286
|
-
return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4));
|
|
2287
|
-
} else {
|
|
2288
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
|
|
2289
|
-
, &varg0, &varg1, &varg2, &varg3, &varg4);
|
|
2290
|
-
|
|
2291
|
-
Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
|
|
2292
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
|
|
2293
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
|
|
2294
|
-
Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
|
|
2295
|
-
Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
|
|
2296
|
-
|
|
2297
|
-
return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4));
|
|
2298
|
-
}
|
|
2299
|
-
}
|
|
2300
|
-
catch(...)
|
|
2301
|
-
{
|
|
2302
|
-
RUBY_TRY
|
|
2303
|
-
{
|
|
2304
|
-
if(wrapper)
|
|
2305
|
-
{
|
|
2306
|
-
return wrapper->handler_->handle_exception();
|
|
2307
|
-
}
|
|
2308
|
-
else
|
|
2309
|
-
{
|
|
2310
|
-
throw;
|
|
2311
|
-
}
|
|
2312
|
-
}
|
|
2313
|
-
RUBY_CATCH
|
|
2314
|
-
}
|
|
2315
|
-
}
|
|
2316
|
-
|
|
2317
|
-
template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T>
|
|
2318
|
-
Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T>::
|
|
2319
|
-
Auto_Function_Wrapper(
|
|
2320
|
-
Func func,
|
|
2321
|
-
Data_Object<Exception_Handler> handler,
|
|
2322
|
-
Arguments* arguments)
|
|
2323
|
-
: Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
|
|
2324
|
-
, func_(func)
|
|
2325
|
-
, handler_(handler)
|
|
2326
|
-
, handler_guard_(&handler_)
|
|
2327
|
-
{
|
|
2328
|
-
if(arguments == 0) {
|
|
2329
|
-
arguments_ = new Arguments();
|
|
2330
|
-
} else {
|
|
2331
|
-
arguments_ = arguments;
|
|
2332
|
-
}
|
|
2333
|
-
}
|
|
2334
|
-
|
|
2335
|
-
template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T>
|
|
2336
|
-
Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T>::
|
|
2337
|
-
~Auto_Function_Wrapper()
|
|
2338
|
-
{
|
|
2339
|
-
if(arguments_) { delete arguments_; }
|
|
2340
|
-
}
|
|
2341
|
-
|
|
2342
|
-
template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T>
|
|
2343
|
-
VALUE Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T>::
|
|
2344
|
-
call(int argc, VALUE* argv, VALUE self)
|
|
2345
|
-
{
|
|
2346
|
-
Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T> * wrapper = 0;
|
|
2347
|
-
try
|
|
2348
|
-
{
|
|
2349
|
-
Data_Object<Wrapped_Function> data(detail::method_data());
|
|
2350
|
-
wrapper = (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T> *)data.get();
|
|
2351
|
-
Arguments* args = wrapper->arguments_;
|
|
2352
|
-
|
|
2353
|
-
bool hasSelf = (self && self != Qnil);
|
|
2354
|
-
if(args->count() >= 0) {
|
|
2355
|
-
hasSelf = hasSelf && args->count() == Num_Args - 1;
|
|
2356
|
-
} else {
|
|
2357
|
-
hasSelf = hasSelf && argc == Num_Args -1;
|
|
2358
|
-
}
|
|
2359
|
-
|
|
2360
|
-
VALUE varg0, varg1, varg2, varg3, varg4;
|
|
2361
|
-
|
|
2362
|
-
if(hasSelf) {
|
|
2363
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args - 1) .c_str()
|
|
2364
|
-
, &varg0, &varg1, &varg2, &varg3, &varg4);
|
|
2365
|
-
|
|
2366
|
-
Arg0_T arg0 = from_ruby<Arg0_T>(self);
|
|
2367
|
-
|
|
2368
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
|
|
2369
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
|
|
2370
|
-
Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
|
|
2371
|
-
Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
|
|
2372
|
-
|
|
2373
|
-
wrapper->func_(arg0, arg1, arg2, arg3, arg4);
|
|
2374
|
-
return Qnil;
|
|
2375
|
-
} else {
|
|
2376
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
|
|
2377
|
-
, &varg0, &varg1, &varg2, &varg3, &varg4);
|
|
2378
|
-
|
|
2379
|
-
Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
|
|
2380
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
|
|
2381
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
|
|
2382
|
-
Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
|
|
2383
|
-
Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
|
|
2384
|
-
|
|
2385
|
-
wrapper->func_(arg0, arg1, arg2, arg3, arg4);
|
|
2386
|
-
return Qnil;
|
|
2387
|
-
}
|
|
2388
|
-
}
|
|
2389
|
-
catch(...)
|
|
2390
|
-
{
|
|
2391
|
-
RUBY_TRY
|
|
2392
|
-
{
|
|
2393
|
-
if(wrapper)
|
|
2394
|
-
{
|
|
2395
|
-
return wrapper->handler_->handle_exception();
|
|
2396
|
-
}
|
|
2397
|
-
else
|
|
2398
|
-
{
|
|
2399
|
-
throw;
|
|
2400
|
-
}
|
|
2401
|
-
}
|
|
2402
|
-
RUBY_CATCH
|
|
2403
|
-
}
|
|
2404
|
-
}
|
|
2405
|
-
|
|
2406
|
-
// ---------------------------------------------------------------------
|
|
2407
|
-
template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T>
|
|
2408
|
-
Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T>::
|
|
2409
|
-
Auto_Function_Wrapper(
|
|
2410
|
-
Func func,
|
|
2411
|
-
Data_Object<Exception_Handler> handler,
|
|
2412
|
-
Arguments* arguments)
|
|
2413
|
-
: Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
|
|
2414
|
-
, func_(func)
|
|
2415
|
-
, handler_(handler)
|
|
2416
|
-
, handler_guard_(&handler_)
|
|
2417
|
-
{
|
|
2418
|
-
if(arguments == 0) {
|
|
2419
|
-
arguments_ = new Arguments();
|
|
2420
|
-
} else {
|
|
2421
|
-
arguments_ = arguments;
|
|
2422
|
-
}
|
|
2423
|
-
}
|
|
2424
|
-
|
|
2425
|
-
template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T>
|
|
2426
|
-
Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T>::
|
|
2427
|
-
~Auto_Function_Wrapper()
|
|
2428
|
-
{
|
|
2429
|
-
if(arguments_) { delete arguments_; }
|
|
2430
|
-
}
|
|
2431
|
-
|
|
2432
|
-
template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T>
|
|
2433
|
-
VALUE Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T>::
|
|
2434
|
-
call(int argc, VALUE *argv, VALUE self)
|
|
2435
|
-
{
|
|
2436
|
-
Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T> * wrapper = 0;
|
|
2437
|
-
try
|
|
2438
|
-
{
|
|
2439
|
-
Data_Object<Wrapped_Function> data(detail::method_data());
|
|
2440
|
-
wrapper = (Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T> *)data.get();
|
|
2441
|
-
Arguments* args = wrapper->arguments_;
|
|
2442
|
-
|
|
2443
|
-
bool hasSelf = (self && self != Qnil);
|
|
2444
|
-
if(args->count() >= 0) {
|
|
2445
|
-
hasSelf = hasSelf && args->count() == Num_Args - 1;
|
|
2446
|
-
} else {
|
|
2447
|
-
hasSelf = hasSelf && argc == Num_Args -1;
|
|
2448
|
-
}
|
|
2449
|
-
|
|
2450
|
-
VALUE varg0, varg1, varg2, varg3;
|
|
2451
|
-
|
|
2452
|
-
if(hasSelf) {
|
|
2453
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args - 1).c_str()
|
|
2454
|
-
, &varg0, &varg1, &varg2, &varg3);
|
|
2455
|
-
|
|
2456
|
-
Arg0_T arg0 = from_ruby<Arg0_T>(self);
|
|
2457
|
-
|
|
2458
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
|
|
2459
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
|
|
2460
|
-
Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
|
|
2461
|
-
|
|
2462
|
-
return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3));
|
|
2463
|
-
} else {
|
|
2464
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
|
|
2465
|
-
, &varg0, &varg1, &varg2, &varg3);
|
|
2466
|
-
|
|
2467
|
-
Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
|
|
2468
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
|
|
2469
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
|
|
2470
|
-
Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
|
|
2471
|
-
|
|
2472
|
-
return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3));
|
|
2473
|
-
}
|
|
2474
|
-
}
|
|
2475
|
-
catch(...)
|
|
2476
|
-
{
|
|
2477
|
-
RUBY_TRY
|
|
2478
|
-
{
|
|
2479
|
-
if(wrapper)
|
|
2480
|
-
{
|
|
2481
|
-
return wrapper->handler_->handle_exception();
|
|
2482
|
-
}
|
|
2483
|
-
else
|
|
2484
|
-
{
|
|
2485
|
-
throw;
|
|
2486
|
-
}
|
|
2487
|
-
}
|
|
2488
|
-
RUBY_CATCH
|
|
2489
|
-
}
|
|
2490
|
-
}
|
|
2491
|
-
|
|
2492
|
-
template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T>
|
|
2493
|
-
Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T>::
|
|
2494
|
-
Auto_Function_Wrapper(
|
|
2495
|
-
Func func,
|
|
2496
|
-
Data_Object<Exception_Handler> handler,
|
|
2497
|
-
Arguments* arguments)
|
|
2498
|
-
: Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
|
|
2499
|
-
, func_(func)
|
|
2500
|
-
, handler_(handler)
|
|
2501
|
-
, handler_guard_(&handler_)
|
|
2502
|
-
{
|
|
2503
|
-
if(arguments == 0) {
|
|
2504
|
-
arguments_ = new Arguments();
|
|
2505
|
-
} else {
|
|
2506
|
-
arguments_ = arguments;
|
|
2507
|
-
}
|
|
2508
|
-
}
|
|
2509
|
-
|
|
2510
|
-
template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T>
|
|
2511
|
-
Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T>::
|
|
2512
|
-
~Auto_Function_Wrapper()
|
|
2513
|
-
{
|
|
2514
|
-
if(arguments_) { delete arguments_; }
|
|
2515
|
-
}
|
|
2516
|
-
|
|
2517
|
-
template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T>
|
|
2518
|
-
VALUE Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T>::
|
|
2519
|
-
call(int argc, VALUE* argv, VALUE self)
|
|
2520
|
-
{
|
|
2521
|
-
Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T> * wrapper = 0;
|
|
2522
|
-
try
|
|
2523
|
-
{
|
|
2524
|
-
Data_Object<Wrapped_Function> data(detail::method_data());
|
|
2525
|
-
wrapper = (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T> *)data.get();
|
|
2526
|
-
Arguments* args = wrapper->arguments_;
|
|
2527
|
-
|
|
2528
|
-
bool hasSelf = (self && self != Qnil);
|
|
2529
|
-
if(args->count() >= 0) {
|
|
2530
|
-
hasSelf = hasSelf && args->count() == Num_Args - 1;
|
|
2531
|
-
} else {
|
|
2532
|
-
hasSelf = hasSelf && argc == Num_Args -1;
|
|
2533
|
-
}
|
|
2534
|
-
|
|
2535
|
-
VALUE varg0, varg1, varg2, varg3;
|
|
2536
|
-
|
|
2537
|
-
if(hasSelf) {
|
|
2538
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args - 1) .c_str()
|
|
2539
|
-
, &varg0, &varg1, &varg2, &varg3);
|
|
2540
|
-
|
|
2541
|
-
Arg0_T arg0 = from_ruby<Arg0_T>(self);
|
|
2542
|
-
|
|
2543
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
|
|
2544
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
|
|
2545
|
-
Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
|
|
2546
|
-
|
|
2547
|
-
wrapper->func_(arg0, arg1, arg2, arg3);
|
|
2548
|
-
return Qnil;
|
|
2549
|
-
} else {
|
|
2550
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
|
|
2551
|
-
, &varg0, &varg1, &varg2, &varg3);
|
|
2552
|
-
|
|
2553
|
-
Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
|
|
2554
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
|
|
2555
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
|
|
2556
|
-
Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
|
|
2557
|
-
|
|
2558
|
-
wrapper->func_(arg0, arg1, arg2, arg3);
|
|
2559
|
-
return Qnil;
|
|
2560
|
-
}
|
|
2561
|
-
}
|
|
2562
|
-
catch(...)
|
|
2563
|
-
{
|
|
2564
|
-
RUBY_TRY
|
|
2565
|
-
{
|
|
2566
|
-
if(wrapper)
|
|
2567
|
-
{
|
|
2568
|
-
return wrapper->handler_->handle_exception();
|
|
2569
|
-
}
|
|
2570
|
-
else
|
|
2571
|
-
{
|
|
2572
|
-
throw;
|
|
2573
|
-
}
|
|
2574
|
-
}
|
|
2575
|
-
RUBY_CATCH
|
|
2576
|
-
}
|
|
2577
|
-
}
|
|
2578
|
-
|
|
2579
|
-
// ---------------------------------------------------------------------
|
|
2580
|
-
template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T>
|
|
2581
|
-
Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T>::
|
|
2582
|
-
Auto_Function_Wrapper(
|
|
2583
|
-
Func func,
|
|
2584
|
-
Data_Object<Exception_Handler> handler,
|
|
2585
|
-
Arguments* arguments)
|
|
2586
|
-
: Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
|
|
2587
|
-
, func_(func)
|
|
2588
|
-
, handler_(handler)
|
|
2589
|
-
, handler_guard_(&handler_)
|
|
2590
|
-
{
|
|
2591
|
-
if(arguments == 0) {
|
|
2592
|
-
arguments_ = new Arguments();
|
|
2593
|
-
} else {
|
|
2594
|
-
arguments_ = arguments;
|
|
2595
|
-
}
|
|
2596
|
-
}
|
|
2597
|
-
|
|
2598
|
-
template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T>
|
|
2599
|
-
Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T>::
|
|
2600
|
-
~Auto_Function_Wrapper()
|
|
2601
|
-
{
|
|
2602
|
-
if(arguments_) { delete arguments_; }
|
|
2603
|
-
}
|
|
2604
|
-
|
|
2605
|
-
template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T>
|
|
2606
|
-
VALUE Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T>::
|
|
2607
|
-
call(int argc, VALUE *argv, VALUE self)
|
|
2608
|
-
{
|
|
2609
|
-
Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T> * wrapper = 0;
|
|
2610
|
-
try
|
|
2611
|
-
{
|
|
2612
|
-
Data_Object<Wrapped_Function> data(detail::method_data());
|
|
2613
|
-
wrapper = (Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T> *)data.get();
|
|
2614
|
-
Arguments* args = wrapper->arguments_;
|
|
2615
|
-
|
|
2616
|
-
bool hasSelf = (self && self != Qnil);
|
|
2617
|
-
if(args->count() >= 0) {
|
|
2618
|
-
hasSelf = hasSelf && args->count() == Num_Args - 1;
|
|
2619
|
-
} else {
|
|
2620
|
-
hasSelf = hasSelf && argc == Num_Args -1;
|
|
2621
|
-
}
|
|
2622
|
-
|
|
2623
|
-
VALUE varg0, varg1, varg2;
|
|
2624
|
-
|
|
2625
|
-
if(hasSelf) {
|
|
2626
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args - 1).c_str()
|
|
2627
|
-
, &varg0, &varg1, &varg2);
|
|
2628
|
-
|
|
2629
|
-
Arg0_T arg0 = from_ruby<Arg0_T>(self);
|
|
2630
|
-
|
|
2631
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
|
|
2632
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
|
|
2633
|
-
|
|
2634
|
-
return to_ruby(wrapper->func_(arg0, arg1, arg2));
|
|
2635
|
-
} else {
|
|
2636
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
|
|
2637
|
-
, &varg0, &varg1, &varg2);
|
|
2638
|
-
|
|
2639
|
-
Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
|
|
2640
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
|
|
2641
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
|
|
2642
|
-
|
|
2643
|
-
return to_ruby(wrapper->func_(arg0, arg1, arg2));
|
|
2644
|
-
}
|
|
2645
|
-
}
|
|
2646
|
-
catch(...)
|
|
2647
|
-
{
|
|
2648
|
-
RUBY_TRY
|
|
2649
|
-
{
|
|
2650
|
-
if(wrapper)
|
|
2651
|
-
{
|
|
2652
|
-
return wrapper->handler_->handle_exception();
|
|
2653
|
-
}
|
|
2654
|
-
else
|
|
2655
|
-
{
|
|
2656
|
-
throw;
|
|
2657
|
-
}
|
|
2658
|
-
}
|
|
2659
|
-
RUBY_CATCH
|
|
2660
|
-
}
|
|
2661
|
-
}
|
|
2662
|
-
|
|
2663
|
-
template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T>
|
|
2664
|
-
Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T>::
|
|
2665
|
-
Auto_Function_Wrapper(
|
|
2666
|
-
Func func,
|
|
2667
|
-
Data_Object<Exception_Handler> handler,
|
|
2668
|
-
Arguments* arguments)
|
|
2669
|
-
: Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
|
|
2670
|
-
, func_(func)
|
|
2671
|
-
, handler_(handler)
|
|
2672
|
-
, handler_guard_(&handler_)
|
|
2673
|
-
{
|
|
2674
|
-
if(arguments == 0) {
|
|
2675
|
-
arguments_ = new Arguments();
|
|
2676
|
-
} else {
|
|
2677
|
-
arguments_ = arguments;
|
|
2678
|
-
}
|
|
2679
|
-
}
|
|
2680
|
-
|
|
2681
|
-
template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T>
|
|
2682
|
-
Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T>::
|
|
2683
|
-
~Auto_Function_Wrapper()
|
|
2684
|
-
{
|
|
2685
|
-
if(arguments_) { delete arguments_; }
|
|
2686
|
-
}
|
|
2687
|
-
|
|
2688
|
-
template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T>
|
|
2689
|
-
VALUE Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T>::
|
|
2690
|
-
call(int argc, VALUE* argv, VALUE self)
|
|
2691
|
-
{
|
|
2692
|
-
Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T> * wrapper = 0;
|
|
2693
|
-
try
|
|
2694
|
-
{
|
|
2695
|
-
Data_Object<Wrapped_Function> data(detail::method_data());
|
|
2696
|
-
wrapper = (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T> *)data.get();
|
|
2697
|
-
Arguments* args = wrapper->arguments_;
|
|
2698
|
-
|
|
2699
|
-
bool hasSelf = (self && self != Qnil);
|
|
2700
|
-
if(args->count() >= 0) {
|
|
2701
|
-
hasSelf = hasSelf && args->count() == Num_Args - 1;
|
|
2702
|
-
} else {
|
|
2703
|
-
hasSelf = hasSelf && argc == Num_Args -1;
|
|
2704
|
-
}
|
|
2705
|
-
|
|
2706
|
-
VALUE varg0, varg1, varg2;
|
|
2707
|
-
|
|
2708
|
-
if(hasSelf) {
|
|
2709
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args - 1) .c_str()
|
|
2710
|
-
, &varg0, &varg1, &varg2);
|
|
2711
|
-
|
|
2712
|
-
Arg0_T arg0 = from_ruby<Arg0_T>(self);
|
|
2713
|
-
|
|
2714
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
|
|
2715
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
|
|
2716
|
-
|
|
2717
|
-
wrapper->func_(arg0, arg1, arg2);
|
|
2718
|
-
return Qnil;
|
|
2719
|
-
} else {
|
|
2720
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
|
|
2721
|
-
, &varg0, &varg1, &varg2);
|
|
2722
|
-
|
|
2723
|
-
Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
|
|
2724
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
|
|
2725
|
-
Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
|
|
2726
|
-
|
|
2727
|
-
wrapper->func_(arg0, arg1, arg2);
|
|
2728
|
-
return Qnil;
|
|
2729
|
-
}
|
|
2730
|
-
}
|
|
2731
|
-
catch(...)
|
|
2732
|
-
{
|
|
2733
|
-
RUBY_TRY
|
|
2734
|
-
{
|
|
2735
|
-
if(wrapper)
|
|
2736
|
-
{
|
|
2737
|
-
return wrapper->handler_->handle_exception();
|
|
2738
|
-
}
|
|
2739
|
-
else
|
|
2740
|
-
{
|
|
2741
|
-
throw;
|
|
2742
|
-
}
|
|
2743
|
-
}
|
|
2744
|
-
RUBY_CATCH
|
|
2745
|
-
}
|
|
2746
|
-
}
|
|
2747
|
-
|
|
2748
|
-
// ---------------------------------------------------------------------
|
|
2749
|
-
template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T>
|
|
2750
|
-
Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T>::
|
|
2751
|
-
Auto_Function_Wrapper(
|
|
2752
|
-
Func func,
|
|
2753
|
-
Data_Object<Exception_Handler> handler,
|
|
2754
|
-
Arguments* arguments)
|
|
2755
|
-
: Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
|
|
2756
|
-
, func_(func)
|
|
2757
|
-
, handler_(handler)
|
|
2758
|
-
, handler_guard_(&handler_)
|
|
2759
|
-
{
|
|
2760
|
-
if(arguments == 0) {
|
|
2761
|
-
arguments_ = new Arguments();
|
|
2762
|
-
} else {
|
|
2763
|
-
arguments_ = arguments;
|
|
2764
|
-
}
|
|
2765
|
-
}
|
|
2766
|
-
|
|
2767
|
-
template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T>
|
|
2768
|
-
Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T>::
|
|
2769
|
-
~Auto_Function_Wrapper()
|
|
2770
|
-
{
|
|
2771
|
-
if(arguments_) { delete arguments_; }
|
|
2772
|
-
}
|
|
2773
|
-
|
|
2774
|
-
template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T>
|
|
2775
|
-
VALUE Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T>::
|
|
2776
|
-
call(int argc, VALUE *argv, VALUE self)
|
|
2777
|
-
{
|
|
2778
|
-
Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T> * wrapper = 0;
|
|
2779
|
-
try
|
|
2780
|
-
{
|
|
2781
|
-
Data_Object<Wrapped_Function> data(detail::method_data());
|
|
2782
|
-
wrapper = (Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T> *)data.get();
|
|
2783
|
-
Arguments* args = wrapper->arguments_;
|
|
2784
|
-
|
|
2785
|
-
bool hasSelf = (self && self != Qnil);
|
|
2786
|
-
if(args->count() >= 0) {
|
|
2787
|
-
hasSelf = hasSelf && args->count() == Num_Args - 1;
|
|
2788
|
-
} else {
|
|
2789
|
-
hasSelf = hasSelf && argc == Num_Args -1;
|
|
2790
|
-
}
|
|
2791
|
-
|
|
2792
|
-
VALUE varg0, varg1;
|
|
2793
|
-
|
|
2794
|
-
if(hasSelf) {
|
|
2795
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args - 1).c_str()
|
|
2796
|
-
, &varg0, &varg1);
|
|
2797
|
-
|
|
2798
|
-
Arg0_T arg0 = from_ruby<Arg0_T>(self);
|
|
2799
|
-
|
|
2800
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
|
|
2801
|
-
|
|
2802
|
-
return to_ruby(wrapper->func_(arg0, arg1));
|
|
2803
|
-
} else {
|
|
2804
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
|
|
2805
|
-
, &varg0, &varg1);
|
|
2806
|
-
|
|
2807
|
-
Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
|
|
2808
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
|
|
2809
|
-
|
|
2810
|
-
return to_ruby(wrapper->func_(arg0, arg1));
|
|
2811
|
-
}
|
|
2812
|
-
}
|
|
2813
|
-
catch(...)
|
|
2814
|
-
{
|
|
2815
|
-
RUBY_TRY
|
|
2816
|
-
{
|
|
2817
|
-
if(wrapper)
|
|
2818
|
-
{
|
|
2819
|
-
return wrapper->handler_->handle_exception();
|
|
2820
|
-
}
|
|
2821
|
-
else
|
|
2822
|
-
{
|
|
2823
|
-
throw;
|
|
2824
|
-
}
|
|
2825
|
-
}
|
|
2826
|
-
RUBY_CATCH
|
|
2827
|
-
}
|
|
2828
|
-
}
|
|
2829
|
-
|
|
2830
|
-
template<typename Func_T, typename Arg0_T, typename Arg1_T>
|
|
2831
|
-
Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T>::
|
|
2832
|
-
Auto_Function_Wrapper(
|
|
2833
|
-
Func func,
|
|
2834
|
-
Data_Object<Exception_Handler> handler,
|
|
2835
|
-
Arguments* arguments)
|
|
2836
|
-
: Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
|
|
2837
|
-
, func_(func)
|
|
2838
|
-
, handler_(handler)
|
|
2839
|
-
, handler_guard_(&handler_)
|
|
2840
|
-
{
|
|
2841
|
-
if(arguments == 0) {
|
|
2842
|
-
arguments_ = new Arguments();
|
|
2843
|
-
} else {
|
|
2844
|
-
arguments_ = arguments;
|
|
2845
|
-
}
|
|
2846
|
-
}
|
|
2847
|
-
|
|
2848
|
-
template<typename Func_T, typename Arg0_T, typename Arg1_T>
|
|
2849
|
-
Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T>::
|
|
2850
|
-
~Auto_Function_Wrapper()
|
|
2851
|
-
{
|
|
2852
|
-
if(arguments_) { delete arguments_; }
|
|
2853
|
-
}
|
|
2854
|
-
|
|
2855
|
-
template<typename Func_T, typename Arg0_T, typename Arg1_T>
|
|
2856
|
-
VALUE Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T>::
|
|
2857
|
-
call(int argc, VALUE* argv, VALUE self)
|
|
2858
|
-
{
|
|
2859
|
-
Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T> * wrapper = 0;
|
|
2860
|
-
try
|
|
2861
|
-
{
|
|
2862
|
-
Data_Object<Wrapped_Function> data(detail::method_data());
|
|
2863
|
-
wrapper = (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T> *)data.get();
|
|
2864
|
-
Arguments* args = wrapper->arguments_;
|
|
2865
|
-
|
|
2866
|
-
bool hasSelf = (self && self != Qnil);
|
|
2867
|
-
if(args->count() >= 0) {
|
|
2868
|
-
hasSelf = hasSelf && args->count() == Num_Args - 1;
|
|
2869
|
-
} else {
|
|
2870
|
-
hasSelf = hasSelf && argc == Num_Args -1;
|
|
2871
|
-
}
|
|
2872
|
-
|
|
2873
|
-
VALUE varg0, varg1;
|
|
2874
|
-
|
|
2875
|
-
if(hasSelf) {
|
|
2876
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args - 1) .c_str()
|
|
2877
|
-
, &varg0, &varg1);
|
|
2878
|
-
|
|
2879
|
-
Arg0_T arg0 = from_ruby<Arg0_T>(self);
|
|
2880
|
-
|
|
2881
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
|
|
2882
|
-
|
|
2883
|
-
wrapper->func_(arg0, arg1);
|
|
2884
|
-
return Qnil;
|
|
2885
|
-
} else {
|
|
2886
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
|
|
2887
|
-
, &varg0, &varg1);
|
|
2888
|
-
|
|
2889
|
-
Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
|
|
2890
|
-
Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
|
|
2891
|
-
|
|
2892
|
-
wrapper->func_(arg0, arg1);
|
|
2893
|
-
return Qnil;
|
|
2894
|
-
}
|
|
2895
|
-
}
|
|
2896
|
-
catch(...)
|
|
2897
|
-
{
|
|
2898
|
-
RUBY_TRY
|
|
2899
|
-
{
|
|
2900
|
-
if(wrapper)
|
|
2901
|
-
{
|
|
2902
|
-
return wrapper->handler_->handle_exception();
|
|
2903
|
-
}
|
|
2904
|
-
else
|
|
2905
|
-
{
|
|
2906
|
-
throw;
|
|
2907
|
-
}
|
|
2908
|
-
}
|
|
2909
|
-
RUBY_CATCH
|
|
2910
|
-
}
|
|
2911
|
-
}
|
|
2912
|
-
|
|
2913
|
-
// ---------------------------------------------------------------------
|
|
2914
|
-
template<typename Func_T, typename Ret_T, typename Arg0_T>
|
|
2915
|
-
Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T>::
|
|
2916
|
-
Auto_Function_Wrapper(
|
|
2917
|
-
Func func,
|
|
2918
|
-
Data_Object<Exception_Handler> handler,
|
|
2919
|
-
Arguments* arguments)
|
|
2920
|
-
: Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
|
|
2921
|
-
, func_(func)
|
|
2922
|
-
, handler_(handler)
|
|
2923
|
-
, handler_guard_(&handler_)
|
|
2924
|
-
{
|
|
2925
|
-
if(arguments == 0) {
|
|
2926
|
-
arguments_ = new Arguments();
|
|
2927
|
-
} else {
|
|
2928
|
-
arguments_ = arguments;
|
|
2929
|
-
}
|
|
2930
|
-
}
|
|
2931
|
-
|
|
2932
|
-
template<typename Func_T, typename Ret_T, typename Arg0_T>
|
|
2933
|
-
Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T>::
|
|
2934
|
-
~Auto_Function_Wrapper()
|
|
2935
|
-
{
|
|
2936
|
-
if(arguments_) { delete arguments_; }
|
|
2937
|
-
}
|
|
2938
|
-
|
|
2939
|
-
template<typename Func_T, typename Ret_T, typename Arg0_T>
|
|
2940
|
-
VALUE Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T>::
|
|
2941
|
-
call(int argc, VALUE *argv, VALUE self)
|
|
2942
|
-
{
|
|
2943
|
-
Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T> * wrapper = 0;
|
|
2944
|
-
try
|
|
2945
|
-
{
|
|
2946
|
-
Data_Object<Wrapped_Function> data(detail::method_data());
|
|
2947
|
-
wrapper = (Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T> *)data.get();
|
|
2948
|
-
Arguments* args = wrapper->arguments_;
|
|
2949
|
-
|
|
2950
|
-
bool hasSelf = (self && self != Qnil);
|
|
2951
|
-
if(args->count() >= 0) {
|
|
2952
|
-
hasSelf = hasSelf && args->count() == Num_Args - 1;
|
|
2953
|
-
} else {
|
|
2954
|
-
hasSelf = hasSelf && argc == Num_Args -1;
|
|
2955
|
-
}
|
|
2956
|
-
|
|
2957
|
-
VALUE varg0;
|
|
2958
|
-
|
|
2959
|
-
if(hasSelf) {
|
|
2960
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args - 1).c_str()
|
|
2961
|
-
, &varg0);
|
|
2962
|
-
|
|
2963
|
-
Arg0_T arg0 = from_ruby<Arg0_T>(self);
|
|
2964
|
-
|
|
2965
|
-
|
|
2966
|
-
return to_ruby(wrapper->func_(arg0));
|
|
2967
|
-
} else {
|
|
2968
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
|
|
2969
|
-
, &varg0);
|
|
2970
|
-
|
|
2971
|
-
Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
|
|
2972
|
-
|
|
2973
|
-
return to_ruby(wrapper->func_(arg0));
|
|
2974
|
-
}
|
|
2975
|
-
}
|
|
2976
|
-
catch(...)
|
|
2977
|
-
{
|
|
2978
|
-
RUBY_TRY
|
|
2979
|
-
{
|
|
2980
|
-
if(wrapper)
|
|
2981
|
-
{
|
|
2982
|
-
return wrapper->handler_->handle_exception();
|
|
2983
|
-
}
|
|
2984
|
-
else
|
|
2985
|
-
{
|
|
2986
|
-
throw;
|
|
2987
|
-
}
|
|
2988
|
-
}
|
|
2989
|
-
RUBY_CATCH
|
|
2990
|
-
}
|
|
2991
|
-
}
|
|
2992
|
-
|
|
2993
|
-
template<typename Func_T, typename Arg0_T>
|
|
2994
|
-
Auto_Function_Wrapper<Func_T, void, Arg0_T>::
|
|
2995
|
-
Auto_Function_Wrapper(
|
|
2996
|
-
Func func,
|
|
2997
|
-
Data_Object<Exception_Handler> handler,
|
|
2998
|
-
Arguments* arguments)
|
|
2999
|
-
: Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
|
|
3000
|
-
, func_(func)
|
|
3001
|
-
, handler_(handler)
|
|
3002
|
-
, handler_guard_(&handler_)
|
|
3003
|
-
{
|
|
3004
|
-
if(arguments == 0) {
|
|
3005
|
-
arguments_ = new Arguments();
|
|
3006
|
-
} else {
|
|
3007
|
-
arguments_ = arguments;
|
|
3008
|
-
}
|
|
3009
|
-
}
|
|
3010
|
-
|
|
3011
|
-
template<typename Func_T, typename Arg0_T>
|
|
3012
|
-
Auto_Function_Wrapper<Func_T, void, Arg0_T>::
|
|
3013
|
-
~Auto_Function_Wrapper()
|
|
3014
|
-
{
|
|
3015
|
-
if(arguments_) { delete arguments_; }
|
|
3016
|
-
}
|
|
3017
|
-
|
|
3018
|
-
template<typename Func_T, typename Arg0_T>
|
|
3019
|
-
VALUE Auto_Function_Wrapper<Func_T, void, Arg0_T>::
|
|
3020
|
-
call(int argc, VALUE* argv, VALUE self)
|
|
3021
|
-
{
|
|
3022
|
-
Auto_Function_Wrapper<Func_T, void, Arg0_T> * wrapper = 0;
|
|
3023
|
-
try
|
|
3024
|
-
{
|
|
3025
|
-
Data_Object<Wrapped_Function> data(detail::method_data());
|
|
3026
|
-
wrapper = (Auto_Function_Wrapper<Func_T, void, Arg0_T> *)data.get();
|
|
3027
|
-
Arguments* args = wrapper->arguments_;
|
|
3028
|
-
|
|
3029
|
-
bool hasSelf = (self && self != Qnil);
|
|
3030
|
-
if(args->count() >= 0) {
|
|
3031
|
-
hasSelf = hasSelf && args->count() == Num_Args - 1;
|
|
3032
|
-
} else {
|
|
3033
|
-
hasSelf = hasSelf && argc == Num_Args -1;
|
|
3034
|
-
}
|
|
3035
|
-
|
|
3036
|
-
VALUE varg0;
|
|
3037
|
-
|
|
3038
|
-
if(hasSelf) {
|
|
3039
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args - 1) .c_str()
|
|
3040
|
-
, &varg0);
|
|
3041
|
-
|
|
3042
|
-
Arg0_T arg0 = from_ruby<Arg0_T>(self);
|
|
3043
|
-
|
|
3044
|
-
|
|
3045
|
-
wrapper->func_(arg0);
|
|
3046
|
-
return Qnil;
|
|
3047
|
-
} else {
|
|
3048
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
|
|
3049
|
-
, &varg0);
|
|
3050
|
-
|
|
3051
|
-
Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
|
|
3052
|
-
|
|
3053
|
-
wrapper->func_(arg0);
|
|
3054
|
-
return Qnil;
|
|
3055
|
-
}
|
|
3056
|
-
}
|
|
3057
|
-
catch(...)
|
|
3058
|
-
{
|
|
3059
|
-
RUBY_TRY
|
|
3060
|
-
{
|
|
3061
|
-
if(wrapper)
|
|
3062
|
-
{
|
|
3063
|
-
return wrapper->handler_->handle_exception();
|
|
3064
|
-
}
|
|
3065
|
-
else
|
|
3066
|
-
{
|
|
3067
|
-
throw;
|
|
3068
|
-
}
|
|
3069
|
-
}
|
|
3070
|
-
RUBY_CATCH
|
|
3071
|
-
}
|
|
3072
|
-
}
|
|
3073
|
-
|
|
3074
|
-
// ---------------------------------------------------------------------
|
|
3075
|
-
|
|
3076
|
-
template<typename Func_T, typename Ret_T>
|
|
3077
|
-
Auto_Function_Wrapper<Func_T, Ret_T>::
|
|
3078
|
-
Auto_Function_Wrapper(
|
|
3079
|
-
Func func,
|
|
3080
|
-
Data_Object<Exception_Handler> handler,
|
|
3081
|
-
Arguments* arguments)
|
|
3082
|
-
: Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
|
|
3083
|
-
, func_(func)
|
|
3084
|
-
, handler_(handler ? handler : new Default_Exception_Handler)
|
|
3085
|
-
, arguments_(arguments)
|
|
3086
|
-
{
|
|
3087
|
-
}
|
|
3088
|
-
|
|
3089
|
-
template<typename Func_T, typename Ret_T>
|
|
3090
|
-
Auto_Function_Wrapper<Func_T, Ret_T>::
|
|
3091
|
-
~Auto_Function_Wrapper()
|
|
3092
|
-
{
|
|
3093
|
-
if(arguments_) { delete arguments_; }
|
|
3094
|
-
}
|
|
3095
|
-
|
|
3096
|
-
template<typename Func_T, typename Ret_T>
|
|
3097
|
-
VALUE Auto_Function_Wrapper<Func_T, Ret_T>::
|
|
3098
|
-
call()
|
|
3099
|
-
{
|
|
3100
|
-
Auto_Function_Wrapper<Func_T, Ret_T> * wrapper = 0;
|
|
3101
|
-
try
|
|
3102
|
-
{
|
|
3103
|
-
Data_Object<Wrapped_Function> data(detail::method_data());
|
|
3104
|
-
wrapper = (Auto_Function_Wrapper<Func_T, Ret_T>*)data.get();
|
|
3105
|
-
|
|
3106
|
-
return to_ruby(wrapper->func_());
|
|
3107
|
-
}
|
|
3108
|
-
catch(...)
|
|
3109
|
-
{
|
|
3110
|
-
RUBY_TRY
|
|
3111
|
-
{
|
|
3112
|
-
if(wrapper)
|
|
3113
|
-
{
|
|
3114
|
-
return wrapper->handler_->handle_exception();
|
|
3115
|
-
}
|
|
3116
|
-
else
|
|
3117
|
-
{
|
|
3118
|
-
throw;
|
|
3119
|
-
}
|
|
3120
|
-
}
|
|
3121
|
-
RUBY_CATCH
|
|
3122
|
-
}
|
|
3123
|
-
}
|
|
3124
|
-
|
|
3125
|
-
template<typename Func_T>
|
|
3126
|
-
Auto_Function_Wrapper<Func_T, void>::
|
|
3127
|
-
Auto_Function_Wrapper(
|
|
3128
|
-
Func func,
|
|
3129
|
-
Data_Object<Exception_Handler> handler,
|
|
3130
|
-
Arguments* arguments)
|
|
3131
|
-
: Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
|
|
3132
|
-
, func_(func)
|
|
3133
|
-
, handler_(handler ? handler : new Default_Exception_Handler)
|
|
3134
|
-
, arguments_(arguments)
|
|
3135
|
-
{
|
|
3136
|
-
}
|
|
3137
|
-
|
|
3138
|
-
template<typename Func_T>
|
|
3139
|
-
Auto_Function_Wrapper<Func_T, void>::
|
|
3140
|
-
~Auto_Function_Wrapper()
|
|
3141
|
-
{
|
|
3142
|
-
if(arguments_) { delete arguments_; }
|
|
3143
|
-
}
|
|
3144
|
-
|
|
3145
|
-
template<typename Func_T>
|
|
3146
|
-
VALUE Auto_Function_Wrapper<Func_T, void>::
|
|
3147
|
-
call()
|
|
3148
|
-
{
|
|
3149
|
-
Auto_Function_Wrapper<Func_T, void> * wrapper = 0;
|
|
3150
|
-
try
|
|
3151
|
-
{
|
|
3152
|
-
Data_Object<Wrapped_Function> data(detail::method_data());
|
|
3153
|
-
wrapper = (Auto_Function_Wrapper<Func_T, void> *)data.get();
|
|
3154
|
-
|
|
3155
|
-
wrapper->func_();
|
|
3156
|
-
return Qnil;
|
|
3157
|
-
}
|
|
3158
|
-
catch(...)
|
|
3159
|
-
{
|
|
3160
|
-
RUBY_TRY
|
|
3161
|
-
{
|
|
3162
|
-
if(wrapper)
|
|
3163
|
-
{
|
|
3164
|
-
return wrapper->handler_->handle_exception();
|
|
3165
|
-
}
|
|
3166
|
-
else
|
|
3167
|
-
{
|
|
3168
|
-
throw;
|
|
3169
|
-
}
|
|
3170
|
-
}
|
|
3171
|
-
RUBY_CATCH
|
|
3172
|
-
}
|
|
3173
|
-
}
|
|
3174
|
-
|
|
3175
|
-
} // namespace detail
|
|
3176
|
-
|
|
3177
|
-
} // namespace Rice
|
|
3178
|
-
|
|
3179
|
-
|
|
3180
|
-
#endif // Rice__detail__Auto_Function_Wrapper__ipp_
|
|
3181
|
-
|