rice 4.3.2 → 4.5.0

data/rice/Data_Object.ipp

@@ -1,7 +1,3 @@
-#ifndef Rice__Data_Object__ipp_
-#define Rice__Data_Object__ipp_
-
-#include "Data_Type_defn.hpp"
 
 #include <algorithm>
 
@@ -22,6 +18,13 @@ namespace Rice
     this->set_value(value);
   }
 
+  template<typename T>
+  inline Data_Object<T>::Data_Object(const T& data, bool isOwner, Class klass)
+  {
+    VALUE value = detail::wrap(klass, Data_Type<T>::ruby_data_type(), data, isOwner);
+    this->set_value(value);
+  }
+
   template<typename T>
   inline Data_Object<T>::Data_Object(T* data, bool isOwner, Class klass)
   {
@@ -65,16 +68,16 @@ namespace Rice
     }
     else
     {
-      return detail::unwrap<T>(this->value(), Data_Type<T>::ruby_data_type());
+      return detail::unwrap<T>(this->value(), Data_Type<T>::ruby_data_type(), false);
     }
   }
 
   template<typename T>
-  inline T* Data_Object<T>::from_ruby(VALUE value)
+  inline T* Data_Object<T>::from_ruby(VALUE value, bool takeOwnership)
   {
     if (Data_Type<T>::is_descendant(value))
     {
-      return detail::unwrap<T>(value, Data_Type<T>::ruby_data_type());
+      return detail::unwrap<T>(value, Data_Type<T>::ruby_data_type(), takeOwnership);
     }
     else
     {
@@ -102,7 +105,7 @@ namespace Rice::detail
     VALUE convert(const T& data)
     {
       // Get the ruby typeinfo
-        std::pair<VALUE, rb_data_type_t*> rubyTypeInfo = detail::Registries::instance.types.figureType<T>(data);
+      std::pair<VALUE, rb_data_type_t*> rubyTypeInfo = detail::Registries::instance.types.figureType<T>(data);
 
       // We always take ownership of data passed by value (yes the parameter is T& but the template
       // matched <typename T> thus we have to tell wrap to copy the reference we are sending to it
@@ -236,6 +239,52 @@ namespace Rice::detail
     Return* returnInfo_ = nullptr;
   };
 
+  template <typename T>
+  class To_Ruby<T**>
+  {
+  public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
+
+    VALUE convert(T** data)
+    {
+      if (data)
+      {
+        // Note that T could be a pointer or reference to a base class while data is in fact a
+        // child class. Lookup the correct type so we return an instance of the correct Ruby class
+        std::pair<VALUE, rb_data_type_t*> rubyTypeInfo = detail::Registries::instance.types.figureType(**data);
+        bool isOwner = this->returnInfo_ && this->returnInfo_->isOwner();
+        return detail::wrap(rubyTypeInfo.first, rubyTypeInfo.second, data, isOwner);
+      }
+      else
+      {
+        return Qnil;
+      }
+    }
+
+    VALUE convert(const T** data)
+    {
+      if (data)
+      {
+        // Note that T could be a pointer or reference to a base class while data is in fact a
+        // child class. Lookup the correct type so we return an instance of the correct Ruby class
+        std::pair<VALUE, rb_data_type_t*> rubyTypeInfo = detail::Registries::instance.types.figureType(*data);
+        bool isOwner = this->returnInfo_ && this->returnInfo_->isOwner();
+        return detail::wrap(rubyTypeInfo.first, rubyTypeInfo.second, data, isOwner);
+      }
+      else
+      {
+        return Qnil;
+      }
+    }
+
+  private:
+    Return* returnInfo_ = nullptr;
+  };
+
   template<typename T>
   class To_Ruby<Data_Object<T>>
   {
@@ -258,23 +307,48 @@ namespace Rice::detail
     {
     }
     
-    bool is_convertible(VALUE value)
+    Convertible is_convertible(VALUE value)
     {
-      return rb_type(value) == RUBY_T_DATA &&
-        Data_Type<T>::is_descendant(value);
+      switch (rb_type(value))
+      {
+        case RUBY_T_DATA:
+          return Data_Type<T>::is_descendant(value) ? Convertible::Exact : Convertible::None;
+          break;
+        default:
+          return Convertible::None;
+      }
     }
 
     T convert(VALUE value)
     {
-      using Intrinsic_T = intrinsic_type<T>;
-
+      // This expression checks to see if T has an explicit copy constructor
+      // If it does then we have to call it directly. Not sure if this end ups
+      // with an extra copy or not?
+      // 
+      // std::is_constructible_v<T, T> && !std::is_convertible_v<T, T>
       if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
       {
-        return this->arg_->template defaultValue<Intrinsic_T>();
+        if constexpr (std::is_constructible_v<T, T> && !std::is_convertible_v<T, T>)
+        {
+          return T(this->arg_->template defaultValue<T>());
+        }
+        else
+        {
+          return this->arg_->template defaultValue<T>();
+        }
       }
       else
       {
-        return *Data_Object<Intrinsic_T>::from_ruby(value);
+        if constexpr (std::is_constructible_v<T, T> && !std::is_convertible_v<T, T>)
+        {
+          using Intrinsic_T = intrinsic_type<T>;
+          return T(*Data_Object<Intrinsic_T>::from_ruby(value, this->arg_ && this->arg_->isOwner()));
+        }
+        else
+        {
+          using Intrinsic_T = intrinsic_type<T>;
+          return *Data_Object<Intrinsic_T>::from_ruby(value, this->arg_ && this->arg_->isOwner());
+        }
       }
     }
 
@@ -294,10 +368,16 @@ namespace Rice::detail
     {
     }
 
-    bool is_convertible(VALUE value)
+    Convertible is_convertible(VALUE value)
     {
-      return rb_type(value) == RUBY_T_DATA &&
-        Data_Type<T>::is_descendant(value);
+      switch (rb_type(value))
+      {
+        case RUBY_T_DATA:
+          return Data_Type<T>::is_descendant(value) ? Convertible::Exact : Convertible::None;
+          break;
+        default:
+          return Convertible::None;
+      }
     }
 
     T& convert(VALUE value)
@@ -310,7 +390,7 @@ namespace Rice::detail
       }
       else
       {
-        return *Data_Object<Intrinsic_T>::from_ruby(value);
+        return *Data_Object<Intrinsic_T>::from_ruby(value, this->arg_ && this->arg_->isOwner());
       }
     }
 
@@ -319,30 +399,154 @@ namespace Rice::detail
   };
 
   template<typename T>
-  class From_Ruby<T*>
+  class From_Ruby<T&&>
   {
     static_assert(!std::is_fundamental_v<intrinsic_type<T>>,
                   "Data_Object cannot be used with fundamental types");
   public:
-    bool is_convertible(VALUE value)
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg * arg) : arg_(arg)
     {
-      return rb_type(value) == RUBY_T_DATA &&
-        Data_Type<T>::is_descendant(value);
     }
 
-    T* convert(VALUE value)
+    Convertible is_convertible(VALUE value)
+    {
+      switch (rb_type(value))
+      {
+      case RUBY_T_DATA:
+        return Data_Type<T>::is_descendant(value) ? Convertible::Exact : Convertible::None;
+        break;
+      default:
+        return Convertible::None;
+      }
+    }
+
+    T&& convert(VALUE value)
     {
       using Intrinsic_T = intrinsic_type<T>;
 
-      if (value == Qnil)
+      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
       {
-        return nullptr;
+        return std::move(this->arg_->template defaultValue<Intrinsic_T>());
       }
       else
       {
-        return Data_Object<Intrinsic_T>::from_ruby(value);
+        return std::move(*Data_Object<Intrinsic_T>::from_ruby(value, this->arg_ && this->arg_->isOwner()));
+      }
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+  };
+
+  // Helper class to convert a Ruby array of T to a C++ array of T (this happens when an API take T* as parameter
+  // along with a second size parameter)
+  template<typename T>
+  class ArrayHelper
+  {
+  public:
+    using Intrinsic_T = intrinsic_type<T>;
+
+    T* convert(VALUE value)
+    {
+      this->vector_ = Array(value).to_vector<T>();
+      return this->vector_.data();
+    }
+
+  private:
+    std::vector<Intrinsic_T> vector_;
+  };
+
+  // 99% of the time a T* represents a wrapped C++ object that we want to call methods on. However, T* 
+  // could also be a pointer to an array of T objects, so T[]. OpenCV for example has API calls like this.
+  //
+  // Therefore this From_Ruby implementation supports both uses cases which complicates the code. The problem
+  // is for T[] to compile, a class needs to be constructible, destructible and not abstract. A further wrinkle
+  // is if T has an explicit copy-constructor then that requires additional special handling in the code
+  // (see From_Ruby<T>). Whether this extra complication is worth it is debatable, but it does mean that 
+  // a Ruby array can be passed to any C++ API that takes a * including fundamental types (unsigned char)
+  // and class types (T).
+  //
+  // Note that the From_Ruby<T[]> specialization never matches a parameter defined in function as T[] - the C++ 
+  // compiler always picks T* instead. Not sure why...
+  template<typename T>
+  class From_Ruby<T*>
+  {
+    static_assert(!std::is_fundamental_v<intrinsic_type<T>>,
+                  "Data_Object cannot be used with fundamental types");
+    using Intrinsic_T = intrinsic_type<T>;
+
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    ~From_Ruby()
+    {
+      if constexpr (std::is_destructible_v<Intrinsic_T>)
+      {
+        delete this->arrayHelper_;
+      }
+    }
+
+    Convertible is_convertible(VALUE value)
+    {
+      switch (rb_type(value))
+      {
+        case RUBY_T_DATA:
+          return Data_Type<T>::is_descendant(value) ? Convertible::Exact : Convertible::None;
+          break;
+        case RUBY_T_NIL:
+          return Convertible::Exact;
+          break;
+        case RUBY_T_ARRAY:
+          return Convertible::Exact;
+          break;
+        default:
+          return Convertible::None;
       }
     }
+
+    T* convert(VALUE value)
+    {
+      switch (rb_type(value))
+      {
+        case RUBY_T_DATA:
+        {
+          return Data_Object<Intrinsic_T>::from_ruby(value, this->arg_ && this->arg_->isOwner());
+          break;
+        }
+        case RUBY_T_NIL:
+        {
+          return nullptr;
+          break;
+        }
+        case RUBY_T_ARRAY:
+        {
+          if constexpr (std::is_copy_constructible_v<Intrinsic_T> && std::is_destructible_v<Intrinsic_T> && !std::is_abstract_v<Intrinsic_T>)
+          {
+            if (this->arrayHelper_ == nullptr)
+            {
+              this->arrayHelper_ = new ArrayHelper<T>();
+            }
+            return this->arrayHelper_->convert(value);
+            break;
+          }
+          // Will fall through to the type exception if we get here
+        }
+        default:
+        {
+          throw create_type_exception<Intrinsic_T>(value);
+        }
+      }
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+    ArrayHelper<T>* arrayHelper_ = nullptr;
   };
 
   template<typename T>
@@ -351,10 +555,22 @@ namespace Rice::detail
     static_assert(!std::is_fundamental_v<intrinsic_type<T>>,
                   "Data_Object cannot be used with fundamental types");
   public:
-    bool is_convertible(VALUE value)
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    Convertible is_convertible(VALUE value)
     {
-      return rb_type(value) == RUBY_T_DATA &&
-             Data_Type<T>::is_descendant(value);
+      switch (rb_type(value))
+      {
+        case RUBY_T_DATA:
+          return Data_Type<T>::is_descendant(value) ? Convertible::Exact : Convertible::None;
+          break;
+        default:
+          return Convertible::None;
+      }
     }
 
     T* convert(VALUE value)
@@ -367,9 +583,74 @@ namespace Rice::detail
       }
       else
       {
-        return Data_Object<Intrinsic_T>::from_ruby(value);
+        return Data_Object<Intrinsic_T>::from_ruby(value, this->arg_ && this->arg_->isOwner());
+      }
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+  };
+
+  template<typename T>
+  class From_Ruby<T**>
+  {
+    static_assert(!std::is_fundamental_v<intrinsic_type<T>>,
+                  "Data_Object cannot be used with fundamental types");
+    using Intrinsic_T = intrinsic_type<T>;
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    Convertible is_convertible(VALUE value)
+    {
+      switch (rb_type(value))
+      {
+        case RUBY_T_DATA:
+          return Data_Type<T>::is_descendant(value) ? Convertible::Exact : Convertible::None;
+          break;
+        case RUBY_T_NIL:
+          return Convertible::Exact;
+          break;
+        case RUBY_T_ARRAY:
+          return Convertible::Exact;
+          break;
+        default:
+          return Convertible::None;
       }
     }
+
+    T** convert(VALUE value)
+    {
+      switch (rb_type(value))
+      {
+        case RUBY_T_DATA:
+        {
+          return detail::unwrap<Intrinsic_T*>(value, Data_Type<T>::ruby_data_type(), false);
+          break;
+        }
+        case RUBY_T_NIL:
+        {
+          return nullptr;
+          break;
+        }
+        case RUBY_T_ARRAY:
+        {
+          this->vector_ = Array(value).to_vector<Intrinsic_T*>();
+          return this->vector_.data();
+        }
+        default:
+        {
+          throw create_type_exception<Intrinsic_T>(value);
+        }
+      }
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+    std::vector<Intrinsic_T*> vector_;
   };
 
   template<typename T>
@@ -378,10 +659,21 @@ namespace Rice::detail
     static_assert(!std::is_fundamental_v<intrinsic_type<T>>,
                   "Data_Object cannot be used with fundamental types");
   public:
+    Convertible is_convertible(VALUE value)
+    {
+      switch (rb_type(value))
+      {
+        case RUBY_T_DATA:
+          return Data_Type<T>::is_descendant(value) ? Convertible::Exact : Convertible::None;
+          break;
+        default:
+          return Convertible::None;
+        }
+    }
+
     static Data_Object<T> convert(VALUE value)
     {
       return Data_Object<T>(value);
     }
   };
 }
-#endif // Rice__Data_Object__ipp_

data/rice/Data_Type.hpp

@@ -1,7 +1,219 @@
 #ifndef Rice__Data_Type__hpp_
 #define Rice__Data_Type__hpp_
 
-#include "Data_Type_defn.hpp"
-#include "Data_Type.ipp"
+#include <set>
 
-#endif // Rice__Data_Type__hpp_
+namespace Rice
+{
+  //! A mechanism for binding ruby types to C++ types.
+  /*! This class binds run-time types (Ruby VALUEs) to compile-time types
+   *  (C++ types).  The binding can occur only once.
+   */
+  template<typename T>
+  class Data_Type : public Class
+  {
+    static_assert(std::is_same_v<detail::intrinsic_type<T>, T>);
+
+  public:
+    using type = T;
+
+    //! Default constructor which does not bind.
+    /*! No member functions must be called on this Data_Type except bind,
+     *  until the type is bound.
+     */
+    Data_Type();
+
+    //! Constructor which takes a Module.
+    /*! Binds the type to the given VALUE according to the rules given
+     *  above.
+     *  \param klass the module to which to bind.
+     */
+    Data_Type(Module const & v);
+
+    //! Return the Ruby class.
+    /*! \return the ruby class to which the type is bound.
+     */
+    static Class klass();
+
+    //! Return the Ruby data type.
+    static rb_data_type_t* ruby_data_type();
+
+    //! Assignment operator which takes a Module
+    /*! \param klass must be the class to which this data type is already
+     *  bound.
+     *  \return *this
+     */
+    virtual Data_Type & operator=(Module const & klass);
+
+    /*! Creates a singleton method allocate and an instance method called
+     *  initialize which together create a new instance of the class.  The
+     *  allocate method allocates memory for the object reference and the
+     *  initialize method constructs the object.
+     *  \param constructor an object that has a static member function
+     *  construct() that constructs a new instance of T and sets the object's data
+     *  member to point to the new instance.  A helper class Constructor
+     *  is provided that does precisely this.
+     *  \param args a list of Arg instance used to define default parameters (optional)
+     *
+     *  For example:
+     *  \code
+     *    define_class<Foo>("Foo")
+     *      .define_constructor(Constructor<Foo>());
+     *  \endcode
+     */
+    template<typename Constructor_T, typename...Rice_Arg_Ts>
+    Data_Type<T>& define_constructor(Constructor_T constructor, Rice_Arg_Ts const& ...args);
+
+    /*! Runs a function that should define this Data_Types methods and attributes.
+     *  This is useful when creating classes from a C++ class template.
+     *
+     *  \param builder A function that addes methods/attributes to this class
+     *
+     *  For example:
+     *  \code
+     *    void builder(Data_Type<Matrix<T, R, C>>& klass)
+     *    {
+     *      klass.define_method...
+     *      return klass;
+     *    }
+     *
+     *    define_class<<Matrix<T, R, C>>>("Matrix")
+     *      .build(&builder);
+     *
+     *  \endcode
+     */
+    template<typename Func_T>
+    Data_Type<T>& define(Func_T func);
+
+    //! Register a Director class for this class.
+    /*! For any class that uses Rice::Director to enable polymorphism
+     *  across the languages, you need to register that director proxy
+     *  class with this method. Not doing so will cause the resulting 
+     *  library to die at run time when it tries to convert the base
+     *  type into the Director proxy type.
+     *
+     *  This method takes no methodInfo, just needs the type of the
+     *  Director proxy class.
+     *
+     *  For example:
+     *  \code
+     *    class FooDirector : public Foo, public Rice::Director {
+     *      ...
+     *    };
+     *
+     *    define_class<Foo>("Foo")
+     *      .define_director<FooDirector>()
+     *      .define_constructor(Constructor<FooDirector, Rice::Object>());
+     *  \endcode
+     */
+    template<typename Director_T>
+    Data_Type<T>& define_director();
+
+    //! Determine if the type is bound.
+    /*! \return true if the object is bound, false otherwise.
+     */
+    static bool is_bound();
+    static void check_is_bound();
+    static bool is_defined(Object parent, const std::string& name);
+
+    // This is only for testing - DO NOT USE!!!
+    static void unbind();
+
+    static bool is_descendant(VALUE value);
+  
+    //! Define an iterator.
+    /*! Essentially this is a conversion from a C++-style begin/end
+     *  iterator to a Ruby-style \#each iterator.
+     *  \param begin a member function pointer to a function that returns
+     *  an iterator to the beginning of the sequence.
+     *  \param end a member function pointer to a function that returns an
+     *  iterator to the end of the sequence.
+     *  \param name the name of the iterator.
+     *  \return *this
+     */
+
+    template<typename Iterator_Func_T>
+    Data_Type<T>& define_iterator(Iterator_Func_T begin, Iterator_Func_T end, std::string name = "each");
+
+    template <typename Attribute_T>
+    Data_Type<T>& define_attr(std::string name, Attribute_T attribute, AttrAccess access = AttrAccess::ReadWrite);
+  
+    template <typename Attribute_T>
+    Data_Type<T>& define_singleton_attr(std::string name, Attribute_T attribute, AttrAccess access = AttrAccess::ReadWrite);
+
+    #include "cpp_api/shared_methods.hpp"
+  protected:
+    //! Bind a Data_Type to a VALUE.
+    /*! Throws an exception if the Data_Type is already bound to a
+     *  different class.  Any existing instances of the Data_Type will be
+     *  bound after this function returns.
+     *  \param klass the ruby type to which to bind.
+     *  \return *this
+     */
+    template <typename Base_T = void>
+    static Data_Type<T> bind(const Module& klass);
+
+    template<typename T_, typename Base_T>
+    friend Rice::Data_Type<T_> define_class_under(Object parent, Identifier id, Class superKlass);
+
+    template<typename T_, typename Base_T>
+    friend Rice::Data_Type<T_> define_class_under(Object parent, char const * name);
+
+    template<typename T_, typename Base_T>
+    friend Rice::Data_Type<T_> define_class(char const * name);
+
+    template<bool IsMethod, typename Function_T>
+    void wrap_native_call(VALUE klass, std::string name, Function_T&& function, MethodInfo* methodInfo);
+
+  private:
+    template<typename T_>
+    friend class Data_Type;
+
+    static inline VALUE klass_ = Qnil;
+
+    // Typed Data support
+    static inline rb_data_type_t* rb_data_type_ = nullptr;
+
+    // Track unbound instances (ie, declared variables of type Data_Type<T>
+    // before define_class is called)
+    static inline std::set<Data_Type<T>*>unbound_instances_;
+  };
+
+  //! Define a new data class in the namespace given by module.
+  /*! This override allows you to specify a Ruby class as the base class versus a 
+   *  wrapped C++ class. This functionality is rarely needed - but is essential for
+   *  creating new custom Exception classes where the Ruby superclass should be
+   *  rb_eStandard
+   *  \param T the C++ type of the wrapped class.
+   *  \param module the Module in which to define the class.
+   *  \param name the name of the new class.
+   *  \param superKlass the Ruby super class.
+   *  \return the new class.
+   */
+  template<typename T, typename Base_T = void>
+  Data_Type<T> define_class_under(Object parent, Identifier id, Class superKlass = rb_cObject);
+
+  //! Define a new data class in the namespace given by module.
+  /*! By default the class will inherit from Ruby's rb_cObject. This
+   *  can be overriden via the Base_T template parameter. Note that
+   *  Base_T must already have been registered.
+   *  \param T the C++ type of the wrapped class.
+   *  \param module the the Module in which to define the class.
+   *  \return the new class.
+   */
+  template<typename T, typename Base_T = void>
+  Data_Type<T> define_class_under(Object parent, char const* name);
+
+  //! Define a new data class in the default namespace.
+  /*! By default the class will inherit from Ruby's rb_cObject. This
+   *  can be overriden via the Base_T template parameter. Note that
+   *  Base_T must already have been registered.
+   *  \param T the C++ type of the wrapped class.
+   *  \param module the the Module in which to define the class.
+   *  \return the new class.
+   */
+  template<typename T, typename Base_T = void>
+  Data_Type<T> define_class(char const* name);
+}
+
+#endif // Rice__Data_Type__hpp_