rice 3.0.0 → 4.0.3

data/rice/detail/TypeRegistry.hpp

@@ -0,0 +1,50 @@
+#ifndef Rice__TypeRegistry__hpp_
+#define Rice__TypeRegistry__hpp_
+
+#include <optional>
+#include <string>
+#include <typeindex>
+#include <typeinfo>
+#include <unordered_map>
+
+#include "ruby.hpp"
+
+/* The type registery keeps track of all C++ types wrapped by Rice. When a native function returns 
+   an instance of a class/struct we look up its type to verity that it has been registered. 
+   
+   We have to do this to support C++ inheritance. If a C++ function returns a pointer/reference
+   to an Abstract class, the actual returned object will be a Child class. However, all we know
+   from the C++ method signature is that it is an Absract class - thus the need for a registry.*/
+
+namespace Rice::detail
+{
+  class TypeRegistry
+  {
+  public:
+    template <typename T>
+    static void add();
+
+    template <typename T>
+    static void add(VALUE klass, rb_data_type_t* rbType);
+
+    template <typename T>
+    static void remove();
+
+    template <typename T>
+    static bool isDefined();
+
+    template <typename T>
+    static void verifyDefined();
+      
+    template <typename T>
+    static std::pair<VALUE, rb_data_type_t*> figureType(const T& object);
+
+  private:
+    static std::optional<std::pair<VALUE, rb_data_type_t*>> lookup(const std::type_info& typeInfo);
+    static inline std::unordered_map<std::type_index, std::pair<VALUE, rb_data_type_t*>> registry_{};
+  };
+}
+
+#include "TypeRegistry.ipp"
+
+#endif // Rice__TypeRegistry__hpp_

data/rice/detail/TypeRegistry.ipp

@@ -0,0 +1,106 @@
+#include <stdexcept>
+
+#include "ruby.hpp"
+#include "rice_traits.hpp"
+#include "Type.hpp"
+
+namespace Rice::detail
+{
+  template <typename T>
+  inline void TypeRegistry::add()
+  {
+    std::type_index key(typeid(T));
+    registry_[key] = std::pair(Qnil, nullptr);
+  }
+
+  template <typename T>
+  inline void TypeRegistry::add(VALUE klass, rb_data_type_t* rbType)
+  {
+    std::type_index key(typeid(T));
+    registry_[key] = std::pair(klass, rbType);
+  }
+
+  template <typename T>
+  inline void TypeRegistry::remove()
+  {
+    std::type_index key(typeid(T));
+    registry_.erase(key);
+  }
+
+  template <typename T>
+  inline bool TypeRegistry::isDefined()
+  {
+    std::type_index key(typeid(T));
+    auto iter = registry_.find(key);
+    return iter != registry_.end();
+  }
+
+  template <typename T>
+  inline void TypeRegistry::verifyDefined()
+  {
+    if (!isDefined<T>())
+    {
+      std::string message = "Type is not defined with Rice: " + detail::typeName(typeid(T));
+      throw std::invalid_argument(message);
+    }
+  }
+
+  inline std::optional<std::pair<VALUE, rb_data_type_t*>> TypeRegistry::lookup(const std::type_info& typeInfo)
+  {
+    std::type_index key(typeInfo);
+    auto iter = registry_.find(key);
+
+    if (iter == registry_.end())
+    {
+      return std::nullopt;
+    }
+    else
+    {
+      return iter->second;
+    }
+  }
+
+  template <typename T>
+  inline std::pair<VALUE, rb_data_type_t*> TypeRegistry::figureType(const T& object)
+  {
+    // First check and see if the actual type of the object is registered
+    std::optional<std::pair<VALUE, rb_data_type_t*>> result = lookup(typeid(object));
+
+    if (result)
+    {
+      return result.value();
+    }
+
+    // If not, then we are willing to accept an ancestor class specified by T. This is needed
+    // to support Directors. Classes inherited from Directors are never actually registered
+    // with Rice - and what we really want it to return the C++ class they inherit from.
+    result = lookup(typeid(T));
+    if (result)
+    {
+      return result.value();
+    }
+
+    // Give up!
+    std::string message = "Type " + typeName(typeid(object)) + " is not registered";
+    throw std::runtime_error(message.c_str());
+  }
+
+  // TODO - hacky to put this here but there is a circular dependency between Type and TypeRegistry
+  template<typename T>
+  bool Type<T>::verify()
+  {
+    // Use intrinsic_type so that we don't have to define specializations
+    // for pointers, references, const, etc.
+    using Intrinsic_T = intrinsic_type<T>;
+
+    if constexpr (std::is_fundamental_v<Intrinsic_T>)
+    {
+      return true;
+    }
+    else
+    {
+      TypeRegistry::verifyDefined<Intrinsic_T>();
+      return true;
+    }
+  }
+}

data/rice/detail/Wrapper.hpp

@@ -0,0 +1,51 @@
+#ifndef Rice__detail__Wrapper__hpp_
+#define Rice__detail__Wrapper__hpp_
+
+#include "ruby.hpp"
+
+namespace Rice
+{
+namespace detail
+{
+
+class Wrapper
+{
+public:
+  virtual ~Wrapper() = default;
+  virtual void* get() = 0;
+
+  void ruby_mark();
+  void addKeepAlive(VALUE value);
+
+private:
+  // We use a vector for speed and memory locality versus a set which does
+  // not scale well when getting to tens of thousands of objects (not expecting
+  // that to happen...but just in case)
+  std::vector<VALUE> keepAlive_;
+};
+
+template <typename T, typename Wrapper_T = void>
+VALUE wrap(VALUE klass, rb_data_type_t* rb_type, T& data, bool isOwner);
+
+template <typename T, typename Wrapper_T = void>
+VALUE wrap(VALUE klass, rb_data_type_t* rb_type, T* data, bool isOwner);
+
+template <typename T>
+T* unwrap(VALUE value, rb_data_type_t* rb_type);
+
+Wrapper* getWrapper(VALUE value, rb_data_type_t* rb_type);
+
+void* unwrap(VALUE value);
+
+template <typename T>
+void replace(VALUE value, rb_data_type_t* rb_type, T* data, bool isOwner);
+
+Wrapper* getWrapper(VALUE value);
+
+} // namespace detail
+} // namespace Rice
+
+#include "Wrapper.ipp"
+
+#endif // Rice__detail__Wrapper__hpp_
+

data/rice/detail/Wrapper.ipp

@@ -0,0 +1,151 @@
+#include <memory>
+
+namespace Rice::detail
+{
+  inline void Wrapper::ruby_mark()
+  {
+    for (VALUE value : this->keepAlive_)
+    {
+      rb_gc_mark(value);
+    }
+  }
+
+  inline void Wrapper::addKeepAlive(VALUE value)
+  {
+    this->keepAlive_.push_back(value);
+  }
+
+  template <typename T>
+  class WrapperValue : public Wrapper
+  {
+  public:
+    WrapperValue(T& data): data_(std::move(data))
+    {
+    }
+
+    void* get() override
+    {
+      return (void*)&this->data_;
+    }
+
+  private:
+    T data_;
+  };
+
+  template <typename T>
+  class WrapperReference : public Wrapper
+  {
+  public:
+    WrapperReference(const T& data): data_(data)
+    {
+    }
+
+    void* get() override
+    {
+      return (void*)&this->data_;
+    }
+
+  private:
+    const T& data_;
+  };
+
+  template <typename T>
+  class WrapperPointer : public Wrapper
+  {
+  public:
+    WrapperPointer(T* data, bool isOwner) : data_(data), isOwner_(isOwner)
+    {
+    }
+
+    ~WrapperPointer()
+    {
+      if (this->isOwner_)
+      {
+        delete this->data_;
+      }
+    }
+
+    void* get() override
+    {
+      return (void*)this->data_;
+    }
+
+  private:
+    T* data_ = nullptr;
+    bool isOwner_ = false;
+  };
+
+  // ---- Helper Functions -------
+  template <typename T, typename Wrapper_T>
+  inline VALUE wrap(VALUE klass, rb_data_type_t* rb_type, T& data, bool isOwner)
+  {
+    if constexpr (!std::is_void_v<Wrapper_T>)
+    {
+      Wrapper_T* wrapper = new Wrapper_T(data);
+      return TypedData_Wrap_Struct(klass, rb_type, wrapper);
+    }
+    else if (isOwner)
+    {
+      WrapperValue<T>* wrapper = new WrapperValue<T>(data);
+      return TypedData_Wrap_Struct(klass, rb_type, wrapper);
+    }
+    else
+    {
+      WrapperReference<T>* wrapper = new WrapperReference<T>(data);
+      return TypedData_Wrap_Struct(klass, rb_type, wrapper);
+    }
+  };
+
+  template <typename T, typename Wrapper_T>
+  inline VALUE wrap(VALUE klass, rb_data_type_t* rb_type, T* data, bool isOwner)
+  {
+    if constexpr (!std::is_void_v<Wrapper_T>)
+    {
+      Wrapper_T* wrapper = new Wrapper_T(data);
+      return TypedData_Wrap_Struct(klass, rb_type, wrapper);
+    }
+    else
+    {
+      WrapperPointer<T>* wrapper = new WrapperPointer<T>(data, isOwner);
+      return TypedData_Wrap_Struct(klass, rb_type, wrapper);
+    }
+  };
+
+  template <typename T>
+  inline T* unwrap(VALUE value, rb_data_type_t* rb_type)
+  {
+    Wrapper* wrapper = getWrapper(value, rb_type);
+    TypedData_Get_Struct(value, Wrapper, rb_type, wrapper);
+    return static_cast<T*>(wrapper->get());
+  }
+
+  inline void* unwrap(VALUE value)
+  {
+    // Direct access to avoid any type checking
+    Wrapper* wrapper = (Wrapper*)RTYPEDDATA_DATA(value);
+    return wrapper->get();
+  }
+
+  inline Wrapper* getWrapper(VALUE value, rb_data_type_t* rb_type)
+  {
+    Wrapper* wrapper = nullptr;
+    TypedData_Get_Struct(value, Wrapper, rb_type, wrapper);
+    return wrapper;
+  }
+
+  template <typename T>
+  inline void replace(VALUE value, rb_data_type_t* rb_type, T* data, bool isOwner)
+  {
+    WrapperPointer<T>* wrapper = nullptr;
+    TypedData_Get_Struct(value, WrapperPointer<T>, rb_type, wrapper);
+    delete wrapper;
+
+    wrapper = new WrapperPointer<T>(data, true);
+    RTYPEDDATA_DATA(value) = wrapper;
+  }
+
+  inline Wrapper* getWrapper(VALUE value)
+  {
+    return static_cast<Wrapper*>(RTYPEDDATA_DATA(value));
+  }
+} // namespace

data/rice/detail/default_allocation_func.hpp

@@ -1,23 +1,12 @@
 #ifndef Rice__detail__default_allocation_func__hpp_
 #define Rice__detail__default_allocation_func__hpp_
 
-namespace Rice
+namespace Rice::detail
 {
-
-namespace detail
-{
-
-//! A default implementation of an allocate_func.  This function does no
-//! actual allocation; the initialize_func can later do the real
-//! allocation with: DATA_PTR(self) = new Type(arg1, arg2, ...)
-template<typename T>
-VALUE default_allocation_func(VALUE klass);
-
-} // detail
-
-} // Rice
-
-#include "default_allocation_func.ipp"
-
-#endif // Rice__detail__default_allocation_func__hpp_
-
+  //! A default implementation of an allocate_func.  This function does no
+  //! actual allocation; the initialize_func can later do the real
+  //! allocation with: DATA_PTR(self) = new Type(arg1, arg2, ...)
+  template<typename T>
+  VALUE default_allocation_func(VALUE klass);
+}
+#endif // Rice__detail__default_allocation_func__hpp_

data/rice/detail/default_allocation_func.ipp

@@ -1,11 +1,12 @@
 #include "../Data_Object.hpp"
 
-template<typename T>
-VALUE Rice::detail::
-default_allocation_func(VALUE klass)
+namespace Rice::detail
 {
-  Data_Object<T> m(static_cast<T*>(0), klass);
-  return m.value();
-} 
-
-
+  template<typename T>
+  VALUE default_allocation_func(VALUE klass)
+  {
+    // Create a new Ruby object but since we do not yet have a C++ object
+    // just pass a nullptr. It will be set via the Constructor call
+    return TypedData_Wrap_Struct(klass, Data_Type<T>::rb_type(), nullptr);
+  }
+}

data/rice/detail/from_ruby.hpp

@@ -1,43 +1,8 @@
 #ifndef Rice__detail__from_ruby__hpp_
 #define Rice__detail__from_ruby__hpp_
 
-namespace Rice
-{
-  namespace detail
-  {
-    template<typename T>
-    struct from_ruby_
-    {
-      typedef T Retval_T;
-
-      static T convert(Rice::Object x);
-    };
-
-    template<typename T>
-    struct from_ruby_<T *>
-    {
-      typedef T * Retval_T;
-
-      static T * convert(Rice::Object x);
-    };
-
-    template<typename T>
-    struct from_ruby_<T const *>
-    {
-      typedef T const * Retval_T;
-
-      static T const * convert(Rice::Object x);
-    };
-
-    template<typename T>
-    struct from_ruby_<T &>
-    {
-      typedef T & Retval_T;
-
-      static T & convert(Rice::Object x);
-    };
-  } // detail
-} // Rice
+#include "from_ruby_defn.hpp"
+#include "from_ruby.ipp"
 
 #endif // Rice__detail__from_ruby__hpp_