rice 1.0.0

data/rice/Module.cpp

@@ -0,0 +1,75 @@
+#include "Module.hpp"
+#include "Symbol.hpp"
+#include "Array.hpp"
+#include "Exception.hpp"
+#include "protect.hpp"
+
+Rice::Module::
+Module()
+  : Module_impl<Module_base, Module>(rb_cObject)
+{
+}
+
+Rice::Module::
+Module(VALUE v)
+  : Module_impl<Module_base, Module>(v)
+{
+  if(::rb_type(v) != T_CLASS && ::rb_type(v) != T_MODULE)
+  {
+    throw Exception(
+        rb_eTypeError,
+        "Expected a Module but got a %s",
+        rb_class2name(CLASS_OF(v))); // TODO: might raise an exception
+  }
+}
+
+Rice::Object Rice::Module::
+mod_name() const
+{
+  return rb_mod_name(*this);
+}
+
+Rice::Module Rice::
+define_module_under(
+    Rice::Object module,
+    char const * name)
+{
+  VALUE v = rb_define_module_under(module, name);
+  return Module(v);
+}
+
+Rice::Module Rice::
+define_module(
+    char const * name)
+{
+  VALUE v = rb_define_module(name);
+  return Module(v);
+}
+
+Rice::Module Rice::
+anonymous_module()
+{
+  return Module(protect(rb_module_new));
+}
+
+void Rice::Module::
+swap(Rice::Module & other)
+{
+  std::swap(handler_, other.handler_);
+  Object::swap(other);
+}
+
+Rice::Array
+Rice::Module::
+ancestors() const
+{
+  return protect(rb_mod_ancestors, *this);
+}
+
+Rice::Class
+Rice::Module::
+singleton_class() const
+{
+  return CLASS_OF(value());
+}
+

data/rice/Module.hpp

@@ -0,0 +1,8 @@
+#ifndef Rice__builtin__Module__hpp_
+#define Rice__builtin__Module__hpp_
+
+#include "Module_defn.hpp"
+#include "Module.ipp"
+
+#endif // Rice__builtin__Module__hpp_
+

data/rice/Module.ipp

@@ -0,0 +1,6 @@
+#ifndef Rice__Module__ipp_
+#define Rice__Module__ipp_
+
+#include "Module_impl.ipp"
+
+#endif // Rice__Module__ipp_

data/rice/Module_defn.hpp

@@ -0,0 +1,87 @@
+#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;
+
+//! 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.
+  Object mod_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,237 @@
+#ifndef Rice__Module_impl__hpp_
+#define Rice__Module_impl__hpp_
+
+#include "detail/Exception_Handler.hpp"
+#include "detail/ruby.hpp"
+#include "Object_defn.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);
+
+protected: // TODO
+  // TODO: For now, we always leak the handler, but in the future, we
+  // should register it with the garbage collector.
+  detail::Exception_Handler const * handler_;
+};
+
+/*! 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.
+   *  \return *this
+   */
+  template<typename Func_T>
+  Derived_T & define_method(
+      char const * name,
+      Func_T func);
+
+  //! 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.
+   *  \return *this
+   */
+  template<typename Func_T>
+  Derived_T & define_singleton_method(
+      char const * name,
+      Func_T func);
+
+  //! 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.
+   *  \return *this
+   */
+  template<typename Func_T>
+  Derived_T & define_module_function(
+      char const * name,
+      Func_T func);
+
+  //! 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)(),
+      char const * 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,302 @@
+#include "detail/define_method_and_auto_wrap.hpp"
+#include "Object.hpp"
+#include "Data_Object.hpp"
+#include "Data_Type.hpp"
+#include "Symbol.hpp"
+#include "protect.hpp"
+
+#include "Module.hpp"
+#include "Class.hpp"
+#include "Data_Type.hpp"
+
+#include "detail/ruby.hpp"
+#include "detail/method_data.hpp"
+
+
+inline
+Rice::Module_base::
+Module_base(VALUE v)
+  : Object(v)
+  , handler_(new Rice::detail::Default_Exception_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)
+{
+  this->handler_ =
+      new Rice::detail::
+      Functor_Exception_Handler<Exception_T, Functor_T>(
+          functor,
+          this->handler_);
+  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(
+    char const * name,
+    Func_T func)
+{
+  detail::define_method_and_auto_wrap(
+      *this, name, func, this->handler_);
+  return (Derived_T &)*this;
+}
+
+template<typename Base_T, typename Derived_T>
+template<typename T>
+inline
+Derived_T &
+Rice::Module_impl<Base_T, Derived_T>::
+define_singleton_method(
+    char const * name,
+    T func)
+{
+  detail::define_method_and_auto_wrap(
+      rb_class_of(*this), name, func, this->handler_);
+  return (Derived_T &)*this;
+}
+
+template<typename Base_T, typename Derived_T>
+template<typename T>
+inline
+Derived_T &
+Rice::Module_impl<Base_T, Derived_T>::
+define_module_function(
+    char const * name,
+    T func)
+{
+  detail::define_method_and_auto_wrap(*this, name, func);
+  this->call("module_function", Symbol(name));
+  return (Derived_T &)*this;
+}
+
+namespace Rice
+{
+
+namespace detail
+{
+
+class Iterator
+{
+public:
+  virtual ~Iterator() { }
+
+  virtual VALUE call_impl(VALUE self) = 0;
+
+  static VALUE call(VALUE self)
+  {
+    void * data = Rice::detail::method_data();
+    Iterator * iterator = static_cast<Iterator *>(data);
+    return iterator->call_impl(self);
+  }
+};
+
+template<typename T, typename Iterator_T>
+class Iterator_Impl
+  : public Iterator
+{
+public:
+  Iterator_Impl(
+      Iterator_T (T::*begin)(),
+      Iterator_T (T::*end)(),
+      Rice::Data_Type<T> data_type)
+    : begin_(begin)
+    , end_(end)
+    , data_type_(data_type)
+  {
+  }
+
+  virtual VALUE call_impl(VALUE self)
+  {
+    Rice::Data_Object<T> obj(self, data_type_);
+    Iterator_T it = obj->begin();
+    Iterator_T end = obj->end();
+    for(; it != end; ++it)
+    {
+      protect(rb_yield, to_ruby(*it));
+    }
+    return self;
+  }
+
+private:
+  Iterator_T (T::*begin_)();
+  Iterator_T (T::*end_)();
+  Rice::Data_Type<T> data_type_;
+};
+
+} // namespace detail
+
+} // namespace Rice
+
+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)(),
+    char const * name)
+{
+  // TODO: memory leak!!!!!!!
+  detail::Iterator * iterator =
+    new detail::Iterator_Impl<T, Iterator_T>(
+        begin,
+        end,
+        Data_Type<T>());
+  detail::define_method_with_data(
+      static_cast<VALUE>(*this),
+      name,
+      (RUBY_METHOD_FUNC)iterator->call,
+      0,
+      iterator);
+  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);
+}
+