rice 1.0.2 → 1.1.0

data/rice/detail/Exception_Handler.hpp

@@ -1,118 +1,8 @@
 #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
+#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/check_ruby_type.cpp

@@ -11,11 +11,17 @@ check_ruby_type(
   if( !rb_obj_is_kind_of(value, klass) ||
      (!include_super && rb_obj_class(value) != klass))
   {
+    // Not sure why this stuff can't be chained
+    VALUE gotV = protect(rb_mod_name, rb_obj_class(value));
+    char* got = StringValuePtr(gotV);
+    VALUE exptV = protect(rb_mod_name, klass);
+    char* expected = StringValuePtr(exptV);
+
     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)));
+        got, expected
+      );
   }                                 
 }
 

data/rice/detail/creation_funcs.ipp

@@ -21,7 +21,7 @@ inline void define_alloc_func(
     Class const & klass,
     RUBY_VALUE_FUNC allocate_func)
 {
-#if RUBY_VERSION_CODE < 170
+#if RICE__RUBY_VERSION_CODE < 170
   klass.define_singleton_method("allocate", allocate_func);
   klass.define_singleton_method("new", ruby_16_new);
 #else
@@ -41,7 +41,7 @@ inline void define_creation_funcs(
 
 inline void undef_alloc_func(Class const & klass)
 {
-#if RUBY_VERSION_CODE >= 170
+#if RICE__RUBY_VERSION_CODE >= 170
   rb_undef_alloc_func(klass);
 #else
   rb_undef_method(CLASS_OF(klass), "new");

data/rice/detail/define_method_and_auto_wrap.hpp

@@ -2,6 +2,8 @@
 #define Rice__detail__define_method_and_auto_wrap__hpp_
 
 #include "ruby.hpp"
+#include "../Data_Object.hpp"
+#include "../Identifier.hpp"
 
 namespace Rice
 {
@@ -14,9 +16,9 @@ class Exception_Handler;
 template<typename Fun_T>
 void define_method_and_auto_wrap(
     VALUE klass,
-    char const * name,
+    Identifier name,
     Fun_T function,
-    Exception_Handler const * handler = 0);
+    Data_Object<Exception_Handler> handler);
 
 } // detail
 

data/rice/detail/define_method_and_auto_wrap.ipp

@@ -3,18 +3,27 @@
 
 #include "wrap_function.hpp"
 #include "method_data.hpp"
-#include "Exception_Handler.hpp"
+#include "Exception_Handler_defn.hpp"
+#include "../protect.hpp"
 
 template<typename Fun_T>
 void Rice::detail::
 define_method_and_auto_wrap(
     VALUE klass,
-    char const * name,
+    Identifier name,
     Fun_T function,
-    Exception_Handler const * handler)
+    Data_Object<Exception_Handler> handler)
 {
-  Wrapped_Function * f(wrap_function(function, handler));
-  define_method_with_data(klass, name, f->func(), f->arity(), f);
+  Data_Object<Wrapped_Function> f(
+      wrap_function(function, handler),
+      rb_cObject);
+  Rice::protect(
+      define_method_with_data,
+      klass,
+      name.id(),
+      f->func(),
+      f->arity(),
+      f);
 }
 
 #endif // Rice__detail__define_method_and_auto_wrap__ipp_