rice2 2.2.0

data/rice/detail/Caster.hpp

@@ -0,0 +1,103 @@
+#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
+      {
+        std::string s = "bad cast. No caster found for ";
+        s += type_.name().str();
+        throw std::runtime_error(s);
+      }
+    }
+  }
+
+private:
+  Abstract_Caster * base_caster_;
+  Module type_;
+};
+
+template<typename To_T, typename From_T>
+class Implicit_Caster
+  : public Abstract_Caster
+{
+public:
+  Implicit_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())
+    {
+      return new To_T( *static_cast<From_T*>(derived) );
+    }
+    else
+    {
+      if(base_caster_)
+      {
+        return base_caster_->cast_to_base(derived, type);
+      }
+      else
+      {
+        std::string s = "bad cast. No implicit caster found for ";
+        s += type_.name().str();
+        throw std::runtime_error(s);
+      }
+    }
+  }
+
+private:
+  Abstract_Caster * base_caster_;
+  Module type_;
+};
+
+
+
+} // detail
+
+} // Rice
+
+#endif //Rice__detail__Caster__hpp_

data/rice/detail/Exception_Handler.hpp

@@ -0,0 +1,8 @@
+#ifndef Rice__detail__Exception_Handler__hpp_
+#define Rice__detail__Exception_Handler__hpp_
+
+#include "Exception_Handler_defn.hpp"
+#include "Exception_Handler.ipp"
+
+#endif // Rice__detail__Exception_Handler__hpp_
+

data/rice/detail/Exception_Handler.ipp

@@ -0,0 +1,68 @@
+#include "../Data_Type_defn.hpp"
+
+inline
+Rice::detail::Exception_Handler::
+Exception_Handler(
+    Data_Object<Exception_Handler> next_exception_handler)
+  : next_exception_handler_(next_exception_handler)
+  , next_exception_handler_guard_(&next_exception_handler_)
+{
+}
+
+inline
+Rice::detail::Exception_Handler::
+~Exception_Handler()
+{
+}
+
+inline
+VALUE
+Rice::detail::Exception_Handler::
+call_next_exception_handler() const
+{
+  return next_exception_handler_->handle_exception();
+}
+
+inline Rice::detail::Default_Exception_Handler::
+Default_Exception_Handler()
+  : Exception_Handler(
+      Data_Object<Exception_Handler>(0, rb_cObject))
+{
+}
+
+inline
+VALUE
+Rice::detail::Default_Exception_Handler::
+handle_exception() const
+{
+  throw;
+}
+
+template <typename Exception_T, typename Functor_T>
+inline
+Rice::detail::Functor_Exception_Handler<Exception_T, Functor_T>::
+Functor_Exception_Handler(
+    Functor_T handler,
+    Data_Object<Exception_Handler> next_exception_handler)
+  : Exception_Handler(next_exception_handler)
+  , handler_(handler)
+{
+}
+
+template <typename Exception_T, typename Functor_T>
+inline
+VALUE
+Rice::detail::Functor_Exception_Handler<Exception_T, Functor_T>::
+handle_exception() const
+{
+  try
+  {
+    return call_next_exception_handler();
+  }
+  catch(Exception_T const & ex)
+  {
+    handler_(ex);
+    throw;
+  }
+}
+

data/rice/detail/Exception_Handler_defn.hpp

@@ -0,0 +1,96 @@
+#ifndef Rice__detail__Exception_Handler_defn__hpp_
+#define Rice__detail__Exception_Handler_defn__hpp_
+
+#include "ruby.h"
+#undef TYPE
+
+#include "Not_Copyable.hpp"
+#include "../Address_Registration_Guard_defn.hpp"
+#include "../Data_Object_defn.hpp"
+
+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 Rice::detail::Not_Copyable
+{
+public:
+  Exception_Handler(
+      Data_Object<Exception_Handler> next_exception_handler);
+
+  virtual ~Exception_Handler();
+
+  virtual VALUE handle_exception() const = 0;
+
+  VALUE call_next_exception_handler() const;
+
+private:
+  Data_Object<Exception_Handler> next_exception_handler_;
+  Address_Registration_Guard next_exception_handler_guard_;
+};
+
+// 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();
+
+  virtual VALUE handle_exception() const;
+};
+
+// 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,
+      Data_Object<Exception_Handler> next_exception_handler);
+
+private:
+  virtual VALUE handle_exception() const;
+
+private:
+  Functor_T handler_;
+};
+
+} // namespace detail
+
+} // namespace Rice
+
+#endif // Rice__detail__Exception_Handler_defn__hpp_
+

data/rice/detail/Iterator.hpp

@@ -0,0 +1,93 @@
+#ifndef Rice__detail__Iterator__hpp_
+#define Rice__detail__Iterator__hpp_
+
+#include "method_data.hpp"
+#include "ruby.hpp"
+#include "../protect.hpp"
+#include "../Data_Object.hpp"
+#include "../Identifier.hpp"
+
+namespace Rice
+{
+
+namespace detail
+{
+
+class Iterator
+{
+public:
+  virtual ~Iterator() { }
+
+  virtual VALUE call_impl(VALUE self) = 0;
+
+  static VALUE call(VALUE self)
+  {
+    VALUE data = (VALUE)method_data();
+    Data_Object<Iterator> iterator(
+        data,
+        Data_Type<Iterator>());
+    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>
+void define_iterator(
+    Module klass,
+    Identifier name,
+    Iterator_T (T::*begin)(),
+    Iterator_T (T::*end)())
+{
+  Data_Type<Iterator> iterator_klass;
+  Data_Object<Iterator> iterator(
+      new Iterator_Impl<T, Iterator_T>(
+          begin,
+          end,
+          Data_Type<T>(klass)),
+      iterator_klass);
+  define_method_with_data(
+      klass,
+      name,
+      (RUBY_METHOD_FUNC)iterator->call,
+      0,
+      iterator);
+}
+
+} // namespace detail
+
+} // namespace Rice
+
+#endif // Rice__detail__Iterator__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/cfp.hpp

@@ -0,0 +1,24 @@
+#ifndef Rice__detail__cfp__hpp_
+#define Rice__detail__cfp__hpp_
+
+#include "ruby.hpp"
+
+namespace Rice
+{
+
+namespace detail
+{
+
+VALUE * cfp();
+
+VALUE & cfp_data_memo_node_and_pc(VALUE * cfp);
+VALUE & cfp_self(VALUE * cfp);
+VALUE & cfp_method_class(VALUE * cfp);
+
+} // detail
+
+} // Rice
+
+#include "cfp.ipp"
+
+#endif // Rice__detail__cfp__hpp_