rice 1.0.2 → 1.1.0

data/configure.ac

@@ -1,4 +1,4 @@
-AC_INIT(rice, 1.0)
+AC_INIT(rice, 1.1)
 AC_CONFIG_SRCDIR(rice)
 AM_INIT_AUTOMAKE
 
@@ -40,8 +40,12 @@ DX_INIT_DOXYGEN(rice, Doxyfile, doc)
 RICE_SAMPLES="enum map inheritance"
 AC_SUBST(RICE_SAMPLES)
 
+RICE_ROOT=`pwd`
+AC_SUBST(RICE_ROOT)
+
 AC_CONFIG_FILES(Makefile rice/Makefile test/Makefile sample/Makefile
-                ruby/Makefile ruby/lib/Makefile ruby/lib/mkmf-rice.rb)
+                ruby/Makefile ruby/lib/Makefile ruby/lib/mkmf-rice.rb
+                rice/detail/ruby_version_code.hpp)
 AC_OUTPUT
 
 dnl Work around a bug in older versions of Rubygems

data/doxygen.ac

@@ -78,7 +78,7 @@ AC_DEFUN([DX_REQUIRE_PROG], [
 AC_PATH_TOOL([$1], [$2])
 if test "$DX_FLAG_[]DX_CURRENT_FEATURE$$1" = 1; then
     AC_MSG_WARN([$2 not found - will not DX_CURRENT_DESCRIPTION])
-    AC_SUBST([DX_FLAG_[]DX_CURRENT_FEATURE], 0)
+    AC_SUBST([DX_FLAG_]DX_CURRENT_FEATURE, 0)
 fi
 ])
 
@@ -101,7 +101,7 @@ test "$DX_FLAG_$1" = "$2" \
 # ----------------------------------------------------------
 # Turn off the DX_CURRENT_FEATURE if the required feature is off.
 AC_DEFUN([DX_CLEAR_DEPEND], [
-test "$DX_FLAG_$1" = "$2" || AC_SUBST([DX_FLAG_[]DX_CURRENT_FEATURE], 0)
+test "$DX_FLAG_$1" = "$2" || AC_SUBST([DX_FLAG_]DX_CURRENT_FEATURE, 0)
 ])
 
 # DX_FEATURE_ARG(FEATURE, DESCRIPTION,

data/extconf.rb

@@ -0,0 +1,22 @@
+# To allow Rice to be installed on non-system installs of Ruby (say the user has
+# 1.8.7 and 1.9.0 installed), the rice gem uses the extconf version of deployment
+# rather than configure. This file will get the appropriate values from CONFIG
+# for the Ruby that this library is being installed into and generate
+# the proper arguments to ./configure.
+#
+# With this, installing on any of the Ruby versions installed on a machine is as
+# easy as /path/to/the/gem install rice.
+#
+# This isn't actually an extconf.rb file, all it needs to do is create a Makefile
+# for gem to continue 'make'-ing. It needs to be named 'extconf.rb' to fit Rubygem's
+# expectations
+
+require 'rbconfig'
+require 'rubygems'
+require 'ruby/lib/version.rb'
+
+gem_name = "rice-#{Rice::VERSION}"
+prefix_dir = File.join(Gem.default_dir, "gems", gem_name, "ruby", "lib")
+with_ruby = File.join(Config::CONFIG["bindir"], Config::CONFIG["RUBY_INSTALL_NAME"])
+
+system "./configure --with-ruby=#{with_ruby} --prefix=#{prefix_dir}"

data/post-autoconf.rb

@@ -1,4 +1,4 @@
-require 'ftools'
+require 'fileutils'
 require 'find'
 
 def process(file)
@@ -10,7 +10,7 @@ def process(file)
       end
     end
   end
-  File.mv("#{file}.pp", "#{file}")
+  FileUtils.mv("#{file}.pp", "#{file}")
 end
 
 process("configure") do |out, line|
@@ -19,4 +19,4 @@ process("configure") do |out, line|
   line.gsub!(/([^"'])(\$am_aux_dir)/, '\1\"\2\"')
   out.puts line
 end
-File.chmod(0700, "configure")
+FileUtils.chmod(0700, "configure")

data/post-automake.rb

@@ -1,4 +1,4 @@
-require 'ftools'
+require 'fileutils'
 require 'find'
 
 def process(file)
@@ -10,7 +10,7 @@ def process(file)
       end
     end
   end
-  File.mv("#{file}.pp", "#{file}")
+  FileUtils.mv("#{file}.pp", "#{file}")
 end
 
 Find.find(".") do |file|

data/rice/Array.ipp

@@ -46,13 +46,14 @@ Array(T const (& a)[n])
 inline size_t Rice::Array::
 size() const
 {
-  return (*this)->len;
+  return RARRAY_LEN(this->value());
 }
 
 inline Rice::Object Rice::Array::
 operator[](ptrdiff_t index) const
 {
-  return (*this)->ptr[position_of(index)];
+  VALUE * ptr = RARRAY_PTR(this->value());
+  return ptr[position_of(index)];
 }
 
 inline Rice::Array::Proxy Rice::Array::
@@ -90,7 +91,7 @@ shift()
 inline VALUE * Rice::Array::
 to_c_array()
 {
-  return (*this)->ptr;
+  return RARRAY_PTR(this->value());
 }
 
 inline size_t Rice::Array::
@@ -116,13 +117,13 @@ Proxy(Array array, size_t index)
 inline Rice::Array::Proxy::
 operator Rice::Object() const
 {
-  return array_->ptr[index_];
+  return RARRAY_PTR(array_.value())[index_];
 }
 
 inline VALUE Rice::Array::Proxy::
 value() const
 {
-  return array_->ptr[index_];
+  return RARRAY_PTR(array_.value())[index_];
 }
 
 template<typename T>
@@ -130,7 +131,7 @@ Rice::Object Rice::Array::Proxy::
 operator=(T const & value)
 {
   Object o = to_ruby(value);
-  array_->ptr[index_] = o.value();
+  RARRAY_PTR(array_.value())[index_] = o.value();
   return o;
 }
 

data/rice/Critical_Guard.hpp

@@ -1,6 +1,10 @@
 #ifndef Rice__ruby_Critical_Guard__hpp_
 #define Rice__ruby_Critical_Guard__hpp_
 
+#include "detail/ruby_version_code.hpp"
+
+#if RICE__RUBY_VERSION_CODE < 190
+
 namespace Rice
 {
 
@@ -28,6 +32,8 @@ public:
 
 }
 
+#endif
+
 #include "Critical_Guard.ipp"
 
 #endif // Rice__ruby_Critical_Guard__hpp_

data/rice/Critical_Guard.ipp

@@ -1,6 +1,10 @@
 #ifndef Rice__ruby_Critical_Guard__ipp_
 #define Rice__ruby_Critical_Guard__ipp_
 
+#include "detail/ruby_version_code.hpp"
+
+#if RICE__RUBY_VERSION_CODE < 190
+
 #include "detail/ruby.hpp"
 #include "detail/rubysig.hpp"
 
@@ -16,5 +20,7 @@ inline Rice::Critical_Guard::
   rb_thread_critical = 0;
 }
 
+#endif
+
 #endif // Rice__ruby_Critical_Guard__ipp_
 

data/rice/Data_Object.hpp

@@ -1,126 +1,7 @@
 #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_defn.hpp"
 #include "Data_Object.ipp"
 
 #endif // Rice__Data_Object__hpp_

data/rice/Data_Object.ipp

@@ -6,6 +6,10 @@
 
 #include <algorithm>
 
+template<typename T>
+const typename Rice::Default_Mark_Function<T>::Ruby_Data_Func
+Rice::Default_Mark_Function<T>::mark = ruby_mark<T>;
+
 namespace Rice
 {
 
@@ -109,7 +113,7 @@ inline void Rice::Data_Object<T>::
 swap(Data_Object<U> & ref)
 {
   std::swap(obj_, ref.obj_);
-  Object::swap(*this, ref);
+  Object::swap(ref);
 }
 
 template<typename T>

data/rice/Data_Object_defn.hpp

@@ -0,0 +1,132 @@
+#ifndef Rice__Data_Object_defn__hpp_
+#define Rice__Data_Object_defn__hpp_
+
+#include "Object_defn.hpp"
+#include "Data_Type_fwd.hpp"
+#include "Allocation_Strategies.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;
+};
+
+//! 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 = Default_Mark_Function<T>::mark,
+      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
+
+#endif // Rice__Data_Object_defn__hpp_
+