rice2 2.2.0

data/rice/config.hpp.in

@@ -0,0 +1,46 @@
+/* rice/config.hpp.in.  Generated from configure.ac by autoheader.  */
+
+/* define if the compiler supports basic C++14 syntax */
+#undef HAVE_CXX14
+
+/* Define to 1 if you have the <env.h> header file. */
+#undef HAVE_ENV_H
+
+/* Define to 1 if you have the <node.h> header file. */
+#undef HAVE_NODE_H
+
+/* Define to 1 if you have the <ruby.h> header file. */
+#undef HAVE_RUBY_H
+
+/* Define to 1 if you have the <ruby/node.h> header file. */
+#undef HAVE_RUBY_NODE_H
+
+/* Define to 1 if you have the <version.h> header file. */
+#undef HAVE_VERSION_H
+
+/* Name of package */
+#undef PACKAGE
+
+/* Define to the address where bug reports for this package should be sent. */
+#undef PACKAGE_BUGREPORT
+
+/* Define to the full name of this package. */
+#undef PACKAGE_NAME
+
+/* Define to the full name and version of this package. */
+#undef PACKAGE_STRING
+
+/* Define to the one symbol short name of this package. */
+#undef PACKAGE_TARNAME
+
+/* Define to the home page for this package. */
+#undef PACKAGE_URL
+
+/* Define to the version of this package. */
+#undef PACKAGE_VERSION
+
+/* Define this macro to use ruby/node.h */
+#undef REALLY_HAVE_RUBY_NODE_H
+
+/* Version number of package */
+#undef VERSION

data/rice/detail/Arguments.hpp

@@ -0,0 +1,118 @@
+#ifndef Rice__Arguments__hpp_
+#define Rice__Arguments__hpp_
+
+#include "../Arg_impl.hpp"
+#include <sstream>
+#include <vector>
+#include "../to_from_ruby_defn.hpp"
+
+namespace Rice {
+
+  class Arguments
+  {
+    public:
+      Arguments() {
+        required_ = 0;
+        optional_ = 0;
+      }
+
+      ~Arguments() {
+      }
+
+      /**
+       * Get the full argument count of this
+       * list of arguments.
+       * Returns -1 no defined arguments
+       */
+      int count() {
+        if(required_ == 0 && optional_ == 0) {
+          return -1;
+        } else {
+          return required_ + optional_;
+        }
+      }
+
+      /**
+       * Get the rb_scan_args format string for this
+       * list of arguments.
+       * In the case of no Args (default case), this
+       * method uses the passed in full argument count
+       */
+      std::string formatString(int fullArgCount)
+      {
+        std::stringstream s;
+        if(required_ == 0 && optional_ == 0)
+        {
+          s << fullArgCount << 0;
+        }
+        else
+        {
+          s << required_ << optional_;
+        }
+
+        return s.str();
+      }
+
+      /**
+       * Add a defined Arg to this list of Arguments
+       */
+      void add(const Arg& arg)
+      {
+        args_.push_back(arg);
+
+        if(arg.hasDefaultValue())
+        {
+          optional_++;
+        }
+        else
+        {
+          required_++;
+        }
+      }
+
+      /**
+       * Is the argument at the request location an optional
+       * argument?
+       */
+      bool isOptional(unsigned int pos)
+      {
+        if(required_ == 0 && optional_ == 0)
+        {
+          return false;
+        }
+        if(pos >= args_.size())
+        {
+          return false;
+        }
+        return args_[pos].hasDefaultValue();
+      }
+
+      /**
+       * Given a position, a type, and a ruby VALUE, figure out
+       * what argument value we need to return according to
+       * defaults and if that VALUE is nil or not
+       */
+      template<typename Arg_T>
+      Arg_T getArgumentOrDefault(int pos, VALUE in)
+      {
+        if(isOptional(pos) && NIL_P(in))
+        {
+          return args_[pos].getDefaultValue<Arg_T>();
+        }
+        else
+        {
+          return from_ruby<Arg_T>(in);
+        }
+      }
+
+    private:
+      std::vector<Arg> args_;
+
+      /** Keep counts of required and optional parameters */
+      int required_;
+      int optional_;
+  };
+
+}
+
+#endif // Rice__Arguments__hpp_

data/rice/detail/Auto_Function_Wrapper.hpp

@@ -0,0 +1,898 @@
+#ifndef Rice__detail__Auto_Function_Wrapper__hpp_
+#define Rice__detail__Auto_Function_Wrapper__hpp_
+
+// This is a generated file.  DO NOT EDIT!!
+
+
+// This causes problems with certain C++ libraries
+#undef TYPE
+
+#include "Exception_Handler_defn.hpp"
+
+namespace Rice
+{
+
+namespace detail
+{
+
+#ifdef DOXYGEN
+
+#else
+
+template<typename Func_T, typename Ret_T, typename Arg0_T = void, typename Arg1_T = void, typename Arg2_T = void, typename Arg3_T = void, typename Arg4_T = void, typename Arg5_T = void, typename Arg6_T = void, typename Arg7_T = void, typename Arg8_T = void, typename Arg9_T = void, typename Arg10_T = void, typename Arg11_T = void, typename Arg12_T = void, typename Arg13_T = void, typename Arg14_T = void, typename Arg15_T = void>
+class Auto_Function_Wrapper
+  : public Wrapped_Function
+{
+public:
+  typedef Func_T Func;
+
+  static const int Num_Args = 16;
+
+  Auto_Function_Wrapper(
+      Func func,
+      Data_Object<Exception_Handler> handler,
+      Arguments* arguments = 0);
+
+  ~Auto_Function_Wrapper();
+
+  static VALUE call(int argc, VALUE* args, VALUE self);
+
+private:
+  Func func_;
+  Data_Object<Exception_Handler> handler_;
+  Address_Registration_Guard handler_guard_;
+  Arguments* arguments_;
+};
+
+template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T, typename Arg13_T, typename Arg14_T, typename Arg15_T>
+class Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T, Arg14_T, Arg15_T>
+  : public Wrapped_Function
+{
+public:
+  typedef Func_T Func;
+
+  static const int Num_Args = 16;
+
+  Auto_Function_Wrapper(
+      Func func,
+      Data_Object<Exception_Handler> handler,
+      Arguments* arguments = 0);
+
+  ~Auto_Function_Wrapper();
+
+  static VALUE call(int argc, VALUE* args, VALUE self);
+
+private:
+  Func func_;
+  Data_Object<Exception_Handler> handler_;
+  Address_Registration_Guard handler_guard_;
+  Arguments* arguments_;
+};
+
+// ---------------------------------------------------------------------
+template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T, typename Arg13_T, typename Arg14_T>
+class Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T, Arg14_T>
+  : public Wrapped_Function
+{
+public:
+  typedef Func_T Func;
+
+  static const int Num_Args = 15;
+
+  Auto_Function_Wrapper(
+      Func func,
+      Data_Object<Exception_Handler> handler,
+      Arguments* arguments = 0);
+
+  ~Auto_Function_Wrapper();
+
+  static VALUE call(int argc, VALUE* args, VALUE self);
+
+private:
+  Func func_;
+  Data_Object<Exception_Handler> handler_;
+  Address_Registration_Guard handler_guard_;
+  Arguments* arguments_;
+};
+
+template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T, typename Arg13_T, typename Arg14_T>
+class Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T, Arg14_T>
+  : public Wrapped_Function
+{
+public:
+  typedef Func_T Func;
+
+  static const int Num_Args = 15;
+
+  Auto_Function_Wrapper(
+      Func func,
+      Data_Object<Exception_Handler> handler,
+      Arguments* arguments = 0);
+
+  ~Auto_Function_Wrapper();
+
+  static VALUE call(int argc, VALUE* args, VALUE self);
+
+private:
+  Func func_;
+  Data_Object<Exception_Handler> handler_;
+  Address_Registration_Guard handler_guard_;
+  Arguments* arguments_;
+};
+
+// ---------------------------------------------------------------------
+template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T, typename Arg13_T>
+class Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T>
+  : public Wrapped_Function
+{
+public:
+  typedef Func_T Func;
+
+  static const int Num_Args = 14;
+
+  Auto_Function_Wrapper(
+      Func func,
+      Data_Object<Exception_Handler> handler,
+      Arguments* arguments = 0);
+
+  ~Auto_Function_Wrapper();
+
+  static VALUE call(int argc, VALUE* args, VALUE self);
+
+private:
+  Func func_;
+  Data_Object<Exception_Handler> handler_;
+  Address_Registration_Guard handler_guard_;
+  Arguments* arguments_;
+};
+
+template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T, typename Arg13_T>
+class Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T>
+  : public Wrapped_Function
+{
+public:
+  typedef Func_T Func;
+
+  static const int Num_Args = 14;
+
+  Auto_Function_Wrapper(
+      Func func,
+      Data_Object<Exception_Handler> handler,
+      Arguments* arguments = 0);
+
+  ~Auto_Function_Wrapper();
+
+  static VALUE call(int argc, VALUE* args, VALUE self);
+
+private:
+  Func func_;
+  Data_Object<Exception_Handler> handler_;
+  Address_Registration_Guard handler_guard_;
+  Arguments* arguments_;
+};
+
+// ---------------------------------------------------------------------
+template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T>
+class Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T>
+  : public Wrapped_Function
+{
+public:
+  typedef Func_T Func;
+
+  static const int Num_Args = 13;
+
+  Auto_Function_Wrapper(
+      Func func,
+      Data_Object<Exception_Handler> handler,
+      Arguments* arguments = 0);
+
+  ~Auto_Function_Wrapper();
+
+  static VALUE call(int argc, VALUE* args, VALUE self);
+
+private:
+  Func func_;
+  Data_Object<Exception_Handler> handler_;
+  Address_Registration_Guard handler_guard_;
+  Arguments* arguments_;
+};
+
+template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T>
+class Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T>
+  : public Wrapped_Function
+{
+public:
+  typedef Func_T Func;
+
+  static const int Num_Args = 13;
+
+  Auto_Function_Wrapper(
+      Func func,
+      Data_Object<Exception_Handler> handler,
+      Arguments* arguments = 0);
+
+  ~Auto_Function_Wrapper();
+
+  static VALUE call(int argc, VALUE* args, VALUE self);
+
+private:
+  Func func_;
+  Data_Object<Exception_Handler> handler_;
+  Address_Registration_Guard handler_guard_;
+  Arguments* arguments_;
+};
+
+// ---------------------------------------------------------------------
+template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T>
+class Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T>
+  : public Wrapped_Function
+{
+public:
+  typedef Func_T Func;
+
+  static const int Num_Args = 12;
+
+  Auto_Function_Wrapper(
+      Func func,
+      Data_Object<Exception_Handler> handler,
+      Arguments* arguments = 0);
+
+  ~Auto_Function_Wrapper();
+
+  static VALUE call(int argc, VALUE* args, VALUE self);
+
+private:
+  Func func_;
+  Data_Object<Exception_Handler> handler_;
+  Address_Registration_Guard handler_guard_;
+  Arguments* arguments_;
+};
+
+template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T>
+class Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T>
+  : public Wrapped_Function
+{
+public:
+  typedef Func_T Func;
+
+  static const int Num_Args = 12;
+
+  Auto_Function_Wrapper(
+      Func func,
+      Data_Object<Exception_Handler> handler,
+      Arguments* arguments = 0);
+
+  ~Auto_Function_Wrapper();
+
+  static VALUE call(int argc, VALUE* args, VALUE self);
+
+private:
+  Func func_;
+  Data_Object<Exception_Handler> handler_;
+  Address_Registration_Guard handler_guard_;
+  Arguments* arguments_;
+};
+
+// ---------------------------------------------------------------------
+template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T>
+class Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T>
+  : public Wrapped_Function
+{
+public:
+  typedef Func_T Func;
+
+  static const int Num_Args = 11;
+
+  Auto_Function_Wrapper(
+      Func func,
+      Data_Object<Exception_Handler> handler,
+      Arguments* arguments = 0);
+
+  ~Auto_Function_Wrapper();
+
+  static VALUE call(int argc, VALUE* args, VALUE self);
+
+private:
+  Func func_;
+  Data_Object<Exception_Handler> handler_;
+  Address_Registration_Guard handler_guard_;
+  Arguments* arguments_;
+};
+
+template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T>
+class Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T>
+  : public Wrapped_Function
+{
+public:
+  typedef Func_T Func;
+
+  static const int Num_Args = 11;
+
+  Auto_Function_Wrapper(
+      Func func,
+      Data_Object<Exception_Handler> handler,
+      Arguments* arguments = 0);
+
+  ~Auto_Function_Wrapper();
+
+  static VALUE call(int argc, VALUE* args, VALUE self);
+
+private:
+  Func func_;
+  Data_Object<Exception_Handler> handler_;
+  Address_Registration_Guard handler_guard_;
+  Arguments* arguments_;
+};
+
+// ---------------------------------------------------------------------
+template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T>
+class Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T>
+  : public Wrapped_Function
+{
+public:
+  typedef Func_T Func;
+
+  static const int Num_Args = 10;
+
+  Auto_Function_Wrapper(
+      Func func,
+      Data_Object<Exception_Handler> handler,
+      Arguments* arguments = 0);
+
+  ~Auto_Function_Wrapper();
+
+  static VALUE call(int argc, VALUE* args, VALUE self);
+
+private:
+  Func func_;
+  Data_Object<Exception_Handler> handler_;
+  Address_Registration_Guard handler_guard_;
+  Arguments* arguments_;
+};
+
+template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T>
+class Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T>
+  : public Wrapped_Function
+{
+public:
+  typedef Func_T Func;
+
+  static const int Num_Args = 10;
+
+  Auto_Function_Wrapper(
+      Func func,
+      Data_Object<Exception_Handler> handler,
+      Arguments* arguments = 0);
+
+  ~Auto_Function_Wrapper();
+
+  static VALUE call(int argc, VALUE* args, VALUE self);
+
+private:
+  Func func_;
+  Data_Object<Exception_Handler> handler_;
+  Address_Registration_Guard handler_guard_;
+  Arguments* arguments_;
+};
+
+// ---------------------------------------------------------------------
+template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T>
+class Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T>
+  : public Wrapped_Function
+{
+public:
+  typedef Func_T Func;
+
+  static const int Num_Args = 9;
+
+  Auto_Function_Wrapper(
+      Func func,
+      Data_Object<Exception_Handler> handler,
+      Arguments* arguments = 0);
+
+  ~Auto_Function_Wrapper();
+
+  static VALUE call(int argc, VALUE* args, VALUE self);
+
+private:
+  Func func_;
+  Data_Object<Exception_Handler> handler_;
+  Address_Registration_Guard handler_guard_;
+  Arguments* arguments_;
+};
+
+template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T>
+class Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T>
+  : public Wrapped_Function
+{
+public:
+  typedef Func_T Func;
+
+  static const int Num_Args = 9;
+
+  Auto_Function_Wrapper(
+      Func func,
+      Data_Object<Exception_Handler> handler,
+      Arguments* arguments = 0);
+
+  ~Auto_Function_Wrapper();
+
+  static VALUE call(int argc, VALUE* args, VALUE self);
+
+private:
+  Func func_;
+  Data_Object<Exception_Handler> handler_;
+  Address_Registration_Guard handler_guard_;
+  Arguments* arguments_;
+};
+
+// ---------------------------------------------------------------------
+template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T>
+class Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T>
+  : public Wrapped_Function
+{
+public:
+  typedef Func_T Func;
+
+  static const int Num_Args = 8;
+
+  Auto_Function_Wrapper(
+      Func func,
+      Data_Object<Exception_Handler> handler,
+      Arguments* arguments = 0);
+
+  ~Auto_Function_Wrapper();
+
+  static VALUE call(int argc, VALUE* args, VALUE self);
+
+private:
+  Func func_;
+  Data_Object<Exception_Handler> handler_;
+  Address_Registration_Guard handler_guard_;
+  Arguments* arguments_;
+};
+
+template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T>
+class Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T>
+  : public Wrapped_Function
+{
+public:
+  typedef Func_T Func;
+
+  static const int Num_Args = 8;
+
+  Auto_Function_Wrapper(
+      Func func,
+      Data_Object<Exception_Handler> handler,
+      Arguments* arguments = 0);
+
+  ~Auto_Function_Wrapper();
+
+  static VALUE call(int argc, VALUE* args, VALUE self);
+
+private:
+  Func func_;
+  Data_Object<Exception_Handler> handler_;
+  Address_Registration_Guard handler_guard_;
+  Arguments* arguments_;
+};
+
+// ---------------------------------------------------------------------
+template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T>
+class Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T>
+  : public Wrapped_Function
+{
+public:
+  typedef Func_T Func;
+
+  static const int Num_Args = 7;
+
+  Auto_Function_Wrapper(
+      Func func,
+      Data_Object<Exception_Handler> handler,
+      Arguments* arguments = 0);
+
+  ~Auto_Function_Wrapper();
+
+  static VALUE call(int argc, VALUE* args, VALUE self);
+
+private:
+  Func func_;
+  Data_Object<Exception_Handler> handler_;
+  Address_Registration_Guard handler_guard_;
+  Arguments* arguments_;
+};
+
+template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T>
+class Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T>
+  : public Wrapped_Function
+{
+public:
+  typedef Func_T Func;
+
+  static const int Num_Args = 7;
+
+  Auto_Function_Wrapper(
+      Func func,
+      Data_Object<Exception_Handler> handler,
+      Arguments* arguments = 0);
+
+  ~Auto_Function_Wrapper();
+
+  static VALUE call(int argc, VALUE* args, VALUE self);
+
+private:
+  Func func_;
+  Data_Object<Exception_Handler> handler_;
+  Address_Registration_Guard handler_guard_;
+  Arguments* arguments_;
+};
+
+// ---------------------------------------------------------------------
+template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T>
+class Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T>
+  : public Wrapped_Function
+{
+public:
+  typedef Func_T Func;
+
+  static const int Num_Args = 6;
+
+  Auto_Function_Wrapper(
+      Func func,
+      Data_Object<Exception_Handler> handler,
+      Arguments* arguments = 0);
+
+  ~Auto_Function_Wrapper();
+
+  static VALUE call(int argc, VALUE* args, VALUE self);
+
+private:
+  Func func_;
+  Data_Object<Exception_Handler> handler_;
+  Address_Registration_Guard handler_guard_;
+  Arguments* arguments_;
+};
+
+template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T>
+class Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T>
+  : public Wrapped_Function
+{
+public:
+  typedef Func_T Func;
+
+  static const int Num_Args = 6;
+
+  Auto_Function_Wrapper(
+      Func func,
+      Data_Object<Exception_Handler> handler,
+      Arguments* arguments = 0);
+
+  ~Auto_Function_Wrapper();
+
+  static VALUE call(int argc, VALUE* args, VALUE self);
+
+private:
+  Func func_;
+  Data_Object<Exception_Handler> handler_;
+  Address_Registration_Guard handler_guard_;
+  Arguments* arguments_;
+};
+
+// ---------------------------------------------------------------------
+template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T>
+class Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T>
+  : public Wrapped_Function
+{
+public:
+  typedef Func_T Func;
+
+  static const int Num_Args = 5;
+
+  Auto_Function_Wrapper(
+      Func func,
+      Data_Object<Exception_Handler> handler,
+      Arguments* arguments = 0);
+
+  ~Auto_Function_Wrapper();
+
+  static VALUE call(int argc, VALUE* args, VALUE self);
+
+private:
+  Func func_;
+  Data_Object<Exception_Handler> handler_;
+  Address_Registration_Guard handler_guard_;
+  Arguments* arguments_;
+};
+
+template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T>
+class Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T>
+  : public Wrapped_Function
+{
+public:
+  typedef Func_T Func;
+
+  static const int Num_Args = 5;
+
+  Auto_Function_Wrapper(
+      Func func,
+      Data_Object<Exception_Handler> handler,
+      Arguments* arguments = 0);
+
+  ~Auto_Function_Wrapper();
+
+  static VALUE call(int argc, VALUE* args, VALUE self);
+
+private:
+  Func func_;
+  Data_Object<Exception_Handler> handler_;
+  Address_Registration_Guard handler_guard_;
+  Arguments* arguments_;
+};
+
+// ---------------------------------------------------------------------
+template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T>
+class Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T>
+  : public Wrapped_Function
+{
+public:
+  typedef Func_T Func;
+
+  static const int Num_Args = 4;
+
+  Auto_Function_Wrapper(
+      Func func,
+      Data_Object<Exception_Handler> handler,
+      Arguments* arguments = 0);
+
+  ~Auto_Function_Wrapper();
+
+  static VALUE call(int argc, VALUE* args, VALUE self);
+
+private:
+  Func func_;
+  Data_Object<Exception_Handler> handler_;
+  Address_Registration_Guard handler_guard_;
+  Arguments* arguments_;
+};
+
+template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T>
+class Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T>
+  : public Wrapped_Function
+{
+public:
+  typedef Func_T Func;
+
+  static const int Num_Args = 4;
+
+  Auto_Function_Wrapper(
+      Func func,
+      Data_Object<Exception_Handler> handler,
+      Arguments* arguments = 0);
+
+  ~Auto_Function_Wrapper();
+
+  static VALUE call(int argc, VALUE* args, VALUE self);
+
+private:
+  Func func_;
+  Data_Object<Exception_Handler> handler_;
+  Address_Registration_Guard handler_guard_;
+  Arguments* arguments_;
+};
+
+// ---------------------------------------------------------------------
+template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T>
+class Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T>
+  : public Wrapped_Function
+{
+public:
+  typedef Func_T Func;
+
+  static const int Num_Args = 3;
+
+  Auto_Function_Wrapper(
+      Func func,
+      Data_Object<Exception_Handler> handler,
+      Arguments* arguments = 0);
+
+  ~Auto_Function_Wrapper();
+
+  static VALUE call(int argc, VALUE* args, VALUE self);
+
+private:
+  Func func_;
+  Data_Object<Exception_Handler> handler_;
+  Address_Registration_Guard handler_guard_;
+  Arguments* arguments_;
+};
+
+template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T>
+class Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T>
+  : public Wrapped_Function
+{
+public:
+  typedef Func_T Func;
+
+  static const int Num_Args = 3;
+
+  Auto_Function_Wrapper(
+      Func func,
+      Data_Object<Exception_Handler> handler,
+      Arguments* arguments = 0);
+
+  ~Auto_Function_Wrapper();
+
+  static VALUE call(int argc, VALUE* args, VALUE self);
+
+private:
+  Func func_;
+  Data_Object<Exception_Handler> handler_;
+  Address_Registration_Guard handler_guard_;
+  Arguments* arguments_;
+};
+
+// ---------------------------------------------------------------------
+template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T>
+class Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T>
+  : public Wrapped_Function
+{
+public:
+  typedef Func_T Func;
+
+  static const int Num_Args = 2;
+
+  Auto_Function_Wrapper(
+      Func func,
+      Data_Object<Exception_Handler> handler,
+      Arguments* arguments = 0);
+
+  ~Auto_Function_Wrapper();
+
+  static VALUE call(int argc, VALUE* args, VALUE self);
+
+private:
+  Func func_;
+  Data_Object<Exception_Handler> handler_;
+  Address_Registration_Guard handler_guard_;
+  Arguments* arguments_;
+};
+
+template<typename Func_T, typename Arg0_T, typename Arg1_T>
+class Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T>
+  : public Wrapped_Function
+{
+public:
+  typedef Func_T Func;
+
+  static const int Num_Args = 2;
+
+  Auto_Function_Wrapper(
+      Func func,
+      Data_Object<Exception_Handler> handler,
+      Arguments* arguments = 0);
+
+  ~Auto_Function_Wrapper();
+
+  static VALUE call(int argc, VALUE* args, VALUE self);
+
+private:
+  Func func_;
+  Data_Object<Exception_Handler> handler_;
+  Address_Registration_Guard handler_guard_;
+  Arguments* arguments_;
+};
+
+// ---------------------------------------------------------------------
+template<typename Func_T, typename Ret_T, typename Arg0_T>
+class Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T>
+  : public Wrapped_Function
+{
+public:
+  typedef Func_T Func;
+
+  static const int Num_Args = 1;
+
+  Auto_Function_Wrapper(
+      Func func,
+      Data_Object<Exception_Handler> handler,
+      Arguments* arguments = 0);
+
+  ~Auto_Function_Wrapper();
+
+  static VALUE call(int argc, VALUE* args, VALUE self);
+
+private:
+  Func func_;
+  Data_Object<Exception_Handler> handler_;
+  Address_Registration_Guard handler_guard_;
+  Arguments* arguments_;
+};
+
+template<typename Func_T, typename Arg0_T>
+class Auto_Function_Wrapper<Func_T, void, Arg0_T>
+  : public Wrapped_Function
+{
+public:
+  typedef Func_T Func;
+
+  static const int Num_Args = 1;
+
+  Auto_Function_Wrapper(
+      Func func,
+      Data_Object<Exception_Handler> handler,
+      Arguments* arguments = 0);
+
+  ~Auto_Function_Wrapper();
+
+  static VALUE call(int argc, VALUE* args, VALUE self);
+
+private:
+  Func func_;
+  Data_Object<Exception_Handler> handler_;
+  Address_Registration_Guard handler_guard_;
+  Arguments* arguments_;
+};
+
+// ---------------------------------------------------------------------
+
+template<typename Func_T, typename Ret_T>
+class Auto_Function_Wrapper<Func_T, Ret_T>
+  : public Wrapped_Function
+{
+public:
+  // typedef void (*Func)();
+  typedef Func_T Func;
+
+  static const int Num_Args = 0;
+
+  Auto_Function_Wrapper(
+      Func func,
+      Data_Object<Exception_Handler> handler,
+      Arguments* arguments = new Arguments());
+
+  ~Auto_Function_Wrapper();
+
+  static VALUE call();
+
+private:
+  Func func_;
+  Data_Object<Exception_Handler> handler_;
+  Arguments* arguments_;
+};
+
+template<typename Func_T>
+class Auto_Function_Wrapper<Func_T, void>
+  : public Wrapped_Function
+{
+public:
+  // typedef void (*Func)();
+  typedef Func_T Func;
+
+  static const int Num_Args = 0;
+
+  Auto_Function_Wrapper(
+      Func func,
+      Data_Object<Exception_Handler> handler,
+      Arguments* arguments = new Arguments());
+
+  ~Auto_Function_Wrapper();
+
+  static VALUE call();
+
+private:
+  Func func_;
+  Data_Object<Exception_Handler> handler_;
+  Arguments* arguments_;
+};
+
+#endif // DOXYGEN
+
+} // namespace detail
+
+} // namespace Rice
+
+#include "Auto_Function_Wrapper.ipp"
+
+#endif // Rice__detail__Auto_Function_Wrapper__hpp_
+