rice 1.0.0

data/rice/Critical_Guard.hpp

@@ -0,0 +1,34 @@
+#ifndef Rice__ruby_Critical_Guard__hpp_
+#define Rice__ruby_Critical_Guard__hpp_
+
+namespace Rice
+{
+
+//! A guard to prevent Ruby from switching threads.
+/*! Sets rb_thread_critical to 1 upon construction and back to its
+ *  original value upon destruction.  This prevents the scheduler from
+ *  changing threads.  This does not work on YARV, however, which has a
+ *  different threading model.
+ */
+class Critical_Guard
+{
+public:
+  //! Prevent ruby from switching threads.
+  /*! Prevent the ruby scheduler from switching threads by setting
+   *  rb_thread_critical to 1.
+   */
+  Critical_Guard();
+
+  //! Allow ruby to switch threads.
+  /*! Allow the ruby scheduler to switch threads by setting
+   *  rb_thread_critical to 0.
+   */
+  ~Critical_Guard();
+};
+
+}
+
+#include "Critical_Guard.ipp"
+
+#endif // Rice__ruby_Critical_Guard__hpp_
+

data/rice/Critical_Guard.ipp

@@ -0,0 +1,20 @@
+#ifndef Rice__ruby_Critical_Guard__ipp_
+#define Rice__ruby_Critical_Guard__ipp_
+
+#include "detail/ruby.hpp"
+#include "detail/rubysig.hpp"
+
+inline Rice::Critical_Guard::
+Critical_Guard()
+{
+  rb_thread_critical = 1;
+}
+
+inline Rice::Critical_Guard::
+~Critical_Guard()
+{
+  rb_thread_critical = 0;
+}
+
+#endif // Rice__ruby_Critical_Guard__ipp_
+

data/rice/Data_Object.hpp

@@ -0,0 +1,127 @@
+#ifndef Rice__Data_Object__hpp_
+#define Rice__Data_Object__hpp_
+
+#include "Object_defn.hpp"
+#include "Data_Type_fwd.hpp"
+#include "Allocation_Strategies.hpp"
+#include "detail/to_ruby.hpp"
+#include "detail/ruby.hpp"
+
+/*! \file
+ *  \brief Provides a helper class for wrapping and unwrapping C++
+ *  objects as Ruby objects.
+ */
+
+namespace Rice
+{
+
+//! A smartpointer-like wrapper for Ruby data objects.
+/*! A data object is a ruby object of type T_DATA, which is usually
+ *  created by using the Data_Wrap_Struct or Data_Make_Struct macro.
+ *  This class wraps creation of the data structure, providing a
+ *  type-safe object-oriented interface to the underlying C interface.
+ *  This class works in conjunction with the Data_Type class to ensure
+ *  type safety.
+ *
+ *  Example:
+ *  \code
+ *    class Foo { };
+ *    ...
+ *    Data_Type<Foo> rb_cFoo = define_class("Foo");
+ *    ...
+ *    // Wrap:
+ *    Data_Object<Foo> foo1(new Foo);
+ *
+ *    // Get value to return:
+ *    VALUE v = foo1.value()
+ *
+ *    // Unwrap:
+ *    Data_Object<Foo> foo2(v, rb_cFoo);
+ *  \endcode
+ */
+template<typename T>
+class Data_Object
+  : public Object
+{
+public:
+  //! A function that takes a T* and returns void.
+  typedef void (*Ruby_Data_Func)(T * obj);
+
+  //! Wrap a C++ object.
+  /*! This constructor is analgous to calling Data_Wrap_Struct.  Be
+   *  careful not to call this function more than once for the same
+   *  pointer (in general, it should only be called for newly
+   *  constructed objects that need to be managed by Ruby's garbage
+   *  collector).
+   *  \param obj the object to wrap.
+   *  \param klass the Ruby class to use for the newly created Ruby
+   *  object.
+   *  \param mark_func a function that gets called by the garbage
+   *  collector to mark the object's children.
+   *  \param free_func a function that gets called by the garbage
+   *  collector to free the object.
+   */
+  Data_Object(
+      T * obj,
+      VALUE klass = Data_Type<T>::klass(),
+      Ruby_Data_Func mark_func = 0,
+      Ruby_Data_Func free_func = Default_Allocation_Strategy<T>::free);
+
+  //! Unwrap a Ruby object.
+  /*! This constructor is analgous to calling Data_Get_Struct.  Uses
+   *  Data_Type<T>::klass as the class of the object.
+   *  \param value the Ruby object to unwrap.
+   */
+  Data_Object(
+      Object value);
+
+  //! Unwrap a Ruby object.
+  /*! This constructor is analgous to calling Data_Get_Struct.  Will
+   *  throw an exception if the class of the object differs from the
+   *  specified class.
+   *  \param value the Ruby object to unwrap.
+   *  \param klass the expected class of the object.
+   */
+  template<typename U>
+  Data_Object(
+      Object value,
+      Data_Type<U> const & klass = Data_Type<T>::klass());
+
+  //! Make a copy of a Data_Object
+  /*! \param other the Data_Object to copy.
+   */
+  Data_Object(Data_Object const & other);
+
+  T & operator*() const { return *obj_; } //!< Return a reference to obj_
+  T * operator->() const { return obj_; } //!< Return a pointer to obj_
+  T * get() const { return obj_; }        //!< Return a pointer to obj_
+
+  //! Swap with another data object of the same type
+  /*! \param ref the object with which to swap.
+   */
+  template<typename U>
+  void swap(Data_Object<U> & ref);
+
+private:
+  static void check_cpp_type(Data_Type<T> const & klass);
+
+private:
+  T * obj_;
+};
+
+namespace detail
+{
+  template<typename T>
+  struct to_ruby_<Data_Object<T> >
+  {
+    static Rice::Object convert(Data_Object<T> const & x);
+  };
+}
+
+} // namespace Rice
+
+#include "Object.hpp"
+#include "Data_Object.ipp"
+
+#endif // Rice__Data_Object__hpp_
+

data/rice/Data_Object.ipp

@@ -0,0 +1,129 @@
+#ifndef Rice__Data_Object__ipp_
+#define Rice__Data_Object__ipp_
+
+#include "detail/check_ruby_type.hpp"
+#include "protect.hpp"
+
+#include <algorithm>
+
+namespace Rice
+{
+
+namespace detail
+{
+
+inline VALUE data_wrap_struct(
+    VALUE klass,
+    RUBY_DATA_FUNC mark,
+    RUBY_DATA_FUNC free,
+    void * obj)
+{
+  return Data_Wrap_Struct(klass, mark, free, obj);
+}
+
+template<typename T>
+inline VALUE wrap(
+    VALUE klass,
+    typename Data_Object<T>::Ruby_Data_Func mark,
+    typename Data_Object<T>::Ruby_Data_Func free,
+    T * obj)
+{
+  // We cast to obj void* here before passing to Data_Wrap_Struct,
+  // becuase otherwise compilation will fail if obj is const.  It's safe
+  // to do this, because unwrap() will always add the const back when
+  // the object is unwrapped.
+  return Rice::protect(data_wrap_struct,
+      klass,
+      reinterpret_cast<RUBY_DATA_FUNC>(mark),
+      reinterpret_cast<RUBY_DATA_FUNC>(free),
+      (void *)obj);
+}
+
+template<typename T>
+inline VALUE data_get_struct(VALUE value, T * * obj)
+{
+  Data_Get_Struct(value, T, *obj);
+  return Qnil;
+}
+
+template<typename T>
+inline T * unwrap(VALUE value)
+{
+  T * obj;
+  Rice::protect(data_get_struct<T>, value, &obj);
+  return obj;
+}
+
+} // namespace detail
+
+} // namespace Rice
+
+template<typename T>
+inline Rice::Data_Object<T>::
+Data_Object(
+    T * obj,
+    VALUE klass,
+    Ruby_Data_Func mark_func,
+    Ruby_Data_Func free_func)
+  : Object(detail::wrap(klass, mark_func, free_func, obj))
+  , obj_(obj)
+{
+}
+
+template<typename T>
+inline Rice::Data_Object<T>::
+Data_Object(
+    Object value)
+  : Object(value)
+  , obj_(detail::unwrap<T>(value))
+{  
+  Data_Type<T> klass;
+  check_cpp_type(klass);
+  detail::check_ruby_type(value, klass, true);
+}
+
+template<typename T>
+template<typename U>
+inline Rice::Data_Object<T>::
+Data_Object(
+    Object value,
+    Data_Type<U> const & klass)
+  : Object(value)
+  , obj_(detail::unwrap<T>(value))
+{  
+  check_cpp_type(klass);
+  detail::check_ruby_type(value, klass, true);
+}
+
+template<typename T>
+inline Rice::Data_Object<T>::
+Data_Object(Data_Object const & other)
+  : Object(other.value())
+  , obj_(other.obj_)
+{
+}
+
+template<typename T>
+template<typename U>
+inline void Rice::Data_Object<T>::
+swap(Data_Object<U> & ref)
+{
+  std::swap(obj_, ref.obj_);
+  Object::swap(*this, ref);
+}
+
+template<typename T>
+inline void Rice::Data_Object<T>::
+check_cpp_type(Data_Type<T> const & /* klass */)
+{
+}
+
+template<typename T>
+Rice::Object Rice::detail::to_ruby_<Rice::Data_Object<T> >::
+convert(Rice::Data_Object<T> const & x)
+{
+  return x;
+}
+
+#endif // Rice__Data_Object__ipp_
+

data/rice/Data_Type.cpp

@@ -0,0 +1,21 @@
+#include "Data_Type.hpp"
+
+Rice::Data_Type_Base::Casters Rice::Data_Type_Base::casters_;
+
+Rice::Data_Type_Base::
+Data_Type_Base()
+  : Module_impl<Class, Data_Type_Base>()
+{
+}
+
+Rice::Data_Type_Base::
+Data_Type_Base(VALUE v)
+  : Module_impl<Class, Data_Type_Base>(v)
+{
+}
+
+Rice::Data_Type_Base::
+~Data_Type_Base()
+{
+}
+

data/rice/Data_Type.hpp

@@ -0,0 +1,8 @@
+#ifndef Rice__Data_Type__hpp_
+#define Rice__Data_Type__hpp_
+
+#include "Data_Type_defn.hpp"
+#include "Data_Type.ipp"
+
+#endif // Rice__Data_Type__hpp_
+

data/rice/Data_Type.ipp

@@ -0,0 +1,227 @@
+#ifndef Rice__Data_Type__ipp_
+#define Rice__Data_Type__ipp_
+
+#include "Class.hpp"
+#include "Data_Object.hpp"
+#include "detail/default_allocation_func.hpp"
+#include "detail/creation_funcs.hpp"
+#include "detail/method_data.hpp"
+#include "detail/Caster.hpp"
+
+#include <stdexcept>
+#include <typeinfo>
+
+template<typename T>
+VALUE Rice::Data_Type<T>::klass_ = Qnil;
+
+template<typename T>
+std::auto_ptr<Rice::detail::Abstract_Caster> Rice::Data_Type<T>::caster_;
+
+template<typename T>
+template<typename Base_T>
+inline Rice::Data_Type<T> Rice::Data_Type<T>::
+bind(Module const & klass)
+{
+  if(klass.value() == klass_)
+  {
+    return Data_Type<T>();
+  }
+
+  if(is_bound())
+  {
+    std::string s;
+    s = "Data type ";
+    s = typeid(T).name();
+    s += " is already bound to a different type";
+    throw std::runtime_error(s.c_str());
+  }
+
+  // TODO: Make sure base type is bound; throw an exception otherwise.
+  // We can't do this just yet, because we don't have a specialization
+  // for binding to void.
+  klass_ = klass;
+
+  // TODO: do we need to unregister when the program exits?  we have to
+  // be careful if we do, because the ruby interpreter might have
+  // already shut down.  The correct behavior is probably to register an
+  // exit proc with the interpreter, so the proc gets called before the
+  // GC shuts down.
+  rb_gc_register_address(&klass_);
+
+  for(typename Instances::iterator it = unbound_instances().begin(),
+      end = unbound_instances().end();
+      it != end;
+      unbound_instances().erase(it++))
+  {
+    (*it)->set_value(klass);
+  }
+
+  detail::Abstract_Caster * base_caster = Data_Type<Base_T>().caster();
+  caster_.reset(new detail::Caster<T, Base_T>(base_caster, klass));
+  Data_Type_Base::casters_.insert(std::make_pair(klass, caster_.get()));
+  return Data_Type<T>();
+}
+
+template<typename T>
+inline Rice::Data_Type<T>::
+Data_Type()
+  : Module_impl<Data_Type_Base, Data_Type<T> >(
+      klass_ == Qnil ? rb_cObject : klass_)
+{
+  unbound_instances().insert(this);
+}
+
+template<typename T>
+inline Rice::Data_Type<T>::
+Data_Type(Module const & klass)
+  : Module_impl<Data_Type_Base, Data_Type<T> >(
+      klass)
+{
+  this->bind<void>(klass);
+}
+
+template<typename T>
+inline Rice::Data_Type<T>::
+~Data_Type()
+{
+  unbound_instances().erase(this);
+}
+
+template<typename T>
+Rice::Data_Type<T> & Rice::Data_Type<T>::
+operator=(Module const & klass)
+{
+  this->bind<void>(klass);
+  return *this;
+}
+
+template<typename T>
+template<typename Constructor_T>
+inline Rice::Data_Type<T> & Rice::Data_Type<T>::
+define_constructor(
+    Constructor_T constructor)
+{
+  check_is_bound();
+
+  // Normal constructor pattern with new/initialize
+  detail::define_alloc_func(
+      static_cast<VALUE>(*this),
+      detail::default_allocation_func<T>);
+  define_method("initialize", &Constructor_T::construct);
+
+  return *this;
+}
+
+template<typename T>
+inline T * Rice::Data_Type<T>::
+from_ruby(Object x)
+{
+  check_is_bound();
+
+  void * v = DATA_PTR(x.value());
+  Class klass = x.class_of();
+  Data_Type_Base::Casters::const_iterator it(
+      Data_Type_Base::casters_.find(klass));
+  if(it == Data_Type_Base::casters_.end())
+  {
+    throw std::runtime_error("Derived type is unbound");
+  }
+
+  detail::Abstract_Caster * caster = it->second;
+  if(caster)
+  {
+    T * result = static_cast<T *>(caster->cast_to_base(v, klass_));
+    return result;
+  }
+  else
+  {
+    return static_cast<T *>(v);
+  }
+}
+
+template<typename T>
+inline bool Rice::Data_Type<T>::
+is_bound()
+{
+  return klass_ != Qnil;
+}
+
+template<typename T>
+inline Rice::detail::Abstract_Caster * Rice::Data_Type<T>::
+caster() const
+{
+  check_is_bound();
+  return caster_.get();
+}
+
+namespace Rice
+{
+
+template<>
+inline detail::Abstract_Caster * Data_Type<void>::
+caster() const
+{
+  return 0;
+}
+
+template<typename T>
+void Data_Type<T>::
+check_is_bound()
+{
+  if(!is_bound())
+  {
+    std::string s;
+    s = "Data type ";
+    s = typeid(T).name();
+    s += " is not bound";
+    throw std::runtime_error(s.c_str());
+  }
+}
+
+} // Rice
+
+template<typename T>
+inline Rice::Data_Type<T> Rice::
+define_class_under(
+    Object module,
+    char const * name)
+{
+  Class c(define_class_under(module, name, rb_cObject));
+  c.undef_creation_funcs();
+  return Data_Type<T>::template bind<void>(c);
+}
+
+template<typename T, typename Base_T>
+inline Rice::Data_Type<T> Rice::
+define_class_under(
+    Object module,
+    char const * name)
+{
+  Data_Type<Base_T> base_dt;
+  Class c(define_class_under(module, name, base_dt));
+  c.undef_creation_funcs();
+  return Data_Type<T>::template bind<Base_T>(c);
+}
+
+template<typename T>
+inline Rice::Data_Type<T> Rice::
+define_class(
+    char const * name)
+{
+  Class c(define_class(name, rb_cObject));
+  c.undef_creation_funcs();
+  return Data_Type<T>::template bind<void>(c);
+}
+
+template<typename T, typename Base_T>
+inline Rice::Data_Type<T> Rice::
+define_class(
+    char const * name)
+{
+  Data_Type<Base_T> base_dt;
+  Class c(define_class(name, base_dt));
+  c.undef_creation_funcs();
+  return Data_Type<T>::template bind<Base_T>(c);
+}
+
+#endif // Rice__Data_Type__ipp_