rice2 2.2.0

data/rice/Data_Object_defn.hpp

@@ -0,0 +1,138 @@
+#ifndef Rice__Data_Object_defn__hpp_
+#define Rice__Data_Object_defn__hpp_
+
+#include "Object_defn.hpp"
+#include "Data_Type_fwd.hpp"
+#include "ruby_mark.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
+{
+
+template<typename T>
+struct Default_Mark_Function
+{
+  typedef void (*Ruby_Data_Func)(T * obj);
+  static const Ruby_Data_Func mark;
+};
+
+template<typename T>
+struct Default_Free_Function
+{
+  static void free(T * obj) { delete obj; }
+};
+
+
+//! 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 analogous 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 = Default_Mark_Function<T>::mark,
+      Ruby_Data_Func free_func = Default_Free_Function<T>::free);
+
+  //! Unwrap a Ruby object.
+  /*! This constructor is analogous 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 analogous 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
+
+#endif // Rice__Data_Object_defn__hpp_
+

data/rice/Data_Type.cpp

@@ -0,0 +1,54 @@
+#include "Data_Type.hpp"
+
+Rice::Data_Type_Base::Casters * Rice::Data_Type_Base::casters_ = 0;
+
+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()
+{
+}
+
+Rice::Data_Type_Base::Casters &
+Rice::Data_Type_Base::
+casters()
+{
+  // Initialize the casters_ if it is null
+  if (!casters_)
+  {
+    // First, see if it has been previously registered with the
+    // interpreter (possibly by another extension)
+    Class object(rb_cObject);
+    Object casters_object(object.attr_get("__rice_casters__"));
+
+    if (casters_object.is_nil())
+    {
+      // If it is unset, then set it for the first time
+      Data_Object<Casters> casters(
+          new Casters,
+          rb_cObject);
+      object.iv_set("__rice_casters__", casters);
+      casters_ = casters.get();
+    }
+    else
+    {
+      // If it is set, then use the existing value
+      Data_Object<Casters> casters(
+          casters_object);
+      casters_ = casters.get();
+    }
+  }
+
+  return *casters_;
+}
+

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,365 @@
+#ifndef Rice__Data_Type__ipp_
+#define Rice__Data_Type__ipp_
+
+#include "Class.hpp"
+#include "String.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 "detail/demangle.hpp"
+
+#include <stdexcept>
+#include <typeinfo>
+
+template<typename T>
+VALUE Rice::Data_Type<T>::klass_ = Qnil;
+
+template<typename T>
+std_unique_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 += detail::demangle(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_)
+{
+  if(!is_bound())
+  {
+    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::Module
+Rice::Data_Type<T>::
+klass() {
+  if(is_bound())
+  {
+    return klass_;
+  }
+  else
+  {
+    std::string s;
+    s += detail::demangle(typeid(T *).name());
+    s += " is unbound";
+    throw std::runtime_error(s.c_str());
+  }
+}
+
+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 */,
+    Arguments* arguments)
+{
+  check_is_bound();
+
+  // Normal constructor pattern with new/initialize
+  rb_define_alloc_func(
+      static_cast<VALUE>(*this),
+      detail::default_allocation_func<T>);
+  this->define_method(
+      "initialize",
+      &Constructor_T::construct,
+      arguments
+      );
+
+  return *this;
+}
+
+template<typename T>
+template<typename Constructor_T>
+inline Rice::Data_Type<T> & Rice::Data_Type<T>::
+define_constructor(
+    Constructor_T constructor,
+    Arg const& arg)
+{
+  Arguments* args = new Arguments();
+  args->add(arg);
+  return define_constructor(constructor, args);
+}
+
+
+template<typename T>
+template<typename Director_T>
+inline Rice::Data_Type<T>& Rice::Data_Type<T>::
+define_director()
+{
+  Rice::Data_Type<Director_T>::template bind<T>(*this);
+  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();
+
+  if(klass.value() == klass_)
+  {
+    // Great, not converting to a base/derived type
+    Data_Type<T> data_klass;
+    Data_Object<T> obj(x, data_klass);
+    return obj.get();
+  }
+
+  Data_Type_Base::Casters::const_iterator it = Data_Type_Base::casters().begin();
+  Data_Type_Base::Casters::const_iterator end = Data_Type_Base::casters().end();
+   
+  // Finding the bound type that relates to the given klass is
+  // a two step process. We iterate over the list of known type casters,
+  // looking for:
+  //
+  // 1) casters that handle this direct type
+  // 2) casters that handle types that are ancestors of klass
+  //
+  // Step 2 allows us to handle the case where a Rice-wrapped class
+  // is subclassed in Ruby but then an instance of that class is passed
+  // back into C++ (say, in a Listener / callback construction)
+  //
+
+  VALUE ancestors = rb_mod_ancestors(klass.value());
+
+  long earliest = RARRAY_LEN(ancestors) + 1;
+
+  int index;
+  VALUE indexFound;
+  Data_Type_Base::Casters::const_iterator toUse = end;
+
+  for(; it != end; it++) {
+    // Do we match directly?
+    if(klass.value() == it->first) {
+      toUse = it;
+      break;
+    }
+
+    // Check for ancestors. Trick is, we need to find the lowest
+    // ancestor that does have a Caster to make sure that we're casting
+    // to the closest C++ type that the Ruby class is subclassing. 
+    // There might be multiple ancestors that are also wrapped in
+    // the extension, so find the earliest in the list and use that one.
+    indexFound = rb_funcall(ancestors, rb_intern("index"), 1, it->first);
+
+    if(indexFound != Qnil) {
+      index = NUM2INT(indexFound);
+
+      if(index < earliest) {
+        earliest = index;
+        toUse = it;
+      }
+    }
+  }
+  
+  if(toUse == end)
+  {
+    std::string s = "Class ";
+    s += klass.name().str();
+    s += " is not registered/bound in Rice";
+    throw std::runtime_error(s);
+  }
+
+  detail::Abstract_Caster * caster = toUse->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 += detail::demangle(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);
+}
+
+template<typename From_T, typename To_T>
+inline void 
+Rice::define_implicit_cast()
+{
+  // As Rice currently expects only one entry into
+  // this list for a given klass VALUE, we need to get
+  // the current caster for From_T and insert in our
+  // new caster as the head of the caster list
+
+  Class from_class = Data_Type<From_T>::klass().value();
+  Class to_class = Data_Type<To_T>::klass().value();
+
+  detail::Abstract_Caster* from_caster = 
+    Data_Type<From_T>::caster_.release();
+
+  detail::Abstract_Caster* new_caster = 
+    new detail::Implicit_Caster<To_T, From_T>(from_caster, to_class);
+
+  // Insert our new caster into the list for the from class
+  Data_Type_Base::casters().erase(from_class);
+  Data_Type_Base::casters().insert(
+    std::make_pair(
+      from_class,
+      new_caster
+    )
+  );
+
+  // And make sure the from_class has direct access to the
+  // updated caster list
+  Data_Type<From_T>::caster_.reset(new_caster);
+}
+
+#endif // Rice__Data_Type__ipp_