rice 1.0.0

data/rice/detail/Caster.hpp

@@ -0,0 +1,61 @@
+#ifndef Rice__detail__Caster__hpp_
+#define Rice__detail__Caster__hpp_
+
+#include "../Module.hpp"
+#include <stdexcept>
+
+namespace Rice
+{
+
+namespace detail
+{
+
+class Abstract_Caster
+{
+public:
+  virtual void * cast_to_base(void * derived, Module type) const = 0;
+  virtual ~Abstract_Caster() { }
+};
+
+template<typename Derived_T, typename Base_T>
+class Caster
+  : public Abstract_Caster
+{
+public:
+  Caster(Abstract_Caster * base_caster, Module type)
+    : base_caster_(base_caster)
+    , type_(type)
+  {
+  }
+
+protected:
+  virtual void * cast_to_base(void * derived, Module type) const
+  {
+    if(type.value() == type_.value())
+    {
+      Derived_T * d(static_cast<Derived_T *>(derived));
+      return static_cast<Base_T *>(d);
+    }
+    else
+    {
+      if(base_caster_)
+      {
+        return base_caster_->cast_to_base(derived, type);
+      }
+      else
+      {
+        throw std::runtime_error("bad cast");
+      }
+    }
+  }
+
+private:
+  Abstract_Caster * base_caster_;
+  Module type_;
+};
+
+} // detail
+
+} // Rice
+
+#endif //Rice__detail__Caster__hpp_

data/rice/detail/Exception_Handler.hpp

@@ -0,0 +1,118 @@
+#ifndef Rice__detail__Exception_Handler__hpp_
+#define Rice__detail__Exception_Handler__hpp_
+
+#include "ruby.h"
+#undef TYPE
+
+namespace Rice
+{
+
+namespace detail
+{
+
+// A class for converting C++ exceptions to ruby exceptions.  It's used
+// like this:
+//
+//   try
+//   {
+//   }
+//   catch(...)
+//   {
+//     handler->handle_exception();
+//   }
+//
+// If an exception is thrown the handler will pass the exception up the
+// chain, then the last handler in the chain will throw the exception
+// down the chain until a lower handler can handle it, e.g.:
+//
+//   try
+//   {
+//     return call_next_exception_handler();
+//   }
+//   catch(MyException const & ex)
+//   {
+//     throw Rice::Exception(rb_cMyException, "%s", ex.what());
+//   }
+//
+class Exception_Handler
+{
+public:
+  Exception_Handler(Exception_Handler const * next_exception_handler)
+    : next_exception_handler_(next_exception_handler)
+  {
+  }
+
+  virtual ~Exception_Handler()
+  {
+  }
+
+  virtual VALUE handle_exception() const = 0;
+
+  VALUE call_next_exception_handler() const
+  {
+    return next_exception_handler_->handle_exception();
+  }
+
+private:
+  Exception_Handler const * next_exception_handler_;
+};
+
+// The default exception handler just rethrows the exception.  If there
+// are other handlers in the chain, they will try to handle the rethrown
+// exception.
+class Default_Exception_Handler
+  : public Exception_Handler
+{
+public:
+  Default_Exception_Handler()
+    : Exception_Handler(0)
+  {
+  }
+
+  virtual VALUE handle_exception() const
+  {
+    throw;
+  }
+};
+
+// An exception handler that takes a functor as an argument.  The
+// functor should throw a Rice::Exception to handle the exception.  If
+// the functor does not handle the exception, the exception will be
+// re-thrown.
+template <typename Exception_T, typename Functor_T>
+class Functor_Exception_Handler
+  : public Exception_Handler
+{
+public:
+  Functor_Exception_Handler(
+      Functor_T handler,
+      Exception_Handler const * next_exception_handler)
+    : Exception_Handler(next_exception_handler)
+    , handler_(handler)
+  {
+  }
+
+private:
+  virtual VALUE handle_exception() const
+  {
+    try
+    {
+      return call_next_exception_handler();
+    }
+    catch(Exception_T const & ex)
+    {
+      handler_(ex);
+      throw;
+    }
+  }
+
+private:
+  Functor_T handler_;
+};
+
+} // namespace detail
+
+} // namespace Rice
+
+#endif // Rice__detail__Exception_Handler__hpp_
+

data/rice/detail/Iterator_Definer.hpp

@@ -0,0 +1,98 @@
+#ifndef Rice__detail__Iterator_Definer__hpp_
+#define Rice__detail__Iterator_Definer__hpp_
+
+#include "method_data.hpp"
+#include "ruby.hpp"
+#include "../protect.hpp"
+#include "../Data_Object.hpp"
+
+namespace Rice
+{
+
+namespace detail
+{
+
+template<typename Derived_T>
+class Iterator_Definer
+{
+public:
+  virtual ~Iterator_Definer()
+  {
+  }
+
+  class Iterator
+  {
+  public:
+    virtual ~Iterator() { }
+
+    virtual VALUE call_impl(VALUE self) = 0;
+
+    static VALUE call(VALUE self)
+    {
+      void * data = 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)(),
+        Data_Type<T> data_type)
+      : begin_(begin)
+      , end_(end)
+      , data_type_(data_type)
+    {
+    }
+
+    virtual VALUE call_impl(VALUE self)
+    {
+      Data_Object<T> obj(self, data_type_);
+      Iterator_T it = obj->begin();
+      Iterator_T end = obj->end();
+      for(; it != end; ++it)
+      {
+        Rice::protect(rb_yield, to_ruby(*it));
+      }
+      return self;
+    }
+
+  private:
+    Iterator_T (T::*begin_)();
+    Iterator_T (T::*end_)();
+    Data_Type<T> data_type_;
+  };
+
+  template<typename T, typename Iterator_T>
+  Derived_T & define_iterator(
+      char const * name,
+      Iterator_T (T::*begin)(),
+      Iterator_T (T::*end)())
+  {
+    Derived_T & self = static_cast<Derived_T &>(*this);
+    // TODO: memory leak!!!!!!!
+    Iterator * iterator = new Iterator_Impl<T, Iterator_T>(
+        begin,
+        end,
+        Data_Type<T>(self));
+    define_method_with_data(
+        static_cast<VALUE>(self),
+        name,
+        (RUBY_METHOD_FUNC)iterator->call,
+        0,
+        iterator);
+    return self;
+  }
+};
+
+} // namespac edetail
+
+} // namespace Rice
+
+#endif // Rice__detail__Iterator_Definer__hpp_
+

data/rice/detail/Not_Copyable.hpp

@@ -0,0 +1,25 @@
+#ifndef Rice__Not_Copyable__hpp_
+#define Rice__Not_Copyable__hpp_
+
+namespace Rice
+{
+
+namespace detail
+{
+
+// Inherit from Not_Copyable to prevent copying instances of a class.
+class Not_Copyable
+{
+public:
+  Not_Copyable() { }
+
+private:
+  Not_Copyable(Not_Copyable const &);
+  Not_Copyable & operator=(Not_Copyable const &);
+};
+
+} // namespace detail
+
+} // namespace Rice
+
+#endif // Rice__Not_Copyable__hpp_

data/rice/detail/Wrapped_Function.hpp

@@ -0,0 +1,33 @@
+#ifndef Rice__detail__Wrapped_Function__hpp_
+#define Rice__detail__Wrapped_Function__hpp_
+
+#include "ruby.hpp"
+
+namespace Rice
+{
+
+namespace detail
+{
+
+class Wrapped_Function
+{
+public:
+  Wrapped_Function(RUBY_METHOD_FUNC func, int arity)
+    : func_(func)
+    , arity_(arity)
+  {
+  }
+
+  RUBY_METHOD_FUNC func() const { return func_; }
+  int arity() const { return arity_; }
+
+private:
+  RUBY_METHOD_FUNC func_;
+  int arity_;
+};
+
+} // detail
+
+} // Rice
+
+#endif // Rice__detail__Wrapped_Function__hpp_

data/rice/detail/check_ruby_type.cpp

@@ -0,0 +1,21 @@
+#include "check_ruby_type.hpp"
+#include "../Exception.hpp"
+
+void Rice::detail::
+check_ruby_type(
+    VALUE value,
+    VALUE klass,
+    bool include_super
+    )
+{ 
+  if( !rb_obj_is_kind_of(value, klass) ||
+     (!include_super && rb_obj_class(value) != klass))
+  {
+    throw Exception(
+        rb_eTypeError,
+        "wrong argument type %s (expected %s)",
+        STR2CSTR(protect(rb_mod_name, rb_obj_class(value))),
+        STR2CSTR(protect(rb_mod_name, klass)));
+  }                                 
+}
+

data/rice/detail/check_ruby_type.hpp

@@ -0,0 +1,23 @@
+#ifndef Rice__detail__check_ruby_type__hpp_
+#define Rice__detail__check_ruby_type__hpp_
+
+#include "ruby.hpp"
+
+namespace Rice
+{
+
+namespace detail
+{
+
+// Throws an exception if the given object is not of type klass.
+void check_ruby_type(
+    VALUE value,
+    VALUE klass,
+    bool include_super);
+
+} // namespace detail
+
+} // namespace Rice
+
+#endif // Rice__detail__check_ruby_type__hpp_
+

data/rice/detail/creation_funcs.hpp

@@ -0,0 +1,45 @@
+#ifndef Rice__detail__creation_funcs__hpp_
+#define Rice__detail__creation_funcs__hpp_
+
+namespace Rice
+{
+
+class Class;
+
+namespace detail
+{
+
+//! Ruby 1.6.x doesn't have rb_define_alloc_func, but Ruby 1.8 will.
+//! It's the "new" way to allocate objects.  This function will just
+//! define a singleton new method on older versions of Ruby, and will
+//! call rb_define_alloc_func() on newer versions of Ruby.
+void define_alloc_func(
+    Class const & klass,
+    RUBY_VALUE_FUNC allocate_func);
+
+//! Like define_alloc_func, but allows the user to define an
+//! "initialize" method too.
+template<typename Initialize_Func_T>
+void define_creation_funcs(
+    Class const & klass,
+    RUBY_VALUE_FUNC allocate_func,
+    Initialize_Func_T initialize_func);
+
+//! This is just the opposite of define_alloc_func.  It can be
+//! used to create a class that cannot be instantiated by the user.
+void undef_alloc_func(
+    Class const & klass);
+
+//! This is just the opposite of define_creation_func.  It can be
+//! used to create a class that cannot be instantiated by the user.
+void undef_creation_funcs(
+    Class const & klass);
+
+} // namespace detail
+
+} // namespace Rice
+
+#include "creation_funcs.ipp"
+
+#endif // Rice__detail__creation_funcs__hpp_
+

data/rice/detail/creation_funcs.ipp

@@ -0,0 +1,62 @@
+#ifndef Rice__detail__creation_funcs__ipp_
+#define Rice__detail__creation_funcs__ipp_
+
+namespace Rice
+{
+
+namespace detail
+{
+
+namespace
+{
+  inline VALUE ruby_16_new(int argc, VALUE * argv, VALUE klass)
+  {
+    VALUE obj = rb_funcall(klass, rb_intern("allocate"), 0);
+    rb_obj_call_init(obj, argc, argv);
+    return obj;
+  }
+}
+
+inline void define_alloc_func(
+    Class const & klass,
+    RUBY_VALUE_FUNC allocate_func)
+{
+#if RUBY_VERSION_CODE < 170
+  klass.define_singleton_method("allocate", allocate_func);
+  klass.define_singleton_method("new", ruby_16_new);
+#else
+  rb_define_alloc_func(klass, allocate_func);
+#endif
+}
+
+template<typename Initialize_Func_T>
+inline void define_creation_funcs(
+    Class const & klass,
+    RUBY_VALUE_FUNC allocate_func,
+    Initialize_Func_T initialize_func)
+{
+  define_alloc_func(klass, allocate_func);
+  klass.define_method("initialize", initialize_func);
+}
+
+inline void undef_alloc_func(Class const & klass)
+{
+#if RUBY_VERSION_CODE >= 170
+  rb_undef_alloc_func(klass);
+#else
+  rb_undef_method(CLASS_OF(klass), "new");
+#endif
+}
+
+inline void undef_creation_funcs(Class const & klass)
+{
+  undef_alloc_func(klass);
+  rb_undef_method(klass, "initialize");
+}
+
+} // namespace detail
+
+} // namespace Rice
+
+#endif // Rice__detail__creation_funcs__ipp_
+