rice 2.2.0 → 3.0.0

Sign up to get free protection for your applications and to get access to all the features.
Files changed (76) hide show
  1. checksums.yaml +4 -4
  2. data/COPYING +2 -2
  3. data/Doxyfile +1 -1
  4. data/Makefile.in +15 -7
  5. data/README.md +115 -117
  6. data/aclocal.m4 +25 -28
  7. data/ax_cxx_compile_stdcxx.m4 +951 -0
  8. data/configure +486 -61
  9. data/configure.ac +3 -3
  10. data/extconf.rb +6 -2
  11. data/rice/Array.hpp +16 -16
  12. data/rice/Array.ipp +11 -11
  13. data/rice/Class_defn.hpp +1 -0
  14. data/rice/Constructor.hpp +27 -371
  15. data/rice/Director.hpp +3 -3
  16. data/rice/Exception.cpp +2 -7
  17. data/rice/Hash.hpp +8 -5
  18. data/rice/Makefile.am +0 -4
  19. data/rice/Makefile.in +6 -10
  20. data/rice/Object.cpp +1 -1
  21. data/rice/Object.ipp +15 -1
  22. data/rice/Object_defn.hpp +24 -1
  23. data/rice/String.cpp +2 -7
  24. data/rice/Struct.cpp +2 -2
  25. data/rice/Struct.hpp +1 -1
  26. data/rice/Struct.ipp +1 -1
  27. data/rice/config.hpp +2 -2
  28. data/rice/config.hpp.in +2 -2
  29. data/rice/detail/Arguments.hpp +1 -1
  30. data/rice/detail/Auto_Function_Wrapper.ipp +512 -1025
  31. data/rice/detail/Auto_Member_Function_Wrapper.ipp +272 -545
  32. data/rice/detail/ruby.hpp +0 -4
  33. data/rice/detail/ruby_version_code.hpp +1 -1
  34. data/rice/detail/wrap_function.hpp +32 -307
  35. data/rice/protect.hpp +3 -57
  36. data/rice/to_from_ruby.ipp +3 -3
  37. data/ruby/Makefile.in +4 -4
  38. data/ruby/lib/Makefile.in +4 -4
  39. data/ruby/lib/version.rb +1 -1
  40. data/sample/Makefile.am +10 -4
  41. data/sample/Makefile.in +14 -8
  42. data/sample/callbacks/extconf.rb +3 -0
  43. data/sample/callbacks/sample_callbacks.cpp +38 -0
  44. data/sample/callbacks/test.rb +28 -0
  45. data/test/Makefile.am +1 -0
  46. data/test/Makefile.in +15 -9
  47. data/test/embed_ruby.cpp +21 -0
  48. data/test/embed_ruby.hpp +4 -0
  49. data/test/ext/Makefile.in +4 -4
  50. data/test/test_Address_Registration_Guard.cpp +2 -1
  51. data/test/test_Array.cpp +2 -1
  52. data/test/test_Builtin_Object.cpp +2 -1
  53. data/test/test_Class.cpp +2 -1
  54. data/test/test_Data_Object.cpp +2 -1
  55. data/test/test_Data_Type.cpp +2 -1
  56. data/test/test_Director.cpp +2 -1
  57. data/test/test_Enum.cpp +2 -1
  58. data/test/test_Exception.cpp +2 -1
  59. data/test/test_Hash.cpp +2 -1
  60. data/test/test_Identifier.cpp +2 -1
  61. data/test/test_Memory_Management.cpp +2 -1
  62. data/test/test_Module.cpp +2 -1
  63. data/test/test_Object.cpp +13 -1
  64. data/test/test_String.cpp +2 -1
  65. data/test/test_Struct.cpp +2 -1
  66. data/test/test_Symbol.cpp +2 -1
  67. data/test/test_To_From_Ruby.cpp +2 -1
  68. data/test/test_global_functions.cpp +2 -1
  69. data/test/test_rice.rb +4 -0
  70. data/test/unittest.cpp +34 -8
  71. metadata +26 -11
  72. data/check_stdcxx_11.ac +0 -103
  73. data/rice/detail/object_call.hpp +0 -69
  74. data/rice/detail/object_call.ipp +0 -131
  75. data/rice/detail/traits.hpp +0 -43
  76. data/rice/detail/wrap_function.ipp +0 -514
data/rice/Director.hpp CHANGED
@@ -10,10 +10,10 @@ namespace Rice {
10
10
  * You use this class to help build proxy classes so that polymorphism
11
11
  * works from C++ into Ruby. See the main README for how this class works.
12
12
  */
13
- class Director
13
+ class Director
14
14
  {
15
15
  public:
16
- //! Construct new Director. Needs the Ruby object so that the
16
+ //! Construct new Director. Needs the Ruby object so that the
17
17
  // proxy class can call methods on that object.
18
18
  Director(Object self);
19
19
 
@@ -21,7 +21,7 @@ namespace Rice {
21
21
 
22
22
  //! Raise a ruby exception when a call comes through for a pure virtual method
23
23
  /*! If a Ruby script calls 'super' on a method that's otherwise a pure virtual
24
- * method, use this method to throw an exception in this case.
24
+ * method, use this method to throw an exception in this case.
25
25
  */
26
26
  void raisePureVirtual() const;
27
27
 
data/rice/Exception.cpp CHANGED
@@ -3,13 +3,8 @@
3
3
  #include "to_from_ruby.hpp"
4
4
  #include "detail/ruby.hpp"
5
5
 
6
- #ifdef HAVE_STDARG_PROTOTYPES
7
6
  #include <stdarg.h>
8
7
  #define va_init_list(a,b) va_start(a,b)
9
- #else
10
- #include <varargs.h>
11
- #define va_init_list(a,b) va_start(a)
12
- #endif
13
8
 
14
9
  Rice::Exception::
15
10
  Exception(VALUE e)
@@ -35,7 +30,7 @@ Exception(Object exc, char const * fmt, ...)
35
30
  {
36
31
  va_list args;
37
32
  char buf[BUFSIZ];
38
-
33
+
39
34
  va_init_list(args, fmt);
40
35
  vsnprintf(buf, BUFSIZ, fmt, args);
41
36
  buf[BUFSIZ - 1] = '\0';
@@ -54,6 +49,6 @@ char const * Rice::Exception::
54
49
  what() const throw()
55
50
  {
56
51
  message_ = message();
57
- return from_ruby<std::string>(message_).c_str();
52
+ return from_ruby<char const *>(message_);
58
53
  }
59
54
 
data/rice/Hash.hpp CHANGED
@@ -5,8 +5,8 @@
5
5
  #include "Array.hpp"
6
6
  #include "to_from_ruby_defn.hpp"
7
7
  #include "detail/ruby.hpp"
8
- #include "detail/traits.hpp"
9
8
  #include <iterator>
9
+ #include <type_traits>
10
10
 
11
11
  namespace Rice
12
12
  {
@@ -146,11 +146,14 @@ bool operator<(Hash::Entry const & lhs, Hash::Entry const & rhs);
146
146
  //! A helper class for implementing iterators for a Hash.
147
147
  template<typename Hash_Ref_T, typename Value_T>
148
148
  class Hash::Iterator
149
- : public std::iterator<
150
- std::input_iterator_tag,
151
- Value_T>
152
149
  {
153
150
  public:
151
+ using iterator_category = std::input_iterator_tag;
152
+ using value_type = Value_T;
153
+ using difference_type = long;
154
+ using pointer = Object*;
155
+ using reference = Value_T&;
156
+
154
157
  //! Construct a new Iterator.
155
158
  Iterator(Hash_Ref_T hash);
156
159
 
@@ -202,7 +205,7 @@ private:
202
205
  size_t current_index_;
203
206
  VALUE keys_;
204
207
 
205
- mutable typename detail::remove_const<Value_T>::Type tmp_;
208
+ mutable typename std::remove_const<Value_T>::type tmp_;
206
209
  };
207
210
 
208
211
  } // namespace Rice
data/rice/Makefile.am CHANGED
@@ -104,17 +104,13 @@ detail/from_ruby.hpp \
104
104
  detail/from_ruby.ipp \
105
105
  detail/method_data.hpp \
106
106
  detail/node.hpp \
107
- detail/object_call.hpp \
108
- detail/object_call.ipp \
109
107
  detail/protect.hpp \
110
108
  detail/ruby.hpp \
111
109
  detail/st.hpp \
112
- detail/traits.hpp \
113
110
  detail/to_ruby.hpp \
114
111
  detail/to_ruby.ipp \
115
112
  detail/win32.hpp \
116
113
  detail/wrap_function.hpp \
117
- detail/wrap_function.ipp \
118
114
  detail/ruby_version_code.hpp
119
115
 
120
116
  includedir = ${prefix}/include/rice
data/rice/Makefile.in CHANGED
@@ -1,7 +1,7 @@
1
- # Makefile.in generated by automake 1.16.1 from Makefile.am.
1
+ # Makefile.in generated by automake 1.16.3 from Makefile.am.
2
2
  # @configure_input@
3
3
 
4
- # Copyright (C) 1994-2018 Free Software Foundation, Inc.
4
+ # Copyright (C) 1994-2020 Free Software Foundation, Inc.
5
5
 
6
6
  # This Makefile.in is free software; the Free Software Foundation
7
7
  # gives unlimited permission to copy and/or distribute it,
@@ -91,7 +91,7 @@ build_triplet = @build@
91
91
  host_triplet = @host@
92
92
  subdir = rice
93
93
  ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
94
- am__aclocal_m4_deps = $(top_srcdir)/check_stdcxx_11.ac \
94
+ am__aclocal_m4_deps = $(top_srcdir)/ax_cxx_compile_stdcxx.m4 \
95
95
  $(top_srcdir)/ruby.ac $(top_srcdir)/doxygen.ac \
96
96
  $(top_srcdir)/configure.ac
97
97
  am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
@@ -194,8 +194,8 @@ am__can_run_installinfo = \
194
194
  *) (install-info --version) >/dev/null 2>&1;; \
195
195
  esac
196
196
  HEADERS = $(nobase_include_HEADERS)
197
- am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) \
198
- $(LISP)config.hpp.in
197
+ am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) \
198
+ config.hpp.in
199
199
  # Read a list of newline-separated strings from the standard input,
200
200
  # and print each of them once, without duplicates. Input order is
201
201
  # *not* preserved.
@@ -259,7 +259,7 @@ ECHO_C = @ECHO_C@
259
259
  ECHO_N = @ECHO_N@
260
260
  ECHO_T = @ECHO_T@
261
261
  EXEEXT = @EXEEXT@
262
- HAVE_CXX11 = @HAVE_CXX11@
262
+ HAVE_CXX14 = @HAVE_CXX14@
263
263
  INSTALL = @INSTALL@
264
264
  INSTALL_DATA = @INSTALL_DATA@
265
265
  INSTALL_PROGRAM = @INSTALL_PROGRAM@
@@ -455,17 +455,13 @@ detail/from_ruby.hpp \
455
455
  detail/from_ruby.ipp \
456
456
  detail/method_data.hpp \
457
457
  detail/node.hpp \
458
- detail/object_call.hpp \
459
- detail/object_call.ipp \
460
458
  detail/protect.hpp \
461
459
  detail/ruby.hpp \
462
460
  detail/st.hpp \
463
- detail/traits.hpp \
464
461
  detail/to_ruby.hpp \
465
462
  detail/to_ruby.ipp \
466
463
  detail/win32.hpp \
467
464
  detail/wrap_function.hpp \
468
- detail/wrap_function.ipp \
469
465
  detail/ruby_version_code.hpp
470
466
 
471
467
  AM_CPPFLAGS = @RUBY_CPPFLAGS@
data/rice/Object.cpp CHANGED
@@ -117,7 +117,7 @@ vcall(
117
117
  a[i] = it->value();
118
118
  }
119
119
 
120
- return protect(rb_funcall3, *this, id, (int)args.size(), &a[0]);
120
+ return protect(rb_funcall3, *this, id, (int)args.size(), a.data());
121
121
  }
122
122
 
123
123
  void Rice::Object::
data/rice/Object.ipp CHANGED
@@ -3,8 +3,22 @@
3
3
 
4
4
  #include "protect.hpp"
5
5
  #include "detail/ruby.hpp"
6
+ #include "to_from_ruby.hpp"
6
7
 
7
- #include "detail/object_call.ipp"
8
+ #include <vector>
9
+
10
+ template<typename ...ArgT>
11
+ inline Rice::Object Rice::Object::
12
+ call(Identifier id, ArgT... args) const
13
+ {
14
+ auto asList = this->convert_args<ArgT...>(args...);
15
+ return protect(rb_funcall2, value(), id, (int)asList.size(), asList.data());
16
+ }
17
+
18
+ template<typename ...ArgT>
19
+ std::vector<VALUE> Rice::Object::convert_args(ArgT&... args) const {
20
+ return std::vector<VALUE>{ to_ruby(args)... };
21
+ }
8
22
 
9
23
  template<typename T>
10
24
  void Rice::Object::
data/rice/Object_defn.hpp CHANGED
@@ -8,6 +8,7 @@
8
8
  #include "detail/ruby.hpp"
9
9
 
10
10
  #include <iosfwd>
11
+ #include <vector>
11
12
 
12
13
  namespace Rice
13
14
  {
@@ -151,7 +152,25 @@ public:
151
152
  Object attr_get(
152
153
  Identifier name) const;
153
154
 
154
- #include "detail/object_call.hpp"
155
+ //! Call the Ruby method specified by 'id' on object 'obj'.
156
+ /*! Pass in arguments (arg1, arg2, ...). The arguments will be converted to
157
+ * Ruby objects with to_ruby<>.
158
+ *
159
+ * E.g.:
160
+ * \code
161
+ * Rice::Object obj = x.call("foo", "one", 2);
162
+ * \endcode
163
+ *
164
+ * If a return type is specified, the return value will automatically be
165
+ * converted to that type as long as 'from_ruby' exists for that type.
166
+ *
167
+ * E.g.:
168
+ * \code
169
+ * float ret = x.call<float>("foo", z, 42);
170
+ * \endcode
171
+ */
172
+ template<typename ...ArgT>
173
+ Object call(Identifier id, ArgT... args) const;
155
174
 
156
175
  //! Vectorized call.
157
176
  /*! Calls the method identified by id with the list of arguments
@@ -169,6 +188,10 @@ protected:
169
188
  //! Set the encapsulated value.
170
189
  void set_value(VALUE v);
171
190
 
191
+ //! Unpack the provided arguments and convert them all to Ruby types.
192
+ template<typename ...ArgT>
193
+ std::vector<VALUE> convert_args(ArgT&... args) const;
194
+
172
195
  private:
173
196
  volatile VALUE value_;
174
197
  };
data/rice/String.cpp CHANGED
@@ -3,13 +3,8 @@
3
3
  #include "protect.hpp"
4
4
  #include "detail/ruby.hpp"
5
5
 
6
- #ifdef HAVE_STDARG_PROTOTYPES
7
6
  #include <stdarg.h>
8
7
  #define va_init_list(a,b) va_start(a,b)
9
- #else
10
- #include <varargs.h>
11
- #define va_init_list(a,b) va_start(a)
12
- #endif
13
8
 
14
9
  Rice::String::
15
10
  String()
@@ -37,7 +32,7 @@ String(char const * s)
37
32
 
38
33
  Rice::String::
39
34
  String(std::string const & s)
40
- : Builtin_Object<T_STRING>(protect(rb_str_new, s.data(), s.length()))
35
+ : Builtin_Object<T_STRING>(protect(rb_str_new, s.data(), (long)s.length()))
41
36
  {
42
37
  }
43
38
 
@@ -52,7 +47,7 @@ format(char const * fmt, ...)
52
47
  {
53
48
  va_list args;
54
49
  char buf[BUFSIZ];
55
-
50
+
56
51
  va_init_list(args, fmt);
57
52
  vsnprintf(buf, BUFSIZ, fmt, args);
58
53
  buf[BUFSIZ - 1] = '\0';
data/rice/Struct.cpp CHANGED
@@ -59,11 +59,11 @@ define_member(
59
59
  return *this;
60
60
  }
61
61
 
62
- size_t Rice::Struct::
62
+ unsigned long Rice::Struct::
63
63
  offset_of(Identifier name) const
64
64
  {
65
65
  Symbol ruby_name(name);
66
- return from_ruby<size_t>(member_offset_[ruby_name]);
66
+ return from_ruby<unsigned long>(member_offset_[ruby_name]);
67
67
  }
68
68
 
69
69
  void Rice::Struct::
data/rice/Struct.hpp CHANGED
@@ -91,7 +91,7 @@ public:
91
91
  * \param member the name of the desired member.
92
92
  * \return the index of the given member.
93
93
  */
94
- size_t offset_of(Identifier name) const;
94
+ unsigned long offset_of(Identifier name) const;
95
95
 
96
96
  class Instance;
97
97
  friend class Instance;
data/rice/Struct.ipp CHANGED
@@ -12,7 +12,7 @@ template<>
12
12
  inline Object Struct::Instance::
13
13
  operator[]<Identifier>(Identifier member)
14
14
  {
15
- size_t index = type_.offset_of(member);
15
+ unsigned long index = type_.offset_of(member);
16
16
  return (*this)[index];
17
17
  }
18
18
 
data/rice/config.hpp CHANGED
@@ -1,8 +1,8 @@
1
1
  /* rice/config.hpp. Generated from config.hpp.in by configure. */
2
2
  /* rice/config.hpp.in. Generated from configure.ac by autoheader. */
3
3
 
4
- /* define if the compiler supports basic C++11 syntax */
5
- /* #undef HAVE_CXX11 */
4
+ /* define if the compiler supports basic C++14 syntax */
5
+ #define HAVE_CXX14 1
6
6
 
7
7
  /* Define to 1 if you have the <env.h> header file. */
8
8
  /* #undef HAVE_ENV_H */
data/rice/config.hpp.in CHANGED
@@ -1,7 +1,7 @@
1
1
  /* rice/config.hpp.in. Generated from configure.ac by autoheader. */
2
2
 
3
- /* define if the compiler supports basic C++11 syntax */
4
- #undef HAVE_CXX11
3
+ /* define if the compiler supports basic C++14 syntax */
4
+ #undef HAVE_CXX14
5
5
 
6
6
  /* Define to 1 if you have the <env.h> header file. */
7
7
  #undef HAVE_ENV_H
data/rice/detail/Arguments.hpp CHANGED
@@ -38,7 +38,7 @@ namespace Rice {
38
38
  * In the case of no Args (default case), this
39
39
  * method uses the passed in full argument count
40
40
  */
41
- std::string formatString(int fullArgCount)
41
+ std::string formatString(size_t fullArgCount)
42
42
  {
43
43
  std::stringstream s;
44
44
  if(required_ == 0 && optional_ == 0)
data/rice/detail/Auto_Function_Wrapper.ipp CHANGED
@@ -10,7 +10,6 @@
10
10
  #include "method_data.hpp"
11
11
  #include "../ruby_try_catch.hpp"
12
12
  #include "../to_from_ruby.hpp"
13
- #include "traits.hpp"
14
13
  namespace Rice
15
14
  {
16
15
 
@@ -68,74 +67,43 @@ call(int argc, VALUE *argv, VALUE self)
68
67
 
69
68
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
70
69
 
71
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
72
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
73
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
74
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
75
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
76
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
77
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
78
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
79
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
80
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
81
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
82
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
83
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
84
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
85
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
86
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
87
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
88
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
89
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
90
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
91
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
92
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
93
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
94
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
95
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
96
- Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(12, varg12);
97
- typedef typename sanitize< Arg14_T >::Type Arg14_Type;
98
- Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(13, varg13);
99
- typedef typename sanitize< Arg15_T >::Type Arg15_Type;
100
- Arg15_Type arg15 = args->getArgumentOrDefault<Arg15_Type>(14, varg14);
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);
101
85
 
102
86
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15));
103
87
  } else {
104
88
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
105
89
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14, &varg15);
106
90
 
107
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
108
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
109
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
110
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
111
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
112
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
113
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
114
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
115
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
116
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
117
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
118
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
119
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
120
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
121
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
122
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
123
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
124
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
125
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
126
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
127
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
128
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
129
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
130
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
131
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
132
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
133
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
134
- Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
135
- typedef typename sanitize< Arg14_T >::Type Arg14_Type;
136
- Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(14, varg14);
137
- typedef typename sanitize< Arg15_T >::Type Arg15_Type;
138
- Arg15_Type arg15 = args->getArgumentOrDefault<Arg15_Type>(15, varg15);
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);
139
107
 
140
108
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15));
141
109
  }
@@ -208,36 +176,21 @@ call(int argc, VALUE* argv, VALUE self)
208
176
 
209
177
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
210
178
 
211
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
212
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
213
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
214
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
215
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
216
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
217
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
218
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
219
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
220
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
221
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
222
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
223
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
224
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
225
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
226
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
227
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
228
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
229
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
230
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
231
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
232
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
233
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
234
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
235
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
236
- Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(12, varg12);
237
- typedef typename sanitize< Arg14_T >::Type Arg14_Type;
238
- Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(13, varg13);
239
- typedef typename sanitize< Arg15_T >::Type Arg15_Type;
240
- Arg15_Type arg15 = args->getArgumentOrDefault<Arg15_Type>(14, varg14);
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);
241
194
 
242
195
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15);
243
196
  return Qnil;
@@ -245,38 +198,22 @@ call(int argc, VALUE* argv, VALUE self)
245
198
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
246
199
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14, &varg15);
247
200
 
248
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
249
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
250
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
251
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
252
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
253
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
254
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
255
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
256
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
257
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
258
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
259
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
260
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
261
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
262
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
263
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
264
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
265
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
266
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
267
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
268
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
269
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
270
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
271
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
272
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
273
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
274
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
275
- Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
276
- typedef typename sanitize< Arg14_T >::Type Arg14_Type;
277
- Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(14, varg14);
278
- typedef typename sanitize< Arg15_T >::Type Arg15_Type;
279
- Arg15_Type arg15 = args->getArgumentOrDefault<Arg15_Type>(15, varg15);
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);
280
217
 
281
218
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15);
282
219
  return Qnil;
@@ -351,70 +288,41 @@ call(int argc, VALUE *argv, VALUE self)
351
288
 
352
289
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
353
290
 
354
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
355
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
356
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
357
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
358
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
359
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
360
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
361
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
362
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
363
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
364
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
365
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
366
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
367
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
368
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
369
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
370
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
371
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
372
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
373
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
374
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
375
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
376
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
377
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
378
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
379
- Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(12, varg12);
380
- typedef typename sanitize< Arg14_T >::Type Arg14_Type;
381
- Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(13, varg13);
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);
382
305
 
383
306
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14));
384
307
  } else {
385
308
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
386
309
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14);
387
310
 
388
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
389
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
390
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
391
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
392
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
393
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
394
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
395
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
396
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
397
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
398
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
399
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
400
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
401
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
402
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
403
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
404
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
405
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
406
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
407
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
408
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
409
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
410
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
411
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
412
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
413
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
414
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
415
- Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
416
- typedef typename sanitize< Arg14_T >::Type Arg14_Type;
417
- Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(14, varg14);
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);
418
326
 
419
327
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14));
420
328
  }
@@ -487,34 +395,20 @@ call(int argc, VALUE* argv, VALUE self)
487
395
 
488
396
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
489
397
 
490
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
491
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
492
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
493
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
494
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
495
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
496
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
497
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
498
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
499
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
500
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
501
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
502
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
503
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
504
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
505
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
506
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
507
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
508
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
509
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
510
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
511
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
512
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
513
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
514
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
515
- Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(12, varg12);
516
- typedef typename sanitize< Arg14_T >::Type Arg14_Type;
517
- Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(13, varg13);
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);
518
412
 
519
413
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
520
414
  return Qnil;
@@ -522,36 +416,21 @@ call(int argc, VALUE* argv, VALUE self)
522
416
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
523
417
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14);
524
418
 
525
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
526
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
527
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
528
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
529
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
530
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
531
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
532
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
533
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
534
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
535
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
536
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
537
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
538
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
539
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
540
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
541
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
542
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
543
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
544
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
545
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
546
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
547
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
548
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
549
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
550
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
551
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
552
- Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
553
- typedef typename sanitize< Arg14_T >::Type Arg14_Type;
554
- Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(14, varg14);
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);
555
434
 
556
435
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
557
436
  return Qnil;
@@ -626,66 +505,39 @@ call(int argc, VALUE *argv, VALUE self)
626
505
 
627
506
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
628
507
 
629
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
630
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
631
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
632
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
633
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
634
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
635
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
636
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
637
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
638
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
639
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
640
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
641
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
642
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
643
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
644
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
645
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
646
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
647
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
648
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
649
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
650
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
651
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
652
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
653
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
654
- Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(12, varg12);
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);
655
521
 
656
522
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13));
657
523
  } else {
658
524
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
659
525
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13);
660
526
 
661
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
662
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
663
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
664
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
665
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
666
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
667
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
668
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
669
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
670
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
671
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
672
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
673
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
674
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
675
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
676
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
677
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
678
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
679
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
680
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
681
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
682
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
683
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
684
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
685
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
686
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
687
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
688
- Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
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);
689
541
 
690
542
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13));
691
543
  }
@@ -758,32 +610,19 @@ call(int argc, VALUE* argv, VALUE self)
758
610
 
759
611
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
760
612
 
761
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
762
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
763
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
764
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
765
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
766
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
767
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
768
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
769
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
770
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
771
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
772
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
773
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
774
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
775
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
776
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
777
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
778
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
779
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
780
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
781
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
782
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
783
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
784
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
785
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
786
- Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(12, varg12);
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);
787
626
 
788
627
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
789
628
  return Qnil;
@@ -791,34 +630,20 @@ call(int argc, VALUE* argv, VALUE self)
791
630
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
792
631
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13);
793
632
 
794
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
795
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
796
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
797
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
798
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
799
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
800
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
801
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
802
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
803
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
804
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
805
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
806
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
807
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
808
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
809
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
810
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
811
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
812
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
813
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
814
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
815
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
816
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
817
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
818
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
819
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
820
- typedef typename sanitize< Arg13_T >::Type Arg13_Type;
821
- Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
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);
822
647
 
823
648
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
824
649
  return Qnil;
@@ -893,62 +718,37 @@ call(int argc, VALUE *argv, VALUE self)
893
718
 
894
719
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
895
720
 
896
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
897
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
898
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
899
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
900
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
901
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
902
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
903
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
904
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
905
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
906
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
907
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
908
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
909
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
910
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
911
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
912
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
913
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
914
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
915
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
916
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
917
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
918
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
919
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
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);
920
733
 
921
734
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12));
922
735
  } else {
923
736
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
924
737
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12);
925
738
 
926
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
927
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
928
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
929
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
930
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
931
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
932
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
933
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
934
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
935
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
936
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
937
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
938
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
939
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
940
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
941
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
942
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
943
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
944
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
945
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
946
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
947
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
948
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
949
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
950
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
951
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
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);
952
752
 
953
753
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12));
954
754
  }
@@ -1021,30 +821,18 @@ call(int argc, VALUE* argv, VALUE self)
1021
821
 
1022
822
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
1023
823
 
1024
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1025
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1026
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1027
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1028
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1029
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1030
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1031
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1032
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1033
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1034
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1035
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1036
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1037
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1038
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1039
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1040
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1041
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
1042
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1043
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
1044
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
1045
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
1046
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
1047
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(11, varg11);
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);
1048
836
 
1049
837
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
1050
838
  return Qnil;
@@ -1052,32 +840,19 @@ call(int argc, VALUE* argv, VALUE self)
1052
840
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
1053
841
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12);
1054
842
 
1055
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1056
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1057
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1058
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1059
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1060
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1061
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1062
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1063
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1064
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1065
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1066
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1067
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1068
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1069
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1070
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1071
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1072
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1073
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1074
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1075
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1076
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
1077
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
1078
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
1079
- typedef typename sanitize< Arg12_T >::Type Arg12_Type;
1080
- Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
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);
1081
856
 
1082
857
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
1083
858
  return Qnil;
@@ -1152,58 +927,35 @@ call(int argc, VALUE *argv, VALUE self)
1152
927
 
1153
928
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
1154
929
 
1155
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1156
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1157
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1158
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1159
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1160
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1161
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1162
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1163
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1164
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1165
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1166
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1167
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1168
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1169
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1170
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1171
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1172
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
1173
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1174
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
1175
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
1176
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
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);
1177
941
 
1178
942
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11));
1179
943
  } else {
1180
944
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
1181
945
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11);
1182
946
 
1183
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1184
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1185
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1186
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1187
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1188
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1189
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1190
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1191
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1192
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1193
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1194
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1195
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1196
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1197
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1198
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1199
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1200
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1201
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1202
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1203
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1204
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
1205
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
1206
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
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);
1207
959
 
1208
960
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11));
1209
961
  }
@@ -1276,28 +1028,17 @@ call(int argc, VALUE* argv, VALUE self)
1276
1028
 
1277
1029
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
1278
1030
 
1279
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1280
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1281
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1282
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1283
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1284
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1285
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1286
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1287
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1288
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1289
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1290
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1291
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1292
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1293
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1294
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1295
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1296
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
1297
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1298
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
1299
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
1300
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(10, varg10);
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);
1301
1042
 
1302
1043
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
1303
1044
  return Qnil;
@@ -1305,30 +1046,18 @@ call(int argc, VALUE* argv, VALUE self)
1305
1046
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
1306
1047
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11);
1307
1048
 
1308
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1309
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1310
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1311
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1312
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1313
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1314
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1315
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1316
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1317
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1318
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1319
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1320
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1321
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1322
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1323
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1324
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1325
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1326
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1327
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1328
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1329
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
1330
- typedef typename sanitize< Arg11_T >::Type Arg11_Type;
1331
- Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
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);
1332
1061
 
1333
1062
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
1334
1063
  return Qnil;
@@ -1403,54 +1132,33 @@ call(int argc, VALUE *argv, VALUE self)
1403
1132
 
1404
1133
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
1405
1134
 
1406
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1407
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1408
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1409
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1410
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1411
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1412
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1413
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1414
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1415
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1416
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1417
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1418
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1419
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1420
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1421
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1422
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1423
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
1424
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1425
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
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);
1426
1145
 
1427
1146
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10));
1428
1147
  } else {
1429
1148
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
1430
1149
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10);
1431
1150
 
1432
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1433
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1434
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1435
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1436
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1437
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1438
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1439
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1440
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1441
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1442
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1443
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1444
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1445
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1446
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1447
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1448
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1449
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1450
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1451
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1452
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1453
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
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);
1454
1162
 
1455
1163
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10));
1456
1164
  }
@@ -1523,26 +1231,16 @@ call(int argc, VALUE* argv, VALUE self)
1523
1231
 
1524
1232
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
1525
1233
 
1526
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1527
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1528
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1529
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1530
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1531
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1532
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1533
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1534
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1535
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1536
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1537
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1538
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1539
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1540
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1541
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1542
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1543
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
1544
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1545
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(9, varg9);
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);
1546
1244
 
1547
1245
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
1548
1246
  return Qnil;
@@ -1550,28 +1248,17 @@ call(int argc, VALUE* argv, VALUE self)
1550
1248
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
1551
1249
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10);
1552
1250
 
1553
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1554
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1555
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1556
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1557
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1558
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1559
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1560
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1561
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1562
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1563
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1564
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1565
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1566
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1567
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1568
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1569
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1570
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1571
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1572
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1573
- typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1574
- Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
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);
1575
1262
 
1576
1263
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
1577
1264
  return Qnil;
@@ -1646,50 +1333,31 @@ call(int argc, VALUE *argv, VALUE self)
1646
1333
 
1647
1334
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
1648
1335
 
1649
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1650
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1651
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1652
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1653
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1654
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1655
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1656
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1657
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1658
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1659
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1660
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1661
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1662
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1663
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1664
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1665
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1666
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
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);
1667
1345
 
1668
1346
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9));
1669
1347
  } else {
1670
1348
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
1671
1349
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9);
1672
1350
 
1673
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1674
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1675
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1676
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1677
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1678
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1679
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1680
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1681
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1682
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1683
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1684
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1685
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1686
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1687
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1688
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1689
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1690
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1691
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1692
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
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);
1693
1361
 
1694
1362
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9));
1695
1363
  }
@@ -1762,24 +1430,15 @@ call(int argc, VALUE* argv, VALUE self)
1762
1430
 
1763
1431
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
1764
1432
 
1765
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1766
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1767
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1768
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1769
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1770
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1771
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1772
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1773
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1774
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1775
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1776
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1777
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1778
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1779
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1780
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
1781
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1782
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(8, varg8);
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);
1783
1442
 
1784
1443
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
1785
1444
  return Qnil;
@@ -1787,26 +1446,16 @@ call(int argc, VALUE* argv, VALUE self)
1787
1446
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
1788
1447
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9);
1789
1448
 
1790
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1791
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1792
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1793
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1794
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1795
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1796
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1797
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1798
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1799
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1800
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1801
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1802
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1803
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1804
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1805
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1806
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1807
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1808
- typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1809
- Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
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);
1810
1459
 
1811
1460
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
1812
1461
  return Qnil;
@@ -1881,46 +1530,29 @@ call(int argc, VALUE *argv, VALUE self)
1881
1530
 
1882
1531
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
1883
1532
 
1884
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1885
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1886
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1887
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
1888
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1889
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
1890
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1891
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
1892
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1893
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
1894
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1895
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
1896
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1897
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
1898
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1899
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
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);
1900
1541
 
1901
1542
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8));
1902
1543
  } else {
1903
1544
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
1904
1545
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8);
1905
1546
 
1906
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1907
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1908
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1909
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1910
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1911
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1912
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1913
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1914
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1915
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1916
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1917
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1918
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1919
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1920
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1921
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1922
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1923
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
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);
1924
1556
 
1925
1557
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8));
1926
1558
  }
@@ -1993,22 +1625,14 @@ call(int argc, VALUE* argv, VALUE self)
1993
1625
 
1994
1626
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
1995
1627
 
1996
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1997
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
1998
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1999
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2000
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2001
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2002
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2003
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2004
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2005
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
2006
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2007
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
2008
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
2009
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
2010
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
2011
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(7, varg7);
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);
2012
1636
 
2013
1637
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
2014
1638
  return Qnil;
@@ -2016,24 +1640,15 @@ call(int argc, VALUE* argv, VALUE self)
2016
1640
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
2017
1641
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8);
2018
1642
 
2019
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2020
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2021
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2022
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2023
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2024
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2025
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2026
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2027
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2028
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2029
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2030
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
2031
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2032
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
2033
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
2034
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
2035
- typedef typename sanitize< Arg8_T >::Type Arg8_Type;
2036
- Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
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);
2037
1652
 
2038
1653
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
2039
1654
  return Qnil;
@@ -2108,42 +1723,27 @@ call(int argc, VALUE *argv, VALUE self)
2108
1723
 
2109
1724
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
2110
1725
 
2111
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2112
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2113
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2114
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2115
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2116
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2117
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2118
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2119
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2120
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
2121
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2122
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
2123
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
2124
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
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);
2125
1733
 
2126
1734
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7));
2127
1735
  } else {
2128
1736
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
2129
1737
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7);
2130
1738
 
2131
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2132
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2133
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2134
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2135
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2136
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2137
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2138
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2139
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2140
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2141
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2142
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
2143
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2144
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
2145
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
2146
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
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);
2147
1747
 
2148
1748
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7));
2149
1749
  }
@@ -2216,20 +1816,13 @@ call(int argc, VALUE* argv, VALUE self)
2216
1816
 
2217
1817
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
2218
1818
 
2219
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2220
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2221
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2222
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2223
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2224
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2225
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2226
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2227
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2228
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
2229
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2230
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
2231
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
2232
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(6, varg6);
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);
2233
1826
 
2234
1827
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
2235
1828
  return Qnil;
@@ -2237,22 +1830,14 @@ call(int argc, VALUE* argv, VALUE self)
2237
1830
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
2238
1831
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7);
2239
1832
 
2240
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2241
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2242
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2243
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2244
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2245
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2246
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2247
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2248
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2249
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2250
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2251
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
2252
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2253
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
2254
- typedef typename sanitize< Arg7_T >::Type Arg7_Type;
2255
- Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
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);
2256
1841
 
2257
1842
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
2258
1843
  return Qnil;
@@ -2327,38 +1912,25 @@ call(int argc, VALUE *argv, VALUE self)
2327
1912
 
2328
1913
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
2329
1914
 
2330
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2331
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2332
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2333
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2334
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2335
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2336
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2337
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2338
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2339
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
2340
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2341
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
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);
2342
1921
 
2343
1922
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6));
2344
1923
  } else {
2345
1924
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
2346
1925
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6);
2347
1926
 
2348
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2349
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2350
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2351
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2352
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2353
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2354
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2355
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2356
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2357
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2358
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2359
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
2360
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2361
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
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);
2362
1934
 
2363
1935
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6));
2364
1936
  }
@@ -2431,18 +2003,12 @@ call(int argc, VALUE* argv, VALUE self)
2431
2003
 
2432
2004
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
2433
2005
 
2434
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2435
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2436
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2437
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2438
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2439
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2440
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2441
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2442
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2443
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
2444
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2445
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(5, varg5);
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);
2446
2012
 
2447
2013
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
2448
2014
  return Qnil;
@@ -2450,20 +2016,13 @@ call(int argc, VALUE* argv, VALUE self)
2450
2016
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
2451
2017
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6);
2452
2018
 
2453
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2454
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2455
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2456
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2457
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2458
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2459
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2460
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2461
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2462
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2463
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2464
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
2465
- typedef typename sanitize< Arg6_T >::Type Arg6_Type;
2466
- Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
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);
2467
2026
 
2468
2027
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
2469
2028
  return Qnil;
@@ -2538,34 +2097,23 @@ call(int argc, VALUE *argv, VALUE self)
2538
2097
 
2539
2098
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
2540
2099
 
2541
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2542
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2543
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2544
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2545
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2546
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2547
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2548
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2549
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2550
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
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);
2551
2105
 
2552
2106
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5));
2553
2107
  } else {
2554
2108
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
2555
2109
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5);
2556
2110
 
2557
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2558
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2559
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2560
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2561
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2562
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2563
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2564
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2565
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2566
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2567
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2568
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
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);
2569
2117
 
2570
2118
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5));
2571
2119
  }
@@ -2638,16 +2186,11 @@ call(int argc, VALUE* argv, VALUE self)
2638
2186
 
2639
2187
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
2640
2188
 
2641
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2642
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2643
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2644
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2645
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2646
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2647
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2648
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
2649
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2650
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(4, varg4);
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);
2651
2194
 
2652
2195
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5);
2653
2196
  return Qnil;
@@ -2655,18 +2198,12 @@ call(int argc, VALUE* argv, VALUE self)
2655
2198
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
2656
2199
  , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5);
2657
2200
 
2658
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2659
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2660
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2661
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2662
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2663
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2664
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2665
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2666
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2667
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
2668
- typedef typename sanitize< Arg5_T >::Type Arg5_Type;
2669
- Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
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);
2670
2207
 
2671
2208
  wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5);
2672
2209
  return Qnil;
@@ -2741,30 +2278,21 @@ call(int argc, VALUE *argv, VALUE self)
2741
2278
 
2742
2279
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
2743
2280
 
2744
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2745
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2746
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2747
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2748
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2749
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2750
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2751
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
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);
2752
2285
 
2753
2286
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4));
2754
2287
  } else {
2755
2288
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
2756
2289
  , &varg0, &varg1, &varg2, &varg3, &varg4);
2757
2290
 
2758
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2759
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2760
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2761
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2762
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2763
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2764
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2765
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2766
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2767
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
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);
2768
2296
 
2769
2297
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4));
2770
2298
  }
@@ -2837,14 +2365,10 @@ call(int argc, VALUE* argv, VALUE self)
2837
2365
 
2838
2366
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
2839
2367
 
2840
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2841
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2842
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2843
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2844
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2845
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
2846
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2847
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(3, varg3);
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);
2848
2372
 
2849
2373
  wrapper->func_(arg0, arg1, arg2, arg3, arg4);
2850
2374
  return Qnil;
@@ -2852,16 +2376,11 @@ call(int argc, VALUE* argv, VALUE self)
2852
2376
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
2853
2377
  , &varg0, &varg1, &varg2, &varg3, &varg4);
2854
2378
 
2855
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2856
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2857
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2858
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2859
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2860
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2861
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2862
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2863
- typedef typename sanitize< Arg4_T >::Type Arg4_Type;
2864
- Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
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);
2865
2384
 
2866
2385
  wrapper->func_(arg0, arg1, arg2, arg3, arg4);
2867
2386
  return Qnil;
@@ -2936,26 +2455,19 @@ call(int argc, VALUE *argv, VALUE self)
2936
2455
 
2937
2456
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
2938
2457
 
2939
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2940
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2941
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2942
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2943
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2944
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
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);
2945
2461
 
2946
2462
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3));
2947
2463
  } else {
2948
2464
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
2949
2465
  , &varg0, &varg1, &varg2, &varg3);
2950
2466
 
2951
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2952
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2953
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2954
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2955
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2956
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2957
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2958
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
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);
2959
2471
 
2960
2472
  return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3));
2961
2473
  }
@@ -3028,12 +2540,9 @@ call(int argc, VALUE* argv, VALUE self)
3028
2540
 
3029
2541
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
3030
2542
 
3031
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3032
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
3033
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
3034
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
3035
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
3036
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(2, varg2);
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);
3037
2546
 
3038
2547
  wrapper->func_(arg0, arg1, arg2, arg3);
3039
2548
  return Qnil;
@@ -3041,14 +2550,10 @@ call(int argc, VALUE* argv, VALUE self)
3041
2550
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
3042
2551
  , &varg0, &varg1, &varg2, &varg3);
3043
2552
 
3044
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
3045
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
3046
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3047
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
3048
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
3049
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
3050
- typedef typename sanitize< Arg3_T >::Type Arg3_Type;
3051
- Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
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);
3052
2557
 
3053
2558
  wrapper->func_(arg0, arg1, arg2, arg3);
3054
2559
  return Qnil;
@@ -3123,22 +2628,17 @@ call(int argc, VALUE *argv, VALUE self)
3123
2628
 
3124
2629
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
3125
2630
 
3126
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3127
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
3128
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
3129
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2631
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
2632
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
3130
2633
 
3131
2634
  return to_ruby(wrapper->func_(arg0, arg1, arg2));
3132
2635
  } else {
3133
2636
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
3134
2637
  , &varg0, &varg1, &varg2);
3135
2638
 
3136
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
3137
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
3138
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3139
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
3140
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
3141
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
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);
3142
2642
 
3143
2643
  return to_ruby(wrapper->func_(arg0, arg1, arg2));
3144
2644
  }
@@ -3211,10 +2711,8 @@ call(int argc, VALUE* argv, VALUE self)
3211
2711
 
3212
2712
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
3213
2713
 
3214
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3215
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
3216
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
3217
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(1, varg1);
2714
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
2715
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
3218
2716
 
3219
2717
  wrapper->func_(arg0, arg1, arg2);
3220
2718
  return Qnil;
@@ -3222,12 +2720,9 @@ call(int argc, VALUE* argv, VALUE self)
3222
2720
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
3223
2721
  , &varg0, &varg1, &varg2);
3224
2722
 
3225
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
3226
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
3227
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3228
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
3229
- typedef typename sanitize< Arg2_T >::Type Arg2_Type;
3230
- Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
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);
3231
2726
 
3232
2727
  wrapper->func_(arg0, arg1, arg2);
3233
2728
  return Qnil;
@@ -3302,18 +2797,15 @@ call(int argc, VALUE *argv, VALUE self)
3302
2797
 
3303
2798
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
3304
2799
 
3305
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3306
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2800
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
3307
2801
 
3308
2802
  return to_ruby(wrapper->func_(arg0, arg1));
3309
2803
  } else {
3310
2804
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
3311
2805
  , &varg0, &varg1);
3312
2806
 
3313
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
3314
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
3315
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3316
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2807
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
2808
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
3317
2809
 
3318
2810
  return to_ruby(wrapper->func_(arg0, arg1));
3319
2811
  }
@@ -3386,8 +2878,7 @@ call(int argc, VALUE* argv, VALUE self)
3386
2878
 
3387
2879
  Arg0_T arg0 = from_ruby<Arg0_T>(self);
3388
2880
 
3389
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3390
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(0, varg0);
2881
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
3391
2882
 
3392
2883
  wrapper->func_(arg0, arg1);
3393
2884
  return Qnil;
@@ -3395,10 +2886,8 @@ call(int argc, VALUE* argv, VALUE self)
3395
2886
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
3396
2887
  , &varg0, &varg1);
3397
2888
 
3398
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
3399
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
3400
- typedef typename sanitize< Arg1_T >::Type Arg1_Type;
3401
- Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2889
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
2890
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
3402
2891
 
3403
2892
  wrapper->func_(arg0, arg1);
3404
2893
  return Qnil;
@@ -3479,8 +2968,7 @@ call(int argc, VALUE *argv, VALUE self)
3479
2968
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
3480
2969
  , &varg0);
3481
2970
 
3482
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
3483
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2971
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
3484
2972
 
3485
2973
  return to_ruby(wrapper->func_(arg0));
3486
2974
  }
@@ -3560,8 +3048,7 @@ call(int argc, VALUE* argv, VALUE self)
3560
3048
  rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
3561
3049
  , &varg0);
3562
3050
 
3563
- typedef typename sanitize< Arg0_T >::Type Arg0_Type;
3564
- Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
3051
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
3565
3052
 
3566
3053
  wrapper->func_(arg0);
3567
3054
  return Qnil;