wurlinc-rice 1.4.0.1

data/rice/Module_defn.hpp

@@ -0,0 +1,88 @@
+#ifndef Rice__Module_defn__hpp_
+#define Rice__Module_defn__hpp_
+
+#include "Object_defn.hpp"
+#include "Module_impl.hpp"
+#include "to_from_ruby_defn.hpp"
+#include <memory>
+
+namespace Rice
+{
+
+class Array;
+class Class;
+class String;
+
+//! A helper for defining a Module and its methods.
+/*! This class provides a C++-style interface to ruby's Module class and
+ *  for defining methods on that module.
+ *
+ *  Many of the methods are defined in Module_impl.hpp so that they can
+ *  return a reference to the most derived type.
+ */
+class Module
+  // TODO: we can't inherit from Builtin_Object, because Class needs
+  // type T_CLASS and Module needs type T_MODULE
+  : public Module_impl<Module_base, Module>
+{
+public:
+  //! Default construct a Module and initialize it to rb_cObject.
+  Module();
+
+  //! Construct a Module from an existing Module object.
+  Module(VALUE v);
+
+  //! Return the name of the module.
+  String name() const;
+
+  //! Swap with another Module.
+  void swap(Module & other);
+
+  //! Return an array containing the Module's ancestors.
+  /*! You will need to include Array.hpp to use this function.
+   */
+  Array ancestors() const;
+
+  //! Return the module's singleton class.
+  /*! You will need to include Class.hpp to use this function.
+   */
+  Class singleton_class() const;
+};
+
+//! Define a new module in the namespace given by module.
+/*! \param module the module in which to define the new module.
+ *  \param name the name of the new module.
+ */
+Module define_module_under(
+    Object module,
+    char const * name);
+
+//! Define a new module in the default namespace.
+/*! \param name the name of the new module.
+ */
+Module define_module(
+    char const * name);
+
+//! Create a new anonymous module.
+/*! \return the new module.
+ */
+Module anonymous_module();
+
+} // namespace Rice
+
+template<>
+inline
+Rice::Module from_ruby<Rice::Module>(Rice::Object x)
+{
+  return Rice::Module(x);
+}
+
+template<>
+inline
+Rice::Object to_ruby<Rice::Module>(Rice::Module const & x)
+{
+  return x;
+}
+
+#endif // Rice__Module_defn__hpp_
+

data/rice/Module_impl.hpp

@@ -0,0 +1,281 @@
+#ifndef Rice__Module_impl__hpp_
+#define Rice__Module_impl__hpp_
+
+#include "detail/Exception_Handler_defn.hpp"
+#include "detail/ruby.hpp"
+#include "Object_defn.hpp"
+#include "Address_Registration_Guard_defn.hpp"
+#include "Arg.hpp"
+
+namespace Rice
+{
+
+class Module;
+class Class;
+template<typename T> class Data_Type;
+
+/*! Holds all member data of Module_impl so it only exists in one place
+ *  in the hierarchy.
+ */
+class Module_base
+  : public Object
+{
+public:
+  Module_base(VALUE v = rb_cObject);
+  Module_base(Module_base const & other);
+
+  Module_base & operator=(Module_base const & other);
+
+  void swap(Module_base & other);
+
+protected:
+  template<typename Exception_T, typename Functor_T>
+  void add_handler(Functor_T functor);
+
+  Object handler() const;
+
+private:
+  Object mutable handler_;
+  Address_Registration_Guard handler_guard_;
+};
+
+/*! An intermediate base class so we can always return the most-derived
+ *  type (Module, Class, Data_Type, ...) without having to re-implement
+ *  each function for each derived class.
+ */
+template<typename Base_T, typename Derived_T>
+class Module_impl
+  : public Base_T
+{
+public:
+  Module_impl();
+
+  template<typename T>
+  Module_impl(T const & arg);
+
+  //! Define an exception handler.
+  /*! Whenever an exception of type Exception_T is thrown from a
+   *  function defined on this class, functor will be called to
+   *  translate the exception into a ruby exception.
+   *  \param Exception_T a template parameter indicating the type of
+   *  exception to be translated.
+   *  \param functor a functor to be called to translate the exception
+   *  into a ruby exception.  This functor should re-throw the exception
+   *  as an Exception.
+   *  Example:
+   *  \code
+   *    class MyException : public std::exception { };
+   *    Data_Type<MyException> rb_cMyException;
+   *    Class rb_cFoo;
+   *
+   *    void translate_my_exception(MyException const & ex)
+   *    {
+   *      Data_Object<MyException> ex_(
+   *          new MyException(ex),
+   *          rb_cMyException);
+   *      throw Exception(ex_);
+   *    }
+   *
+   *    extern "C"
+   *    void Init_MyExtension()
+   *    {
+   *      rb_cMyException = define_class("MyException");
+   *      rb_cFoo = define_class("Foo")
+   *        .add_handler<MyException>(translate_my_exception);
+   *    }
+   *  \endcode
+   */
+  template<typename Exception_T, typename Functor_T>
+  Derived_T & add_handler(
+      Functor_T functor);
+
+  //! Define an instance method.
+  /*! The method's implementation can be any function or member
+   *  function.  A wrapper will be generated which will use from_ruby<>
+   *  to convert the arguments from ruby types to C++ types before
+   *  calling the function.  The return value will be converted back to
+   *  ruby by using to_ruby().
+   *  \param name the name of the method
+   *  \param func the implementation of the function, either a function
+   *  pointer or a member function pointer.
+   *  \param arguments the list of arguments of this function, used for
+   *  defining default parameters (optional)
+   *  \return *this
+   */
+  template<typename Func_T>
+  Derived_T & define_method(
+      Identifier name,
+      Func_T func,
+      Arguments* arguments = 0);
+
+  // FIXME There's GOT to be a better way to
+  // do this. Handles the case where there is a single
+  // argument defined for this method
+  template<typename Func_T>
+  Derived_T & define_method(
+      Identifier name,
+      Func_T func,
+      Arg const& arg);
+
+  //! Define a singleton method.
+  /*! The method's implementation can be any function or member
+   *  function.  A wrapper will be generated which will use from_ruby<>
+   *  to convert the arguments from ruby types to C++ types before
+   *  calling the function.  The return value will be converted back to
+   *  ruby by using to_ruby().
+   *  \param name the name of the method
+   *  \param func the implementation of the function, either a function
+   *  pointer or a member function pointer.
+   *  \param arguments the list of arguments of this function, used for
+   *  defining default parameters (optional)
+   *  \return *this
+   */
+  template<typename Func_T>
+  Derived_T & define_singleton_method(
+      Identifier name,
+      Func_T func,
+      Arguments* arguments = 0);
+
+  // FIXME: See define_method with Arg above
+  template<typename Func_T>
+  Derived_T & define_singleton_method(
+      Identifier name,
+      Func_T func,
+      Arg const& arg);
+
+  //! Define a module function.
+  /*! A module function is a function that can be accessed either as a
+   *  singleton method or as an instance method.
+   *  The method's implementation can be any function or member
+   *  function.  A wrapper will be generated which will use from_ruby<>
+   *  to convert the arguments from ruby types to C++ types before
+   *  calling the function.  The return value will be converted back to
+   *  ruby by using to_ruby().
+   *  \param name the name of the method
+   *  \param func the implementation of the function, either a function
+   *  pointer or a member function pointer.
+   *  \param arguments the list of arguments of this function, used for
+   *  defining default parameters (optional)
+   *  \return *this
+   */
+  template<typename Func_T>
+  Derived_T & define_module_function(
+      Identifier name,
+      Func_T func,
+      Arguments* arguments = 0);
+
+  // FIXME: See define_method with Arg above
+  template<typename Func_T>
+  Derived_T & define_module_function(
+      Identifier name,
+      Func_T func,
+      Arg const& arg);
+
+  //! Define an iterator.
+  /*! Essentially this is a conversion from a C++-style begin/end
+   *  iterator to a Ruby-style \#each iterator.
+   *  \param begin a member function pointer to a function that returns
+   *  an iterator to the beginning of the sequence.
+   *  \param end a member function pointer to a function that returns an
+   *  iterator to the end of the sequence.
+   *  \param name the name of the iterator.
+   *  \return *this
+   */
+  template<typename T, typename Iterator_T>
+  Derived_T & define_iterator(
+      Iterator_T (T::*begin)(),
+      Iterator_T (T::*end)(),
+      Identifier name = "each");
+
+  //! Include a module.
+  /*! \param inc the module to be included.
+   *  \return *this
+   */
+  Derived_T & include_module(
+      Module const & inc);
+
+  //! Set a constant.
+  /*! \param name the name of the constant to set.
+   *  \param value the value of the constant.
+   *  \return *this
+   */
+  Derived_T & const_set(
+      Identifier name,
+      Object value);
+
+  //! Get a constant.
+  /*! \param name the name of the constant to get.
+   *  \return the value of the constant.
+   */
+  Object const_get(
+      Identifier name) const;
+
+  //! Determine whether a constant is defined.
+  /*! \param name the name of the constant to check.
+   *  \return true if the constant is defined in this module or false
+   *  otherwise.
+   */
+  bool const_defined(
+      Identifier name) const;
+
+  //! Remove a constant.
+  /*! \param name the name of the constant to remove.
+   */
+  void remove_const(
+      Identifier name);
+
+  //! Define a module under this module.
+  /*! \param name the name of the module.
+   *  \return the new class.
+   */
+  Module define_module(
+      char const * name);
+
+  //! Define a class under this module.
+  /*! \param name the name of the class.
+   *  \param superclass the base class to use.
+   *  \return the new class.
+   */
+  Class define_class(
+      char const * name,
+      Object superclass = rb_cObject);
+
+  //! Define a new data class under this module.
+  /*! The class will have a base class of Object.
+   *  \param T the C++ type of the wrapped class.
+   *  \return the new class.
+   */
+  // This function needs to be defined inline to work around a bug in
+  // g++ 3.3.3.
+  template<typename T>
+  Data_Type<T>
+  define_class(
+      char const * name)
+  {
+    return this->define_class_with_object_as_base<T>(name);
+  }
+
+  //! Define a new data class under this module.
+  /*! The class with have a base class determined by Base_T (specifically,
+   *  Data_Type<Base_T>::klass).  Therefore, the type Base_T must already
+   *  have been registered using define_class<> or define_class_under<>.
+   *  \param T the C++ type of the wrapped class.
+   *  \return the new class.
+   */
+  template<typename T, typename T_Base_T>
+  Data_Type<T>
+  define_class(
+      char const * name);
+
+private:
+  // Workaround for g++ 3.3.3 (see above).
+  template<typename T>
+  Data_Type<T>
+  define_class_with_object_as_base(
+      char const * name);
+};
+
+} // namespace Rice
+
+#endif // Rice__Module_impl__hpp_
+

data/rice/Module_impl.ipp

@@ -0,0 +1,348 @@
+#include "detail/define_method_and_auto_wrap.hpp"
+#include "Object.hpp"
+#include "Address_Registration_Guard.hpp"
+#include "Data_Object.hpp"
+#include "Data_Type.hpp"
+#include "Symbol.hpp"
+#include "Exception.hpp"
+#include "protect.hpp"
+
+#include "Module.hpp"
+#include "Class.hpp"
+#include "Data_Type.hpp"
+
+#include "detail/ruby.hpp"
+#include "detail/method_data.hpp"
+#include "detail/Iterator.hpp"
+
+
+inline
+Rice::Module_base::
+Module_base(VALUE v)
+  : Object(v)
+  , handler_(Qnil)
+  , handler_guard_(&handler_)
+{
+}
+
+inline
+Rice::Module_base::
+Module_base(Module_base const & other)
+  : Object(other)
+  , handler_(other.handler_)
+  , handler_guard_(&handler_)
+{
+}
+
+inline
+Rice::Module_base &
+Rice::Module_base::
+operator=(Module_base const & other)
+{
+  Module_base tmp(other);
+  swap(tmp);
+  return *this;
+}
+
+inline
+void
+Rice::Module_base::
+swap(Module_base & other)
+{
+  std::swap(handler_, other.handler_);
+  Object::swap(other);
+}
+
+template<typename Exception_T, typename Functor_T>
+inline
+void
+Rice::Module_base::
+add_handler(Functor_T functor)
+{
+  Data_Object<detail::Exception_Handler> handler(
+      new detail::
+      Functor_Exception_Handler<Exception_T, Functor_T>(
+          functor,
+          this->handler()),
+      rb_cObject);
+  this->handler_.swap(handler);
+}
+
+inline
+Rice::Object
+Rice::Module_base::
+handler() const
+{
+  if(!handler_.test())
+  {
+    Data_Object<Rice::detail::Default_Exception_Handler> handler(
+        new Rice::detail::Default_Exception_Handler,
+        rb_cObject);
+    handler_.swap(handler);
+  }
+
+  return handler_;
+}
+
+template<typename Base_T, typename Derived_T>
+inline
+Rice::Module_impl<Base_T, Derived_T>::
+Module_impl()
+  : Base_T()
+{
+}
+
+template<typename Base_T, typename Derived_T>
+template<typename T>
+inline
+Rice::Module_impl<Base_T, Derived_T>::
+Module_impl(T const & arg)
+  : Base_T(arg)
+{
+}
+
+template<typename Base_T, typename Derived_T>
+template<typename Exception_T, typename Functor_T>
+inline
+Derived_T &
+Rice::Module_impl<Base_T, Derived_T>::
+add_handler(
+    Functor_T functor)
+{
+  Module_base::add_handler<Exception_T>(functor);
+  return (Derived_T &)*this;
+}
+
+template<typename Base_T, typename Derived_T>
+template<typename Func_T>
+inline
+Derived_T &
+Rice::Module_impl<Base_T, Derived_T>::
+define_method(
+    Identifier name,
+    Func_T func,
+    Arguments* arguments)
+{
+  detail::define_method_and_auto_wrap(
+      *this, name, func, this->handler(), arguments);
+  return (Derived_T &)*this;
+}
+
+template<typename Base_T, typename Derived_T>
+template<typename Func_T>
+inline
+Derived_T &
+Rice::Module_impl<Base_T, Derived_T>::
+define_method(
+    Identifier name,
+    Func_T func,
+    Arg const& arg)
+{
+  Arguments* args = new Arguments();
+  args->add(arg);
+  return define_method(name, func, args);
+}
+
+
+template<typename Base_T, typename Derived_T>
+template<typename Func_T>
+inline
+Derived_T &
+Rice::Module_impl<Base_T, Derived_T>::
+define_singleton_method(
+    Identifier name,
+    Func_T func,
+    Arguments* arguments)
+{
+  detail::define_method_and_auto_wrap(
+      rb_class_of(*this), name, func, this->handler(), arguments);
+  return (Derived_T &)*this;
+}
+
+template<typename Base_T, typename Derived_T>
+template<typename Func_T>
+inline
+Derived_T &
+Rice::Module_impl<Base_T, Derived_T>::
+define_singleton_method(
+    Identifier name,
+    Func_T func,
+    Arg const& arg)
+{
+  Arguments* args = new Arguments();
+  args->add(arg);
+  return define_singleton_method(name, func, args);
+}
+
+template<typename Base_T, typename Derived_T>
+template<typename Func_T>
+inline
+Derived_T &
+Rice::Module_impl<Base_T, Derived_T>::
+define_module_function(
+    Identifier name,
+    Func_T func,
+    Arguments* arguments)
+{
+  if(this->rb_type() != T_MODULE)
+  {
+    throw Rice::Exception(
+        rb_eTypeError,
+        "can only define module functions for modules");
+  }
+
+  define_method(name, func, arguments);
+  define_singleton_method(name, func, arguments);
+  return (Derived_T &)*this;
+}
+
+template<typename Base_T, typename Derived_T>
+template<typename Func_T>
+inline
+Derived_T &
+Rice::Module_impl<Base_T, Derived_T>::
+define_module_function(
+    Identifier name,
+    Func_T func,
+    Arg const& arg)
+{
+  Arguments* args = new Arguments();
+  args->add(arg);
+  return define_module_function(name, func, args);
+}
+
+template<typename Base_T, typename Derived_T>
+template<typename T, typename Iterator_T>
+inline
+Derived_T &
+Rice::Module_impl<Base_T, Derived_T>::
+define_iterator(
+    Iterator_T (T::*begin)(),
+    Iterator_T (T::*end)(),
+    Identifier name)
+{
+  detail::define_iterator(*this, name, begin, end);
+  return (Derived_T &)*this;
+}
+
+namespace Rice
+{
+
+namespace detail
+{
+
+inline VALUE
+  include_module(VALUE mod, VALUE inc)
+{
+  rb_include_module(mod, inc);
+  return Qnil;
+}
+
+inline VALUE
+const_set(VALUE mod, ID name, VALUE value)
+{
+  rb_const_set(mod, name, value);
+  return Qnil;
+}
+
+} // namespace detail
+
+} // namespace Rice
+
+template<typename Base_T, typename Derived_T>
+inline
+Derived_T &
+Rice::Module_impl<Base_T, Derived_T>::
+include_module(
+    Module const & inc)
+{
+  protect(detail::include_module, *this, inc);
+  return (Derived_T &)*this;
+}
+
+template<typename Base_T, typename Derived_T>
+inline
+Derived_T &
+Rice::Module_impl<Base_T, Derived_T>::
+const_set(
+    Identifier name,
+    Object value)
+{
+  protect(detail::const_set, *this, name, value);
+  return (Derived_T &)*this;
+}
+
+template<typename Base_T, typename Derived_T>
+inline
+Rice::Object
+Rice::Module_impl<Base_T, Derived_T>::
+const_get(
+    Identifier name) const
+{
+  return protect(rb_const_get, *this, name);
+}
+
+template<typename Base_T, typename Derived_T>
+inline
+bool
+Rice::Module_impl<Base_T, Derived_T>::
+const_defined(Identifier name) const
+{
+  int result = protect(rb_const_defined, *this, name);
+  return bool(result);
+}
+
+template<typename Base_T, typename Derived_T>
+inline
+void
+Rice::Module_impl<Base_T, Derived_T>::
+remove_const(Identifier name)
+{
+  protect(rb_mod_remove_const, *this, Symbol(name));
+}
+
+template<typename Base_T, typename Derived_T>
+inline
+Rice::Module
+Rice::Module_impl<Base_T, Derived_T>::
+define_module(
+    char const * name)
+{
+  return Rice::define_module_under(*this, name);
+}
+
+template<typename Base_T, typename Derived_T>
+inline
+Rice::Class
+Rice::Module_impl<Base_T, Derived_T>::
+define_class(
+    char const * name,
+    Object superclass)
+{
+  return Rice::define_class_under(*this, name, superclass);
+}
+
+template<typename Base_T, typename Derived_T>
+template<typename T>
+inline
+Rice::Data_Type<T>
+Rice::Module_impl<Base_T, Derived_T>::
+define_class_with_object_as_base(
+    char const * name)
+{
+  return Rice::define_class_under<T>(*this, name);
+}
+
+template<typename Base_T, typename Derived_T>
+template<typename T, typename T_Base_T>
+inline
+Rice::Data_Type<T>
+Rice::Module_impl<Base_T, Derived_T>::
+define_class(
+    char const * name)
+{
+  return Rice::define_class_under<T, T_Base_T>(
+      *this,
+      name);
+}
+