rice 4.5.0 → 4.6.0

data/rice/detail/Type.hpp

@@ -14,8 +14,10 @@ namespace Rice::detail
   // Return the name of a type
   std::string typeName(const std::type_info& typeInfo);
   std::string typeName(const std::type_index& typeIndex);
-  std::string makeClassName(const std::string& typeInfoName);
+  std::string cppClassName(const std::string& typeInfoName);
+  std::string rubyClassName(const std::string& typeInfoName);
   std::string findGroup(std::string& string, size_t start = 0);
+  void replaceGroup(std::string& string, std::regex regex, std::string replacement);
   void replaceAll(std::string& string, std::regex regex, std::string replacement);
 
   template<typename T>

data/rice/detail/Type.ipp

@@ -13,21 +13,16 @@ namespace Rice::detail
     {
       return true;
     }
+    else if constexpr (std::is_array_v<T> && std::is_fundamental_v<std::remove_extent_t<T>>)
+    {
+      return true;
+    }
     else
     {
       return Registries::instance.types.verify<T>();
     }
   }
 
-  template<>
-  struct Type<void>
-  {
-    static bool verify()
-    {
-      return true;
-    }
-  };
-
   template<typename T>
   void verifyType()
   {
@@ -35,7 +30,7 @@ namespace Rice::detail
   }
 
   template<typename Tuple_T, size_t...Is>
-  void verifyTypesImpl()
+  void verifyTypesImpl(std::index_sequence<Is...> indexes)
   {
     (verifyType<typename std::tuple_element<Is, Tuple_T>::type>(), ...);
   }
@@ -43,10 +38,8 @@ namespace Rice::detail
   template<typename Tuple_T>
   void verifyTypes()
   {
-    if constexpr (std::tuple_size<Tuple_T>::value > 0)
-    {
-      verifyTypesImpl<Tuple_T, std::tuple_size<Tuple_T>::value - 1>();
-    }
+    std::make_index_sequence<std::tuple_size_v<Tuple_T>> indexes;
+    verifyTypesImpl<Tuple_T>(indexes);
   }
 
   inline std::string demangle(char const* mangled_name)
@@ -156,7 +149,18 @@ namespace Rice::detail
     }
   }
 
-  inline std::string makeClassName(const std::string& typeInfoName)
+  inline void replaceGroup(std::string& string, std::regex regex, std::string replacement)
+  {
+    std::smatch match;
+    while (std::regex_search(string, match, regex))
+    {
+      std::string group = findGroup(string, match.position());
+      group = match.str() + group;
+      string.replace(match.position(), group.length(), replacement);
+    }
+  }
+
+  inline std::string cppClassName(const std::string& typeInfoName)
   {
     std::string base = typeInfoName;
 
@@ -170,34 +174,26 @@ namespace Rice::detail
 
     // Remove std::__[^:]*::
     auto stdClangRegex = std::regex("std::__[^:]+::");
-    base = std::regex_replace(base, stdClangRegex, "");
-      
-    // Remove std::
-    auto stdRegex = std::regex("std::");
-    base = std::regex_replace(base, stdRegex, "");
+    base = std::regex_replace(base, stdClangRegex, "std::");
 
-    // Replace basic_string with string
-    auto basicStringRegex = std::regex(R"(basic_string)");
-    replaceAll(base, basicStringRegex, "string");
-      
     // Remove allocators
-    std::regex allocatorRegex(R"(,\s*allocator)");
+    std::regex allocatorRegex(R"(,\s*std::allocator)");
     removeGroup(base, allocatorRegex);
 
     // Remove char_traits
-    std::regex charTraitsRegex(R"(,\s*char_traits)");
+    std::regex charTraitsRegex(R"(,\s*std::char_traits)");
     removeGroup(base, charTraitsRegex);
 
     // Remove less (std::map)
-    std::regex lessRegex(R"(,\s*less)");
+    std::regex lessRegex(R"(,\s*std::less)");
     removeGroup(base, lessRegex);
 
     // Remove hash (std::unordered_map)
-    std::regex hashRegex(R"(,\s*hash)");
+    std::regex hashRegex(R"(,\s*std::hash)");
     removeGroup(base, hashRegex);
 
     // Remove equal_to (std::unordered_map)
-    std::regex equalRegex(R"(,\s*equal_to)");
+    std::regex equalRegex(R"(,\s*std::equal_to)");
     removeGroup(base, equalRegex);
 
     // Remove spaces before pointers
@@ -216,6 +212,36 @@ namespace Rice::detail
     auto commaSpaceRegex = std::regex(R"(,(\S))");
     replaceAll(base, commaSpaceRegex, ", $1");
 
+    // Fix strings
+    auto stringRegex = std::regex(R"(basic_string<char>)");
+    replaceAll(base, stringRegex, "string");
+
+    auto wstringRegex = std::regex(R"(basic_string<wchar_t>)");
+    replaceAll(base, wstringRegex, "wstring");
+
+    // Normalize Anonymous namespace
+    auto anonymousNamespaceGcc = std::regex(R"(\(anonymous namespace\))");
+    replaceAll(base, anonymousNamespaceGcc, "AnonymousNamespace");
+    auto anonymousNamespaceMsvc = std::regex(R"(`anonymous namespace')");
+    replaceAll(base, anonymousNamespaceMsvc, "AnonymousNamespace");
+
+    return base;
+  }
+
+
+  inline std::string rubyClassName(const std::string& typeInfoName)
+  {
+    std::string base = cppClassName(typeInfoName);
+
+    // Remove std:: these could be embedded in template types
+    auto stdRegex = std::regex("std::");
+    base = std::regex_replace(base, stdRegex, "");
+
+    // Remove leading namespaces. This will not remove namespaces
+    // embedded in template types like std::vector<mynamespace::foo>
+    auto leadingNamespacesRegex = std::regex("^[^<]*::");
+    base = std::regex_replace(base, leadingNamespacesRegex, "");
+
     // Capitalize first letter
     base[0] = std::toupper(base[0]);
 
@@ -239,18 +265,22 @@ namespace Rice::detail
 
     // Replace < with unicode U+227A (Precedes)
     auto lessThanRegex = std::regex("<");
-    //replaceAll(base, lessThanRegex, u8"≺");
+    //replaceAll(base, lessThanRegex, "≺");
     replaceAll(base, lessThanRegex, "\u227A");
 
     // Replace > with unicode U+227B (Succeeds)
     auto greaterThanRegex = std::regex(">");
-    //replaceAll(base, greaterThanRegex, u8"≻");
+    //replaceAll(base, greaterThanRegex, "≻");
     replaceAll(base, greaterThanRegex, "\u227B");
 
     // Replace , with Unicode Character (U+066C) - Arabic Thousands Separator
     auto commaRegex = std::regex(R"(,\s*)");
     replaceAll(base, commaRegex, "\u201A");
 
+    // Replace * with Unicode Character (U+2217) -	Asterisk Operator
+    auto asteriskRegex = std::regex(R"(\*)");
+    replaceAll(base, asteriskRegex, "\u2217");
+
     return base;
   }
 }

data/rice/detail/Wrapper.hpp

@@ -1,50 +1,85 @@
 #ifndef Rice__detail__Wrapper__hpp_
 #define Rice__detail__Wrapper__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:
-  Wrapper(bool isOwner = false);
-  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);
-  void setOwner(bool value);
+  protected:
+    bool isOwner_ = false;
+    bool isConst_ = false;
 
-protected:
-  bool isOwner_ = 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>
+  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, typename Wrapper_T = void>
-VALUE wrap(VALUE klass, rb_data_type_t* rb_type, T* data, bool isOwner);
+  template<typename T>
+  class Wrapper<T&> : public WrapperBase
+  {
+  public:
+    Wrapper(T& data);
+    ~Wrapper();
+    void* get() override;
 
-template <typename T>
-T* unwrap(VALUE value, rb_data_type_t* rb_type, bool takeOwnership);
+  private:
+    T& data_;
+  };
 
-Wrapper* getWrapper(VALUE value, rb_data_type_t* rb_type);
+  template <typename T>
+  class Wrapper<T*> : public WrapperBase
+  {
+  public:
+    Wrapper(T* data, bool isOwner);
+    ~Wrapper();
+    void* get() override;
 
-template <typename T>
-void replace(VALUE value, rb_data_type_t* rb_type, T* data, bool isOwner);
+  private:
+    T* data_ = nullptr;
+  };
 
-Wrapper* getWrapper(VALUE value);
+  // ---- Helper Functions ---------
+  template <typename T>
+  void wrapConstructed(VALUE value, rb_data_type_t* rb_data_type, T* data, bool isOwner);
 
-} // namespace detail
-} // namespace Rice
+  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

@@ -2,11 +2,12 @@
 
 namespace Rice::detail
 {
-  inline Wrapper::Wrapper(bool isOwner): isOwner_(isOwner)
+  inline bool WrapperBase::isConst()
   {
+    return this->isConst_;
   }
 
-  inline void Wrapper::ruby_mark()
+  inline void WrapperBase::ruby_mark()
   {
     for (VALUE value : this->keepAlive_)
     {
@@ -14,133 +15,122 @@ namespace Rice::detail
     }
   }
 
-  inline void Wrapper::addKeepAlive(VALUE value)
+  inline void WrapperBase::addKeepAlive(VALUE value)
   {
     this->keepAlive_.push_back(value);
   }
 
-  inline void Wrapper::setOwner(bool value)
+  inline void WrapperBase::setOwner(bool value)
   {
     this->isOwner_ = value;
   }
 
+  // ----  Wrapper -----
   template <typename T>
-  class WrapperValue : public Wrapper
+  inline Wrapper<T>::Wrapper(T& data): data_(data)
   {
-  public:
-    WrapperValue(T& data): data_(std::move(data))
-    {
-    }
-
-    ~WrapperValue()
-    {
-      Registries::instance.instances.remove(this->get());
-    }
+  }
 
-    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) : Wrapper(isOwner), data_(data)
-    {
-    }
+    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 constexpr (std::is_destructible_v<T>)
+      if (this->isOwner_)
       {
-        if (this->isOwner_)
-        {
-          delete this->data_;
-        }
+        delete this->data_;
       }
     }
+  }
 
-    void* get() override
-    {
-      return (void*)this->data_;
-    }
-
-  private:
-    T* data_ = nullptr;
-  };
+  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);
     }
-    // If ruby is the owner than copy the object if possible
-    else if (isOwner)
+
+    // Ruby is the owner so move data
+    else if constexpr (std::is_move_constructible_v<T>)
     {
-      if constexpr (std::is_copy_constructible_v<T> || std::is_move_constructible_v<T>)
-      {
-        wrapper = new WrapperValue<T>(data);
-        result = TypedData_Wrap_Struct(klass, rb_type, wrapper);
-      }
-      else
-      {
-        std::string message = "Ruby 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);
-      }
+      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);
@@ -148,37 +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, bool takeOwnership)
+  inline T* unwrap(VALUE value, rb_data_type_t* rb_data_type, bool takeOwnership)
   {
-    Wrapper* wrapper = getWrapper(value, rb_type);
-    if (takeOwnership)
-      wrapper->setOwner(false);
+    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)
     {
@@ -189,17 +173,21 @@ 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)
   {
-    Wrapper* wrapper = nullptr;
-    TypedData_Get_Struct(value, Wrapper, rb_type, wrapper);
-    return wrapper;
+    WrapperBase* wrapper = nullptr;
+    TypedData_Get_Struct(value, WrapperBase, rb_data_type, wrapper);
+    return dynamic_cast<Wrapper_T*>(wrapper);
   }
 
-  inline Wrapper* getWrapper(VALUE value)
+  inline WrapperBase* getWrapper(VALUE value)
   {
     // Turn off spurious warning on g++ 12
     #if defined(__GNUC__) || defined(__clang__)
@@ -207,7 +195,7 @@ namespace Rice::detail
     #pragma GCC diagnostic ignored "-Warray-bounds"
     #endif
 
-    return RTYPEDDATA_P(value) ? static_cast<Wrapper*>(RTYPEDDATA_DATA(value)) : nullptr;
+    return RTYPEDDATA_P(value) ? static_cast<WrapperBase*>(RTYPEDDATA_DATA(value)) : nullptr;
     
     #if defined(__GNUC__) || defined(__clang__)
     #pragma GCC diagnostic pop
@@ -215,17 +203,19 @@ namespace Rice::detail
   }
 
   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);

data/rice/detail/from_ruby.hpp

@@ -32,10 +32,11 @@ namespace Rice::detail
 
   enum class Convertible: uint8_t
   {
-      None =   0b000,
-      Narrowable = 0b001,
-      Cast =   0b011,
-      Exact =  0b111,
+      None   = 0b0000,
+      Narrow = 0b0001,
+      Cast   = 0b0011,
+      Const  = 0b0111,
+      Exact  = 0b1111
   };
 }