rice 4.3.3 → 4.6.0

data/rice/detail/TypeRegistry.ipp

@@ -1,8 +1,8 @@
+#include <iostream>
 #include <stdexcept>
+#include <sstream>
+#include <typeindex>
 
-#include "ruby.hpp"
-#include "../traits/rice_traits.hpp"
-#include "Type.hpp"
 
 namespace Rice::detail
 {
@@ -13,6 +13,22 @@ namespace Rice::detail
     registry_[key] = std::pair(klass, rbType);
   }
 
+  /* Special case void. Rice defines classes using the class name not a pointer to the
+     class. Thus define_class<void> is more consistent with Rice then 
+     define_class<void*>. However, the types of void and void* are different so we need
+     this special case.
+     
+     It is possible to support define_class<void*>, but it requires changing the static
+     assertions on Data_Type and Data_Object and thus seems less desirable (and less 
+     consistent as mentioned above).*/
+  template <>
+  inline void TypeRegistry::add<void>(VALUE klass, rb_data_type_t* rbType)
+  {
+    // The special case, use void*
+    std::type_index key(typeid(void*));
+    registry_[key] = std::pair(klass, rbType);
+  }
+
   template <typename T>
   inline void TypeRegistry::remove()
   {
@@ -29,14 +45,45 @@ namespace Rice::detail
   }
 
   template <typename T>
-  inline bool TypeRegistry::verifyDefined()
+  std::pair<VALUE, rb_data_type_t*> TypeRegistry::getType()
   {
-    if (!isDefined<T>())
+    std::type_index key(typeid(T));
+    auto iter = registry_.find(key);
+    if (iter != registry_.end())
     {
-      std::string message = "Type is not defined with Rice: " + detail::typeName(typeid(T));
-      throw std::invalid_argument(message);
+      return iter->second;
+    }
+    else
+    {
+      this->raiseUnverifiedType(typeid(T).name());
+      // Make compiler happy
+      return std::make_pair(Qnil, nullptr);
+    }
+  }
+
+  // Special case void. See comment for add above.
+  template <>
+  inline bool TypeRegistry::isDefined<void>()
+  {
+    std::type_index key(typeid(void*));
+    auto iter = registry_.find(key);
+    return iter != registry_.end();
+  }
+
+  template <typename T>
+  inline bool TypeRegistry::verify()
+  {
+    if (isDefined<T>())
+    {
+      return true;
+    }
+    else
+    {
+      const std::type_info& typeInfo = typeid(T);
+      std::type_index key(typeInfo);
+      this->unverified_.insert(key);
+      return false;
     }
-    return true;
   }
 
   inline std::optional<std::pair<VALUE, rb_data_type_t*>> TypeRegistry::lookup(const std::type_info& typeInfo)
@@ -68,14 +115,60 @@ namespace Rice::detail
     // 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));
+    const std::type_info& typeInfo = typeid(T);
+    result = lookup(typeInfo);
     if (result)
     {
       return result.value();
     }
 
-    // Give up!
-    std::string message = "Type " + typeName(typeid(object)) + " is not registered";
-    throw std::runtime_error(message.c_str());
+    raiseUnverifiedType(detail::typeName(typeInfo));
+    // Make the compiler happy
+    return std::pair<VALUE, rb_data_type_t*>(Qnil, nullptr);
+  }
+
+  inline void TypeRegistry::validateTypes()
+  {
+    // Loop over the unverified types and delete each on that is found in the registry
+    // the registry and raise an exception for the first one that is not
+    for (auto iter = this->unverified_.begin(); iter != this->unverified_.end(); )
+    {
+      const std::type_index& typeIndex = *iter;
+      bool isDefined = this->registry_.find(typeIndex) != this->registry_.end();
+      if (isDefined)
+      {
+        iter = this->unverified_.erase(iter);
+      }
+      else
+      {
+        iter++;
+      }
+    }
+
+    if (this->unverified_.empty())
+    {
+      return;
+    }
+
+    std::stringstream stream;
+    stream << "The following types are not registered with Rice:" << "\n";
+
+    for (const std::type_index& typeIndex : this->unverified_)
+    {
+      stream << "  " << typeName(typeIndex) << "\n";
+    }
+
+    throw std::invalid_argument(stream.str());
+  }
+
+  inline void TypeRegistry::clearUnverifiedTypes()
+  {
+    this->unverified_.clear();
+  }
+
+  inline void TypeRegistry::raiseUnverifiedType(const std::string& typeName)
+  {
+    std::string message = "Type is not registered with Rice: " + typeName;
+    throw std::invalid_argument(message);
   }
 }

data/rice/detail/Wrapper.hpp

@@ -1,49 +1,85 @@
 #ifndef Rice__detail__Wrapper__hpp_
 #define Rice__detail__Wrapper__hpp_
 
-#include "ruby.hpp"
-
-namespace Rice
-{
-namespace detail
+namespace Rice::detail
 {
+  class WrapperBase
+  {
+  public:
+    WrapperBase() = default;
+    virtual ~WrapperBase() = default;
+    virtual void* get() = 0;
+    bool isConst();
 
-class Wrapper
-{
-public:
-  virtual ~Wrapper() = default;
-  virtual void* get() = 0;
+    void ruby_mark();
+    void addKeepAlive(VALUE value);
+    void setOwner(bool value);
 
-  void ruby_mark();
-  void addKeepAlive(VALUE value);
+  protected:
+    bool isOwner_ = false;
+    bool isConst_ = false;
 
-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_;
-};
+  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>
+  class Wrapper : public WrapperBase
+  {
+  public:
+    Wrapper(T& data);
+    Wrapper(T&& data);
+    ~Wrapper();
+    void* get() override;
 
-template <typename T, typename Wrapper_T = void>
-VALUE wrap(VALUE klass, rb_data_type_t* rb_type, T* data, bool isOwner);
+  private:
+    T data_;
+  };
 
-template <typename T>
-T* unwrap(VALUE value, rb_data_type_t* rb_type);
+  template<typename T>
+  class Wrapper<T&> : public WrapperBase
+  {
+  public:
+    Wrapper(T& data);
+    ~Wrapper();
+    void* get() override;
 
-Wrapper* getWrapper(VALUE value, rb_data_type_t* rb_type);
+  private:
+    T& data_;
+  };
 
-template <typename T>
-void replace(VALUE value, rb_data_type_t* rb_type, T* data, bool isOwner);
+  template <typename T>
+  class Wrapper<T*> : public WrapperBase
+  {
+  public:
+    Wrapper(T* data, bool isOwner);
+    ~Wrapper();
+    void* get() override;
 
-Wrapper* getWrapper(VALUE value);
+  private:
+    T* data_ = nullptr;
+  };
 
-} // namespace detail
-} // namespace Rice
+  // ---- Helper Functions ---------
+  template <typename T>
+  void wrapConstructed(VALUE value, rb_data_type_t* rb_data_type, T* data, bool isOwner);
 
-#include "Wrapper.ipp"
+  template <typename T>
+  VALUE wrap(VALUE klass, rb_data_type_t* rb_data_type, T& data, bool isOwner);
 
-#endif // Rice__detail__Wrapper__hpp_
+  template <typename T>
+  VALUE wrap(VALUE klass, rb_data_type_t* rb_data_type, T* data, bool isOwner);
 
+  template <typename T>
+  T* unwrap(VALUE value, rb_data_type_t* rb_data_type, bool takeOwnership);
+
+  template <typename Wrapper_T = WrapperBase>
+  Wrapper_T* getWrapper(VALUE value, rb_data_type_t* rb_data_type);
+
+  WrapperBase* getWrapper(VALUE value);
+}
+#endif // Rice__detail__Wrapper__hpp_
+ 

data/rice/detail/Wrapper.ipp

@@ -1,9 +1,13 @@
 #include <memory>
-#include "InstanceRegistry.hpp"
 
 namespace Rice::detail
 {
-  inline void Wrapper::ruby_mark()
+  inline bool WrapperBase::isConst()
+  {
+    return this->isConst_;
+  }
+
+  inline void WrapperBase::ruby_mark()
   {
     for (VALUE value : this->keepAlive_)
     {
@@ -11,118 +15,122 @@ namespace Rice::detail
     }
   }
 
-  inline void Wrapper::addKeepAlive(VALUE value)
+  inline void WrapperBase::addKeepAlive(VALUE value)
   {
     this->keepAlive_.push_back(value);
   }
 
-  template <typename T>
-  class WrapperValue : public Wrapper
+  inline void WrapperBase::setOwner(bool value)
   {
-  public:
-    WrapperValue(T& data): data_(std::move(data))
-    {
-    }
+    this->isOwner_ = value;
+  }
 
-    ~WrapperValue()
-    {
-      Registries::instance.instances.remove(this->get());
-    }
+  // ----  Wrapper -----
+  template <typename T>
+  inline Wrapper<T>::Wrapper(T& data): data_(data)
+  {
+  }
 
-    void* get() override
-    {
-      return (void*)&this->data_;
-    }
+  template <typename T>
+  inline Wrapper<T>::Wrapper(T&& data) : data_(std::move(data))
+  {
+  }
 
-  private:
-    T data_;
-  };
+  template <typename T>
+  inline Wrapper<T>::~Wrapper()
+  {
+    Registries::instance.instances.remove(this->get());
+  }
 
   template <typename T>
-  class WrapperReference : public Wrapper
+  inline void* Wrapper<T>::Wrapper::get()
   {
-  public:
-    WrapperReference(T& data): data_(data)
-    {
-    }
+    return (void*)&this->data_;
+  }
 
-    ~WrapperReference()
-    {
-      Registries::instance.instances.remove(this->get());
-    }
+  // ----  Wrapper& -----
+  template <typename T>
+  inline Wrapper<T&>::Wrapper(T& data): data_(data)
+  {
+    this->isConst_ = std::is_const_v<std::remove_reference_t<T>>;
+  }
 
-    void* get() override
-    {
-      return (void*)&this->data_;
-    }
+  template <typename T>
+  inline Wrapper<T&>::~Wrapper()
+  {
+    Registries::instance.instances.remove(this->get());
+  }
 
-  private:
-    T& data_;
-  };
+  template <typename T>
+  inline void* Wrapper<T&>::get()
+  {
+    return (void*)&this->data_;
+  }
 
+  // ----  Wrapper* -----
   template <typename T>
-  class WrapperPointer : public Wrapper
+  inline Wrapper<T*>::Wrapper(T* data, bool isOwner) : data_(data)
   {
-  public:
-    WrapperPointer(T* data, bool isOwner) : data_(data), isOwner_(isOwner)
-    {
-    }
+    this->isOwner_ = isOwner;
+    this->isConst_ = std::is_const_v<std::remove_pointer_t<T>>;
+  }
 
-    ~WrapperPointer()
+  template <typename T>
+  inline Wrapper<T*>::~Wrapper()
+  {
+    Registries::instance.instances.remove(this->get());
+    if constexpr (std::is_destructible_v<T>)
     {
-      Registries::instance.instances.remove(this->get());
-
       if (this->isOwner_)
       {
         delete this->data_;
       }
     }
+  }
 
-    void* get() override
-    {
-      return (void*)this->data_;
-    }
-
-  private:
-    T* data_ = nullptr;
-    bool isOwner_ = false;
-  };
+  template <typename T>
+  inline void* Wrapper<T*>::get()
+  {
+    return (void*)this->data_;
+  }
 
   // ---- Helper Functions -------
-  template <typename T, typename Wrapper_T>
-  inline VALUE wrap(VALUE klass, rb_data_type_t* rb_type, T& data, bool isOwner)
+  template <typename T>
+  inline VALUE wrap(VALUE klass, rb_data_type_t* rb_data_type, T& data, bool isOwner)
   {
     VALUE result = Registries::instance.instances.lookup(&data);
 
     if (result != Qnil)
       return result;
 
-    Wrapper* wrapper = nullptr;
+    WrapperBase* wrapper = nullptr;
 
-    // Is this a pointer but cannot be copied? For example a std::unique_ptr
-    if constexpr (!std::is_void_v<Wrapper_T> && !std::is_copy_constructible_v<Wrapper_T>)
+    // If Ruby is not the owner then wrap the reference
+    if (!isOwner)
     {
-      wrapper = new Wrapper_T(std::move(data));
-      result = TypedData_Wrap_Struct(klass, rb_type, wrapper);
+      wrapper = new Wrapper<T&>(data);
+      result = TypedData_Wrap_Struct(klass, rb_data_type, wrapper);
     }
-    // Is this a pointer or smart pointer like std::shared_ptr
-    else if constexpr (!std::is_void_v<Wrapper_T>)
+
+    // Ruby is the owner so copy data
+    else if constexpr (std::is_copy_constructible_v<T>)
     {
-      wrapper = new Wrapper_T(data);
-      result = TypedData_Wrap_Struct(klass, rb_type, wrapper);
+      wrapper = new Wrapper<T>(data);
+      result = TypedData_Wrap_Struct(klass, rb_data_type, wrapper);
     }
-    // Is this a pointer and it cannot copied? This is for std::unique_ptr
-    // If ruby is the owner than copy the object
-    else if (isOwner)
+
+    // Ruby is the owner so move data
+    else if constexpr (std::is_move_constructible_v<T>)
     {
-      wrapper = new WrapperValue<T>(data);
-      result = TypedData_Wrap_Struct(klass, rb_type, wrapper);
+      wrapper = new Wrapper<T>(std::forward<T>(data));
+      result = TypedData_Wrap_Struct(klass, rb_data_type, wrapper);
     }
-    // Ruby is not the owner so just wrap the reference
+
     else
     {
-      wrapper = new WrapperReference<T>(data);
-      result = TypedData_Wrap_Struct(klass, rb_type, wrapper);
+      std::string message = "Rice was directed to take ownership of a C++ object but it does not have an accessible copy or move constructor. Type: " +
+        typeName(typeid(T));
+      throw std::runtime_error(message);
     }
 
     Registries::instance.instances.add(wrapper->get(), result);
@@ -130,35 +138,31 @@ namespace Rice::detail
     return result;
   };
 
-  template <typename T, typename Wrapper_T>
-  inline VALUE wrap(VALUE klass, rb_data_type_t* rb_type, T* data, bool isOwner)
+  template <typename T>
+  inline VALUE wrap(VALUE klass, rb_data_type_t* rb_data_type, T* data, bool isOwner)
   {
     VALUE result = Registries::instance.instances.lookup(data);
 
     if (result != Qnil)
       return result;
 
-    Wrapper* wrapper = nullptr;
-
-    if constexpr (!std::is_void_v<Wrapper_T>)
-    {
-      wrapper = new Wrapper_T(data);
-      result = TypedData_Wrap_Struct(klass, rb_type, wrapper);
-    }
-    else
-    {
-      wrapper = new WrapperPointer<T>(data, isOwner);
-      result = TypedData_Wrap_Struct(klass, rb_type, wrapper);
-    }
+    WrapperBase* wrapper = new Wrapper<T*>(data, isOwner);
+    result = TypedData_Wrap_Struct(klass, rb_data_type, wrapper);
 
     Registries::instance.instances.add(wrapper->get(), result);
     return result;
   };
 
   template <typename T>
-  inline T* unwrap(VALUE value, rb_data_type_t* rb_type)
+  inline T* unwrap(VALUE value, rb_data_type_t* rb_data_type, bool takeOwnership)
   {
-    Wrapper* wrapper = getWrapper(value, rb_type);
+    if (rb_type(value) != RUBY_T_DATA)
+    {
+      std::string message = "The provided Ruby object does not wrap a C++ object";
+      throw std::runtime_error(message);
+    }
+
+    WrapperBase* wrapper = getWrapper(value, rb_data_type);
 
     if (wrapper == nullptr)
     {
@@ -169,43 +173,51 @@ namespace Rice::detail
       throw std::runtime_error(message);
     }
 
+    if (takeOwnership)
+      wrapper->setOwner(false);
+
     return static_cast<T*>(wrapper->get());
   }
     
-  inline Wrapper* getWrapper(VALUE value, rb_data_type_t* rb_type)
+  template <typename Wrapper_T>
+  inline Wrapper_T* getWrapper(VALUE value, rb_data_type_t* rb_data_type)
+  {
+    WrapperBase* wrapper = nullptr;
+    TypedData_Get_Struct(value, WrapperBase, rb_data_type, wrapper);
+    return dynamic_cast<Wrapper_T*>(wrapper);
+  }
+
+  inline WrapperBase* getWrapper(VALUE value)
   {
-    Wrapper* wrapper = nullptr;
-    TypedData_Get_Struct(value, Wrapper, rb_type, wrapper);
-    return wrapper;
+    // Turn off spurious warning on g++ 12
+    #if defined(__GNUC__) || defined(__clang__)
+    #pragma GCC diagnostic push
+    #pragma GCC diagnostic ignored "-Warray-bounds"
+    #endif
+
+    return RTYPEDDATA_P(value) ? static_cast<WrapperBase*>(RTYPEDDATA_DATA(value)) : nullptr;
+    
+    #if defined(__GNUC__) || defined(__clang__)
+    #pragma GCC diagnostic pop
+    #endif
   }
 
   template <typename T>
-  inline void replace(VALUE value, rb_data_type_t* rb_type, T* data, bool isOwner)
+  inline void wrapConstructed(VALUE value, rb_data_type_t* rb_data_type, T* data, bool isOwner)
   {
-    WrapperPointer<T>* wrapper = nullptr;
-    TypedData_Get_Struct(value, WrapperPointer<T>, rb_type, wrapper);
+    using Wrapper_T = Wrapper<T*>;
+    
+    Wrapper_T* wrapper = nullptr;
+    TypedData_Get_Struct(value, Wrapper_T, rb_data_type, wrapper);
     if (wrapper)
     {
       Registries::instance.instances.remove(wrapper->get());
       delete wrapper;
     }
 
-    wrapper = new WrapperPointer<T>(data, isOwner);
+    wrapper = new Wrapper_T(data, true);
     RTYPEDDATA_DATA(value) = wrapper;
 
     Registries::instance.instances.add(data, value);
   }
-
-  inline Wrapper* getWrapper(VALUE value)
-  {
-    // Turn off spurious warning on g++ 12
-#ifdef __GNUC__
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Warray-bounds"
-#endif
-    return RTYPEDDATA_P(value) ? static_cast<Wrapper*>(RTYPEDDATA_DATA(value)) : nullptr;
-#ifdef __GNUC__
-#pragma GCC diagnostic pop
-#endif
-  }
 } // namespace

data/rice/detail/cpp_protect.hpp

@@ -14,8 +14,6 @@
   #error "no filesystem include found :'("
 #endif
 
-#include "Jump_Tag.hpp"
-#include "../Exception_defn.hpp"
 
 namespace Rice::detail
 {
@@ -30,13 +28,14 @@ namespace Rice::detail
     {
       try
       {
-        detail::Registries::instance.handlers.handler()->handle();
+        std::function<void()> handler = detail::Registries::instance.handlers.handler();
+        handler();
       }
       catch (::Rice::Exception const& ex)
       {
         rb_exc_raise(ex.value());
       }
-      catch (::Rice::Jump_Tag const& ex)
+      catch (::Rice::JumpException const& ex)
       {
         rb_jump_tag(ex.tag);
       }
@@ -61,11 +60,11 @@ namespace Rice::detail
       }
       catch (std::length_error const& ex)
       {
-        rb_exc_raise(rb_exc_new2(rb_eRuntimeError, ex.what()));
+        rb_exc_raise(rb_exc_new2(rb_eIndexError, ex.what()));
       }
       catch (std::out_of_range const& ex)
       {
-        rb_exc_raise(rb_exc_new2(rb_eRangeError, ex.what()));
+        rb_exc_raise(rb_exc_new2(rb_eIndexError, ex.what()));
       }
       catch (std::overflow_error const& ex)
       {

data/rice/detail/default_allocation_func.ipp

@@ -1,5 +1,3 @@
-#include "../Data_Object.hpp"
-
 namespace Rice::detail
 {
   template<typename T>

data/rice/detail/from_ruby.hpp

@@ -1,8 +1,43 @@
 #ifndef Rice__detail__from_ruby__hpp_
 #define Rice__detail__from_ruby__hpp_
 
-#include "from_ruby_defn.hpp"
-#include "from_ruby.ipp"
+namespace Rice::detail
+{
+  //! Convert a Ruby object to C++.
+  /*! If the Ruby object can be converted to an immediate value, returns a
+   *  copy of the Ruby object.  If the Ruby object is holding a C++
+   *  object and the type specified is a pointer to that type, returns a
+   *  pointer to that object.
+   *
+   *  Conversions from ruby to a pointer type are automatically generated
+   *  when a type is bound using Data_Type.  If no conversion exists an
+   *  exception is thrown.
+   *
+   *  \param T the C++ type to which to convert.
+   *  \param x the Ruby object to convert.
+   *  \return a C++ representation of the Ruby object.
+   *
+   *  Example:
+   *  \code
+   *    Object x = INT2NUM(42);
+   *    std::cout << From_Ruby<int>::convert(x);
+   *
+   *    Data_Object<Foo> foo(new Foo);
+   *    std::cout << *From_Ruby<Foo *>(foo) << std::endl;
+   *  \endcode
+   */
 
-#endif // Rice__detail__from_ruby__hpp_
+  template <typename T>
+  class From_Ruby;
 
+  enum class Convertible: uint8_t
+  {
+      None   = 0b0000,
+      Narrow = 0b0001,
+      Cast   = 0b0011,
+      Const  = 0b0111,
+      Exact  = 0b1111
+  };
+}
+
+#endif // Rice__detail__From_Ruby2__hpp_