rice 4.3.3 → 4.6.0

data/rice/Constructor.ipp

@@ -0,0 +1,79 @@
+namespace Rice
+{
+  template<typename T, typename...Arg_Ts>
+  class Constructor
+  {
+  public:
+    static constexpr std::size_t arity = sizeof...(Arg_Ts);
+
+    static constexpr bool isCopyConstructor()
+    {
+      if constexpr (arity == 1)
+      {
+        using Arg_Types = std::tuple<Arg_Ts...>;
+        using First_Arg_T = std::tuple_element_t<0, Arg_Types>;
+        return (arity == 1 &&
+                std::is_lvalue_reference_v<First_Arg_T> &&
+                std::is_same_v<T, detail::intrinsic_type<First_Arg_T>>);
+      }
+      else
+      {
+        return false;
+      }
+    }
+
+    static constexpr bool isMoveConstructor()
+    {
+      if constexpr (arity == 1)
+      {
+        using Arg_Types = std::tuple<Arg_Ts...>;
+        using First_Arg_T = std::tuple_element_t<0, Arg_Types>;
+        return (arity == 1 &&
+          std::is_rvalue_reference_v<First_Arg_T> &&
+          std::is_same_v<T, detail::intrinsic_type<First_Arg_T>>);
+      }
+      else
+      {
+        return false;
+      }
+    }
+
+    static void initialize(VALUE self, Arg_Ts...args)
+    {
+      // Call C++ constructor
+      T* data = new T(args...);
+      detail::wrapConstructed<T>(self, Data_Type<T>::ruby_data_type(), data, true);
+    }
+
+    static void initialize_copy(VALUE self, const T& other)
+    {
+      // Call C++ copy constructor
+      T* data = new T(other);
+      detail::wrapConstructed<T>(self, Data_Type<T>::ruby_data_type(), data, true);
+    }
+
+  };
+
+  //! Special-case Constructor used when defining Directors.
+  template<typename T, typename...Arg_Ts>
+  class Constructor<T, Object, Arg_Ts...>
+  {
+    public:
+      static constexpr bool isCopyConstructor()
+      {
+        return false;
+      }
+
+      static constexpr bool isMoveConstructor()
+      {
+        return false;
+      }
+
+      static void initialize(Object self, Arg_Ts...args)
+      {
+        // Call C++ constructor
+        T* data = new T(self, args...);
+        detail::wrapConstructed<T>(self.value(), Data_Type<T>::ruby_data_type(), data, true);
+      }
+  };
+}

data/rice/Data_Object.hpp

@@ -1,8 +1,78 @@
 #ifndef Rice__Data_Object__hpp_
 #define Rice__Data_Object__hpp_
 
-#include "Data_Object_defn.hpp"
-#include "Data_Object.ipp"
+/*! \file
+ *  \brief Provides a helper class for wrapping and unwrapping C++
+ *  objects as Ruby objects.
+ */
 
-#endif // Rice__Data_Object__hpp_
+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
+  {
+    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>);
+    static_assert(!std::is_void_v<T>);
+
+  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 isOwner Should the Data_Object take ownership of the object?
+     *  \param klass the Ruby class to use for the newly created Ruby
+     *  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());
+    Data_Object(T&& obj, Class klass = Data_Type<T>::klass());
+    Data_Object(const 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);
+    Data_Object(VALUE 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__hpp_