rice 2.1.2 → 4.0.1

data/rice/Data_Object.ipp

@@ -1,133 +1,260 @@
 #ifndef Rice__Data_Object__ipp_
 #define Rice__Data_Object__ipp_
 
-#include "detail/check_ruby_type.hpp"
-#include "protect.hpp"
+#include "Data_Type_defn.hpp"
 
 #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
 {
+  template <typename T>
+  Exception create_type_exception(VALUE value)
+  {
+    return Exception(rb_eTypeError, "Wrong argument type. Expected: %s. Received: %s.",
+      detail::protect(rb_class2name, Data_Type<T>::klass().value()),
+      detail::protect(rb_obj_classname, value));
+  }
 
-namespace detail
-{
+  template<typename T>
+  inline Data_Object<T>::Data_Object(T& data, bool isOwner, Class klass)
+  {
+    VALUE value = detail::wrap(klass, Data_Type<T>::rb_type(), data, isOwner);
+    this->set_value(value);
+  }
 
-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 Data_Object<T>::Data_Object(T* data, bool isOwner, Class klass)
+  {
+    VALUE value = detail::wrap(klass, Data_Type<T>::rb_type(), data, isOwner);
+    this->set_value(value);
+  }
 
-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 Data_Object<T>::Data_Object(Object value) : Object(value)
+  {
+    Data_Type<T> klass;
+    check_ruby_type(value);
+  }
 
-template<typename T>
-inline VALUE data_get_struct(VALUE value, T * * obj)
-{
-  Data_Get_Struct(value, T, *obj);
-  return Qnil;
+  template<typename T>
+  template<typename U>
+  inline Data_Object<T>::Data_Object(Object value) : Object(value)
+  {
+    check_ruby_type(value);
+  }
+
+  template<typename T>
+  inline void Data_Object<T>::check_ruby_type(VALUE value)
+  {
+    if (rb_obj_is_kind_of(value, Data_Type<T>::klass()) == Qfalse)
+    {
+      throw create_type_exception<T>(value);
+    }
+  }
+
+  template<typename T>
+  inline T& Data_Object<T>::operator*() const
+  {
+    return *this->get();
+  }
+
+  template<typename T>
+  inline T* Data_Object<T>::operator->() const
+  {
+    return this->get();
+  }
+
+  template<typename T>
+  inline T* Data_Object<T>::get() const
+  {
+    if (this->value() == Qnil)
+    {
+      return nullptr;
+    }
+    else
+    {
+      return detail::unwrap<T>(this->value(), Data_Type<T>::rb_type());
+    }
+  }
+
+  template<typename T>
+  inline T* Data_Object<T>::from_ruby(VALUE value)
+  {
+    if (Data_Type<T>::is_descendant(value))
+    {
+      return detail::unwrap<T>(value, Data_Type<T>::rb_type());
+    }
+    else
+    {
+      throw create_type_exception<T>(value);
+    }
+  }
 }
 
-template<typename T>
-inline T * unwrap(VALUE value)
+namespace Rice::detail
 {
-  T * obj;
-  Rice::protect(data_get_struct<T>, value, &obj);
-  return obj;
-}
+  template<typename T>
+  class To_Ruby
+  {
+  public:
+    VALUE convert(T& data)
+    {
+      // Get the ruby typeinfo
+      std::pair<VALUE, rb_data_type_t*> rubyTypeInfo = detail::TypeRegistry::figureType<T>(data);
 
-} // namespace detail
+      // 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
+      return detail::wrap(rubyTypeInfo.first, rubyTypeInfo.second, data, true);
+    }
+  };
 
-} // namespace Rice
+  template <typename T>
+  class To_Ruby<T&>
+  {
+  public:
+    To_Ruby() = default;
 
-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)
-{
-}
+    explicit To_Ruby(Return * returnInfo) : returnInfo_(returnInfo)
+    {
+    }
 
-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);
-}
+    VALUE convert(T& 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::TypeRegistry::figureType<T>(data);
 
-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);
-}
+      bool isOwner = this->returnInfo_ && this->returnInfo_->isOwner();
+      return detail::wrap(rubyTypeInfo.first, rubyTypeInfo.second, data, isOwner);
+    }
 
-template<typename T>
-inline Rice::Data_Object<T>::
-Data_Object(Data_Object const & other)
-  : Object(other.value())
-  , obj_(other.obj_)
-{
-}
+  private:
+    Return* returnInfo_ = nullptr;
+  };
 
-template<typename T>
-template<typename U>
-inline void Rice::Data_Object<T>::
-swap(Data_Object<U> & ref)
-{
-  std::swap(obj_, ref.obj_);
-  Object::swap(ref);
-}
+  template <typename T>
+  class To_Ruby<T*>
+  {
+  public:
+    To_Ruby() = default;
 
-template<typename T>
-inline void Rice::Data_Object<T>::
-check_cpp_type(Data_Type<T> const & /* klass */)
-{
-}
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
 
-template<typename T>
-Rice::Object Rice::detail::to_ruby_<Rice::Data_Object<T> >::
-convert(Rice::Data_Object<T> const & x)
-{
-  return x;
-}
+    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::TypeRegistry::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>>
+  {
+  public:
+    VALUE convert(const Object& x)
+    {
+      return x.value();
+    }
+  };
+
+  template <typename T>
+  class From_Ruby
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg * arg) : arg_(arg)
+    {
+    }
+    
+    T convert(VALUE value)
+    {
+      using Intrinsic_T = intrinsic_type<T>;
 
-#endif // Rice__Data_Object__ipp_
+      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
+      {
+        return this->arg_->template defaultValue<Intrinsic_T>();
+      }
+      else
+      {
+        return *Data_Object<Intrinsic_T>::from_ruby(value);
+      }
+    }
 
+  private:
+    Arg* arg_ = nullptr;
+  };
+
+  template<typename T>
+  class From_Ruby<T&>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg * arg) : arg_(arg)
+    {
+    }
+
+    T& convert(VALUE value)
+    {
+      using Intrinsic_T = intrinsic_type<T>;
+
+      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
+      {
+        return this->arg_->template defaultValue<Intrinsic_T>();
+      }
+      else
+      {
+        return *Data_Object<Intrinsic_T>::from_ruby(value);
+      }
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+  };
+
+  template<typename T>
+  class From_Ruby<T*>
+  {
+  public:
+    T* convert(VALUE value)
+    {
+      using Intrinsic_T = intrinsic_type<T>;
+
+      if (value == Qnil)
+      {
+        return nullptr;
+      }
+      else
+      {
+        return Data_Object<Intrinsic_T>::from_ruby(value);
+      }
+    }
+  };
+
+  template<typename T>
+  class From_Ruby<Data_Object<T>>
+  {
+  public:
+    static Data_Object<T> convert(VALUE value)
+    {
+      return Data_Object<T>(value);
+    }
+  };
+}
+#endif // Rice__Data_Object__ipp_

data/rice/Data_Object_defn.hpp

@@ -1,11 +1,11 @@
 #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 <optional>
+
 #include "detail/to_ruby.hpp"
 #include "detail/ruby.hpp"
+#include "cpp_api/Object_defn.hpp"
 
 /*! \file
  *  \brief Provides a helper class for wrapping and unwrapping C++
@@ -14,124 +14,84 @@
 
 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.
+  //! 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
    */
-  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> >
+  class Data_Object : public Object
   {
-    static Rice::Object convert(Data_Object<T> const & x);
+    static_assert(!std::is_pointer_v<T>);
+    static_assert(!std::is_reference_v<T>);
+    static_assert(!std::is_const_v<T>);
+    static_assert(!std::is_volatile_v<T>);
+
+  public:
+    static T* from_ruby(VALUE value);
+    static std::optional<T> implicit_from_ruby(VALUE value);
+
+  public:
+    //! 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, bool isOwner = false, Class klass = Data_Type<T>::klass());
+    Data_Object(T& obj, bool isOwner = false, Class klass = Data_Type<T>::klass());
+
+    //! 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);
+
+    T& operator*() const; //!< Return a reference to obj_
+    T* operator->() const; //!< Return a pointer to obj_
+    T* get() const;        //!< Return a pointer to obj_
+
+  private:
+    static void check_ruby_type(VALUE value);
   };
-}
-
 } // namespace Rice
 
 #endif // Rice__Data_Object_defn__hpp_