rice 1.1.0 → 1.2.0

data/extconf.rb

@@ -19,4 +19,12 @@ 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}"
+other_opts = ""
+env = ""
+
+if RUBY_PLATFORM =~ /darwin10/
+  other_opts = "--disable-dependency-tracking"
+  env = "ARCHFLAGS='-arch x86_64'"
+end
+
+system "#{env} ./configure --with-ruby=#{with_ruby} --prefix=#{prefix_dir} #{other_opts}"

data/rice/Arg.hpp

@@ -0,0 +1,8 @@
+#ifndef Rice__Arg__hpp_
+#define Rice__Arg__hpp_
+
+#include "Arg_impl.hpp"
+#include "detail/Arguments.hpp"
+#include "Arg_operators.hpp"
+
+#endif // Rice__Arg__hpp_

data/rice/Arg_impl.hpp

@@ -0,0 +1,124 @@
+#ifndef Rice__Arg_Impl_hpp_
+#define Rice__Arg_Impl_hpp_
+
+namespace Rice {
+
+  //! Helper for defining default arguments of a method
+  /*! This class exposes the ability to define the default values of a
+   *  wrapped method. Inspired by how Boost.Python handles keyword and
+   *  default arguments, the syntax is simple:
+   *
+   *    define_method(
+   *      "method",
+   *      &method,
+   *      (Arg("arg1"), Arg("arg2") = 3, Arg("arg3") = true)
+   *    );
+   *
+   *  which means "for method &method, it takes 3 arguments
+   *  [arg1, arg2, arg3]. Of these arguments, arg2's default is 3
+   *  and arg3's default is true.
+   *
+   *  It may be required to explicitly cast the type of the default
+   *  value to prevent compilation errors.
+   */
+  class Arg
+  {
+    public:
+      //! Initialize a new Arg with the name of the argument
+      /*! We require the name of the argument because 1) it makes code
+       *  easier to read and 2) hopefully Ruby gets keyword arguments
+       *  in the future and this means Rice will be ready for it.
+       */
+      Arg(const char* name)
+        : name_(name)
+        , defaultValue(0)
+      {}
+
+      //! Copy Constructor
+      Arg(const Arg& other)
+        : name_(other.name()),
+          defaultValue(other.defaultValue ? other.defaultValue->clone() : 0)
+      {}
+
+      virtual ~Arg()
+      {
+      }
+
+      //! Set the default value for this Arg
+      /*! Set the default value for this argument.
+       *  If this isn't called on this Arg, then this
+       *  Arg is required in the method call.
+       *
+       *  \param val the value to store as default
+       */
+      template<typename Arg_Type>
+      Arg& operator=(Arg_Type const& val)
+      {
+        defaultValue = new type<Arg_Type>(val);
+        return *this;
+      }
+
+      //! Check if this Arg has a default value associated with it
+      bool hasDefaultValue() const {
+        return defaultValue != 0;
+      }
+
+      //! Return the default value associated with this Arg
+      /*! \return the type saved to this Arg
+       */
+      template<typename Arg_Type>
+      Arg_Type getDefaultValue() const
+      {
+        return static_cast< type<Arg_Type>* >(defaultValue)->held;
+      }
+
+      //! Get the name of this Arg
+      const char* name() const
+      {
+        return name_;
+      }
+
+    private:
+
+      //! Name of the argument
+      const char* name_;
+
+      /**
+       * The following is a stripped down version of
+       * Boost.Any.
+       */
+
+      class type_base
+      {
+        public:
+          virtual ~type_base() {}
+          virtual type_base* clone() const = 0;
+      };
+
+      template<typename Type>
+      class type : public type_base
+      {
+        public:
+          type(Type value)
+            :held(value)
+          {}
+
+          virtual ~type() { }
+
+          virtual type_base* clone() const
+          {
+            return new type(held);
+          }
+
+          Type held;
+      };
+
+    public:
+
+      //! Our saved default value
+      type_base* defaultValue;
+  };
+
+}
+
+#endif // Rice__Arg_Impl_hpp_

data/rice/Arg_operators.cpp

@@ -0,0 +1,21 @@
+#include "Arg_impl.hpp"
+#include "detail/Arguments.hpp"
+#include "Arg_operators.hpp"
+
+namespace Rice {
+
+  Arguments* operator,(const Arg& arg1, const Arg& arg2)
+  {
+    Arguments* a = new Arguments();
+    a->add(arg1);
+    a->add(arg2);
+    return a;
+  }
+
+  Arguments* operator,(Arguments* arguments, const Arg& arg)
+  {
+    arguments->add(arg);
+    return arguments;
+  }
+
+}

data/rice/Arg_operators.hpp

@@ -0,0 +1,19 @@
+#ifndef Rice__Arg_Operators_hpp_
+#define Rice__Arg_Operators_hpp_
+
+namespace Rice
+{
+
+  //! Build the list of Arg objects into an Arguments object
+  /*! Take a list of Arg objects and build up a single Argument
+   *  object used later in method dispatch
+   */
+  Arguments* operator,(const Arg& arg1, const Arg& arg2);
+
+  /*! @see operator,(Arg, Arg)
+   */
+  Arguments* operator,(Arguments* arguments, const Arg& arg);
+
+}
+
+#endif // Rice__Arg_Operators_hpp_

data/rice/Constructor.hpp

@@ -181,6 +181,156 @@ public:
   }
 };
 
+template<typename T>
+class Constructor<T, Object, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void>
+{
+public:
+  static void construct(Object self)
+  {
+    DATA_PTR(self.value()) = new T(self);
+  }
+};
+
+template<typename T, typename Arg1_T>
+class Constructor<T, Object, Arg1_T, void, void, void, void, void, void, void, void, void, void, void, void, void, void>
+{
+public:
+  static void construct(Object self, Arg1_T arg1)
+  {
+    DATA_PTR(self.value()) = new T(self, arg1);
+  }
+};
+
+template<typename T, typename Arg1_T, typename Arg2_T>
+class Constructor<T, Object, Arg1_T, Arg2_T, void, void, void, void, void, void, void, void, void, void, void, void, void>
+{
+public:
+  static void construct(Object self, Arg1_T arg1, Arg2_T arg2)
+  {
+    DATA_PTR(self.value()) = new T(self, arg1, arg2);
+  }
+};
+
+template<typename T, typename Arg1_T, typename Arg2_T, typename Arg3_T>
+class Constructor<T, Object, Arg1_T, Arg2_T, Arg3_T, void, void, void, void, void, void, void, void, void, void, void, void>
+{
+public:
+  static void construct(Object self, Arg1_T arg1, Arg2_T arg2, Arg3_T arg3)
+  {
+    DATA_PTR(self.value()) = new T(self, arg1, arg2, arg3);
+  }
+};
+
+template<typename T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T>
+class Constructor<T, Object, Arg1_T, Arg2_T, Arg3_T, Arg4_T, void, void, void, void, void, void, void, void, void, void, void>
+{
+public:
+  static void construct(Object self, Arg1_T arg1, Arg2_T arg2, Arg3_T arg3, Arg4_T arg4)
+  {
+    DATA_PTR(self.value()) = new T(self, arg1, arg2, arg3, arg4);
+  }
+};
+
+template<typename T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T>
+class Constructor<T, Object, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, void, void, void, void, void, void, void, void, void, void>
+{
+public:
+  static void construct(Object self, Arg1_T arg1, Arg2_T arg2, Arg3_T arg3, Arg4_T arg4, Arg5_T arg5)
+  {
+    DATA_PTR(self.value()) = new T(self, arg1, arg2, arg3, arg4, arg5);
+  }
+};
+
+template<typename T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T>
+class Constructor<T, Object, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, void, void, void, void, void, void, void, void, void>
+{
+public:
+  static void construct(Object self, Arg1_T arg1, Arg2_T arg2, Arg3_T arg3, Arg4_T arg4, Arg5_T arg5, Arg6_T arg6)
+  {
+    DATA_PTR(self.value()) = new T(self, arg1, arg2, arg3, arg4, arg5, arg6);
+  }
+};
+
+template<typename T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T>
+class Constructor<T, Object, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, void, void, void, void, void, void, void, void>
+{
+public:
+  static void construct(Object self, Arg1_T arg1, Arg2_T arg2, Arg3_T arg3, Arg4_T arg4, Arg5_T arg5, Arg6_T arg6, Arg7_T arg7)
+  {
+    DATA_PTR(self.value()) = new T(self, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
+  }
+};
+
+template<typename T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T>
+class Constructor<T, Object, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, void, void, void, void, void, void, void>
+{
+public:
+  static void construct(Object self, Arg1_T arg1, Arg2_T arg2, Arg3_T arg3, Arg4_T arg4, Arg5_T arg5, Arg6_T arg6, Arg7_T arg7, Arg8_T arg8)
+  {
+    DATA_PTR(self.value()) = new T(self, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+  }
+};
+
+template<typename T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T>
+class Constructor<T, Object, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, void, void, void, void, void, void>
+{
+public:
+  static void construct(Object self, Arg1_T arg1, Arg2_T arg2, Arg3_T arg3, Arg4_T arg4, Arg5_T arg5, Arg6_T arg6, Arg7_T arg7, Arg8_T arg8, Arg9_T arg9)
+  {
+    DATA_PTR(self.value()) = new T(self, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+  }
+};
+
+template<typename T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T>
+class Constructor<T, Object, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, void, void, void, void, void>
+{
+public:
+  static void construct(Object self, Arg1_T arg1, Arg2_T arg2, Arg3_T arg3, Arg4_T arg4, Arg5_T arg5, Arg6_T arg6, Arg7_T arg7, Arg8_T arg8, Arg9_T arg9, Arg10_T arg10)
+  {
+    DATA_PTR(self.value()) = new T(self, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
+  }
+};
+
+template<typename T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T>
+class Constructor<T, Object, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, void, void, void, void>
+{
+public:
+  static void construct(Object self, Arg1_T arg1, Arg2_T arg2, Arg3_T arg3, Arg4_T arg4, Arg5_T arg5, Arg6_T arg6, Arg7_T arg7, Arg8_T arg8, Arg9_T arg9, Arg10_T arg10, Arg11_T arg11)
+  {
+    DATA_PTR(self.value()) = new T(self, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
+  }
+};
+
+template<typename T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T>
+class Constructor<T, Object, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, void, void, void>
+{
+public:
+  static void construct(Object self, Arg1_T arg1, Arg2_T arg2, Arg3_T arg3, Arg4_T arg4, Arg5_T arg5, Arg6_T arg6, Arg7_T arg7, Arg8_T arg8, Arg9_T arg9, Arg10_T arg10, Arg11_T arg11, Arg12_T arg12)
+  {
+    DATA_PTR(self.value()) = new T(self, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
+  }
+};
+
+template<typename T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T, typename Arg13_T>
+class Constructor<T, Object, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T, void, void>
+{
+public:
+  static void construct(Object self, Arg1_T arg1, Arg2_T arg2, Arg3_T arg3, Arg4_T arg4, Arg5_T arg5, Arg6_T arg6, Arg7_T arg7, Arg8_T arg8, Arg9_T arg9, Arg10_T arg10, Arg11_T arg11, Arg12_T arg12, Arg13_T arg13)
+  {
+    DATA_PTR(self.value()) = new T(self, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
+  }
+};
+
+template<typename T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T, typename Arg13_T, typename Arg14_T>
+class Constructor<T, Object, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T, Arg14_T, void>
+{
+public:
+  static void construct(Object self, Arg1_T arg1, Arg2_T arg2, Arg3_T arg3, Arg4_T arg4, Arg5_T arg5, Arg6_T arg6, Arg7_T arg7, Arg8_T arg8, Arg9_T arg9, Arg10_T arg10, Arg11_T arg11, Arg12_T arg12, Arg13_T arg13, Arg14_T arg14)
+  {
+    DATA_PTR(self.value()) = new T(self, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
+  }
+};
+
 
 } // namespace Rice
 

data/rice/Data_Type.ipp

@@ -126,7 +126,7 @@ define_constructor(
   check_is_bound();
 
   // Normal constructor pattern with new/initialize
-  detail::define_alloc_func(
+  rb_define_alloc_func(
       static_cast<VALUE>(*this),
       detail::default_allocation_func<T>);
   define_method("initialize", &Constructor_T::construct);
@@ -151,17 +151,62 @@ from_ruby(Object x)
     return obj.get();
   }
 
-  Data_Type_Base::Casters::const_iterator it(
-      Data_Type_Base::casters_.find(klass));
-  if(it == Data_Type_Base::casters_.end())
+  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());
+
+  int 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 = "Derived class ";
+    std::string s = "Class ";
     s += klass.name().str();
     s += " is not registered/bound in Rice";
     throw std::runtime_error(s);
   }
 
-  detail::Abstract_Caster * caster = it->second;
+  detail::Abstract_Caster * caster = toUse->second;
   if(caster)
   {
     T * result = static_cast<T *>(caster->cast_to_base(v, klass_));

data/rice/Director.cpp

@@ -0,0 +1,19 @@
+#include "Director.hpp"
+
+#include "detail/env.hpp"
+
+namespace Rice {
+
+  Director::Director(Object self) {
+    self_ = self;
+  }
+
+  bool Director::callIsFromRuby(const char* methodName) const {
+    return (getSelf().value() == ruby_frame->self) && ( rb_id2name(ruby_frame->orig_func) != methodName );
+  }
+
+  void Director::raisePureVirtual() const {
+    rb_raise(rb_eNotImpError, "Cannot call super() into a pure-virtual C++ method");
+  }
+
+}

data/rice/Director.hpp

@@ -0,0 +1,47 @@
+#ifndef Rice__Director__hpp_
+#define Rice__Director__hpp_
+
+#include "Object.hpp"
+
+namespace Rice {
+
+  /**
+   * A Director works exactly as a SWIG %director works (thus the name).
+   * You use this class to help build proxy classes so that polymorphism
+   * works from C++ into Ruby.
+   */
+  class Director 
+  {
+    public:
+      //! Construct new Director. Needs the Ruby object so that the 
+      //  proxy class can call methods on that object.
+      Director(Object self);
+
+      virtual ~Director() { }
+
+      //! Is the current method call path coming from Ruby?
+      /*! This method allows one to choose the call chain according
+       *  to the direction of the execution path. We need to do
+       *  this to prevent infinite loops where super() calls could
+       *  inadvertantly call methods back in Ruby
+       */
+      bool callIsFromRuby(const char* methodName) const;
+
+      //! Raise a ruby exception when a call comes through for a pure virtual method
+      /*! If a Ruby script calls 'super' on a method that's otherwise a pure virtual
+       *  method, use this method to throw an exception in this case. 
+       */
+      void raisePureVirtual() const;
+
+      //! Get the Ruby object linked to this C++ instance
+      Object getSelf() const { return self_; }
+
+    private:
+
+      // Save the Ruby object related to the instance of this class
+      Object self_;
+
+  };
+}
+
+#endif // Rice__Director__hpp_