rice 4.6.1 → 4.7.0

data/rice/detail/Type.ipp

@@ -4,35 +4,52 @@
 #include <cstring>
 #endif
 
+// Rice saves types either as the intrinsic type (MyObject) or pointer (MyObject*).
+// It strips out references, const and volatile to avoid an explosion of template classes.
+// Pointers are used for C function pointers used in callbacks and for the Buffer class.
 namespace Rice::detail
 {
+  // ------ Type ----------------
   template<typename T>
-  bool Type<T>::verify()
+  inline bool Type<T>::verify()
   {
-    if constexpr (std::is_fundamental_v<T>)
-    {
-      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>();
-    }
+    return Registries::instance.types.verify<intrinsic_type<T>>();
+  }
+
+  template<typename T>
+  inline bool Type<T&>::verify()
+  {
+    return Type<T>::verify();
+  }
+
+  template<typename T>
+  inline bool Type<T&&>::verify()
+  {
+    return Type<T>::verify();
+  }
+
+  template<typename T>
+  inline bool Type<T*>::verify()
+  {
+    return Type<T>::verify();
+  }
+
+  template<typename T>
+  inline bool Type<T**>::verify()
+  {
+    return Type<T>::verify();
   }
 
   template<typename T>
   void verifyType()
   {
-    Type<intrinsic_type<T>>::verify();
+    Type<remove_cv_recursive_t<T>>::verify();
   }
 
   template<typename Tuple_T, size_t...Is>
   void verifyTypesImpl(std::index_sequence<Is...> indexes)
   {
-    (verifyType<typename std::tuple_element<Is, Tuple_T>::type>(), ...);
+    (verifyType<std::tuple_element_t<Is, Tuple_T>>(), ...);
   }
 
   template<typename Tuple_T>
@@ -42,7 +59,21 @@ namespace Rice::detail
     verifyTypesImpl<Tuple_T>(indexes);
   }
 
-  inline std::string demangle(char const* mangled_name)
+  // ---------- RubyKlass ------------
+  // Helper template to see if the method rubyKlass is defined on a Type specialization
+  template<typename, typename = std::void_t<>>
+  struct has_ruby_klass : std::false_type
+  {
+  };
+
+  template<typename T>
+  struct has_ruby_klass<T, std::void_t<decltype(T::rubyKlass())>> : std::true_type
+  {
+  };
+
+  // ---------- TypeMapper ------------
+  template<typename T>
+  inline std::string TypeMapper<T>::demangle(char const* mangled_name)
   {
 #ifdef __GNUC__
     struct Helper
@@ -81,12 +112,15 @@ namespace Rice::detail
 #endif
   }
 
-  inline std::string typeName(const std::type_info& typeInfo)
+  template<typename T>
+  inline std::string TypeMapper<T>::name()
   {
-    return demangle(typeInfo.name());
+    const std::type_index& typeIndex = typeid(T);
+    return demangle(typeIndex.name());
   }
 
-  inline std::string typeName(const std::type_index& typeIndex)
+  template<typename T>
+  inline std::string TypeMapper<T>::name(const std::type_index& typeIndex)
   {
     return demangle(typeIndex.name());
   }
@@ -96,7 +130,8 @@ namespace Rice::detail
   // Example:
   //  
   //   std::vector<std::vector<int>, std::allocator<std::vector, std::allocator<int>>>
-  inline std::string findGroup(std::string& string, size_t offset)
+  template<typename T>
+  inline std::string TypeMapper<T>::findGroup(std::string& string, size_t offset)
   {
     int depth = 0;
 
@@ -129,7 +164,8 @@ namespace Rice::detail
     throw std::runtime_error("Unbalanced Group");
   }
 
-  inline void replaceAll(std::string& string, std::regex regex, std::string replacement)
+  template<typename T>
+  inline void TypeMapper<T>::replaceAll(std::string& string, std::regex regex, std::string replacement)
   {
     std::smatch match;
     while (std::regex_search(string, match, regex))
@@ -138,7 +174,8 @@ namespace Rice::detail
     }
   }
 
-  inline void removeGroup(std::string& string, std::regex regex)
+  template<typename T>
+  inline void TypeMapper<T>::removeGroup(std::string& string, std::regex regex)
   {
     std::smatch match;
     while (std::regex_search(string, match, regex))
@@ -149,7 +186,8 @@ namespace Rice::detail
     }
   }
 
-  inline void replaceGroup(std::string& string, std::regex regex, std::string replacement)
+  template<typename T>
+  inline void TypeMapper<T>::replaceGroup(std::string& string, std::regex regex, std::string replacement)
   {
     std::smatch match;
     while (std::regex_search(string, match, regex))
@@ -160,20 +198,25 @@ namespace Rice::detail
     }
   }
 
-  inline std::string cppClassName(const std::string& typeInfoName)
+  template<typename T>
+  inline std::string TypeMapper<T>::simplifiedName()
   {
-    std::string base = typeInfoName;
+    std::string base = this->name();
+
+    // Remove void from Buffer<T, void> - the void comes from SFINAE
+    std::regex fixBuffer = std::regex("(Buffer<.*),\\s?void>");
+    base = std::regex_replace(base, fixBuffer, "$1>");
 
     // Remove class keyword
-    auto classRegex = std::regex("class +");
-    base = std::regex_replace(typeInfoName, classRegex, "");
+    std::regex classRegex = std::regex("class +");
+    base = std::regex_replace(base, classRegex, "");
 
     // Remove struct keyword
-    auto structRegex = std::regex("struct +");
+    std::regex structRegex = std::regex("struct +");
     base = std::regex_replace(base, structRegex, "");
 
     // Remove std::__[^:]*::
-    auto stdClangRegex = std::regex("std::__[^:]+::");
+    std::regex stdClangRegex = std::regex("std::__[^:]+::");
     base = std::regex_replace(base, stdClangRegex, "std::");
 
     // Remove allocators
@@ -197,7 +240,7 @@ namespace Rice::detail
     removeGroup(base, equalRegex);
 
     // Remove spaces before pointers
-    auto ptrRegex = std::regex(R"(\s+\*)");
+    std::regex ptrRegex = std::regex(R"(\s+\*)");
     base = std::regex_replace(base, ptrRegex, "*");
 
     // Remove __ptr64
@@ -205,32 +248,65 @@ namespace Rice::detail
     base = std::regex_replace(base, ptr64Regex, "");
 
     // Replace " >" with ">"
-    auto trailingAngleBracketSpaceRegex = std::regex(R"(\s+>)");
+    std::regex trailingAngleBracketSpaceRegex = std::regex(R"(\s+>)");
     replaceAll(base, trailingAngleBracketSpaceRegex, ">");
 
     // One space after a comma (MSVC has no spaces, GCC one space)
-    auto commaSpaceRegex = std::regex(R"(,(\S))");
+    std::regex commaSpaceRegex = std::regex(R"(,(\S))");
     replaceAll(base, commaSpaceRegex, ", $1");
 
     // Fix strings
-    auto stringRegex = std::regex(R"(basic_string<char>)");
+    std::regex stringRegex = std::regex(R"(basic_string<char>)");
     replaceAll(base, stringRegex, "string");
 
-    auto wstringRegex = std::regex(R"(basic_string<wchar_t>)");
+    std::regex wstringRegex = std::regex(R"(basic_string<wchar_t>)");
     replaceAll(base, wstringRegex, "wstring");
 
     // Normalize Anonymous namespace
-    auto anonymousNamespaceGcc = std::regex(R"(\(anonymous namespace\))");
+    std::regex anonymousNamespaceGcc = std::regex(R"(\(anonymous namespace\))");
     replaceAll(base, anonymousNamespaceGcc, "AnonymousNamespace");
-    auto anonymousNamespaceMsvc = std::regex(R"(`anonymous namespace')");
+    std::regex anonymousNamespaceMsvc = std::regex(R"(`anonymous namespace')");
     replaceAll(base, anonymousNamespaceMsvc, "AnonymousNamespace");
 
     return base;
   }
 
-  inline std::string rubyClassName(const std::string& typeInfoName)
+  template<typename T>
+  inline void TypeMapper<T>::capitalizeHelper(std::string& content, std::regex& regex)
   {
-    std::string base = cppClassName(typeInfoName);
+    std::smatch match;
+    while (std::regex_search(content, match, regex))
+    {
+      std::string replacement = match[1];
+      std::transform(replacement.begin(), replacement.end(), replacement.begin(), ::toupper);
+      content.replace(match.position(), match.length(), replacement);
+    }
+  }
+
+  template<typename T>
+  inline std::string TypeMapper<T>::rubyTypeName()
+  {
+    using Intrinsic_T = detail::intrinsic_type<T>;
+
+    if constexpr (std::is_fundamental_v<T>)
+    {
+      return RubyType<Intrinsic_T>::name;
+    }
+    else if constexpr (std::is_same_v<std::remove_cv_t<T>, char*>)
+    {
+      return "String";
+    }
+    else
+    {
+      detail::TypeMapper<Intrinsic_T> typeIntrinsicMapper;
+      return typeIntrinsicMapper.simplifiedName();
+    }
+  }
+
+  template<typename T>
+  inline std::string TypeMapper<T>::rubyName()
+  {
+    std::string base = this->rubyTypeName();
 
     // Remove std:: these could be embedded in template types
     auto stdRegex = std::regex("std::");
@@ -249,18 +325,21 @@ namespace Rice::detail
     replaceAll(base, colonRegex, "\uA789");
 
     // Replace _ and capitalize the next letter
-    std::regex namespaceRegex(R"(_(\w))");
-    std::smatch namespaceMatch;
-    while (std::regex_search(base, namespaceMatch, namespaceRegex))
+    std::regex underscoreRegex(R"(_(\w))");
+    capitalizeHelper(base, underscoreRegex);
+
+    if constexpr (std::is_fundamental_v<intrinsic_type<T>>)
     {
-      std::string replacement = namespaceMatch[1];
-      std::transform(replacement.begin(), replacement.end(), replacement.begin(), ::toupper);
-      base.replace(namespaceMatch.position(), namespaceMatch.length(), replacement);
+      // Replace space and capitalize the next letter
+      std::regex spaceRegex(R"(\s+(\w))");
+      capitalizeHelper(base, spaceRegex);
+    }
+    else
+    {
+      // Replace spaces with unicode U+u00A0 (Non breaking Space)
+      std::regex spaceRegex = std::regex(R"(\s+)");
+      replaceAll(base, spaceRegex, "\u00A0");
     }
-
-    // Replace spaces with unicode U+u00A0 (Non breaking Space)
-    auto spaceRegex = std::regex(R"(\s+)");
-    replaceAll(base, spaceRegex, "\u00A0");
 
     // Replace < with unicode U+227A (Precedes)
     auto lessThanRegex = std::regex("<");
@@ -282,4 +361,27 @@ namespace Rice::detail
 
     return base;
   }
-}
+
+  template<typename T>
+  inline VALUE TypeMapper<T>::rubyKlass()
+  {
+    using Type_T = Type<std::remove_reference_t<detail::remove_cv_recursive_t<T>>>;
+    using Intrinsic_T = detail::intrinsic_type<T>;
+
+    if constexpr (has_ruby_klass<Type_T>::value)
+    {
+      return Type_T::rubyKlass();
+    }
+    else if constexpr (std::is_fundamental_v<Intrinsic_T> && std::is_pointer_v<T>)
+    {
+			using Pointer_T = Pointer<std::remove_pointer_t<remove_cv_recursive_t<T>>>;
+      std::pair<VALUE, rb_data_type_t*> pair = Registries::instance.types.getType<Pointer_T>();
+      return pair.first;
+    }
+    else
+    {
+      std::pair<VALUE, rb_data_type_t*> pair = Registries::instance.types.getType<Intrinsic_T>();
+      return pair.first;
+    }
+  }
+}

data/rice/detail/TypeRegistry.hpp

@@ -43,6 +43,9 @@ namespace Rice::detail
     // Clear unverified types. This is mostly for unit tests
     void clearUnverifiedTypes();
 
+    // API for access from Ruby
+    VALUE klasses();
+
   private:
     std::optional<std::pair<VALUE, rb_data_type_t*>> lookup(const std::type_info& typeInfo);
     void raiseUnverifiedType(const std::string& typeName);

data/rice/detail/TypeRegistry.ipp

@@ -13,22 +13,6 @@ 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()
   {
@@ -61,15 +45,6 @@ namespace Rice::detail
     }
   }
 
-  // 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()
   {
@@ -122,7 +97,8 @@ namespace Rice::detail
       return result.value();
     }
 
-    raiseUnverifiedType(detail::typeName(typeInfo));
+    detail::TypeMapper<T> typeMapper;
+    raiseUnverifiedType(typeMapper.name());
     // Make the compiler happy
     return std::pair<VALUE, rb_data_type_t*>(Qnil, nullptr);
   }
@@ -155,7 +131,8 @@ namespace Rice::detail
 
     for (const std::type_index& typeIndex : this->unverified_)
     {
-      stream << "  " << typeName(typeIndex) << "\n";
+      detail::TypeMapper<int> typeMapper;
+      stream << "  " << typeMapper.name(typeIndex) << "\n";
     }
 
     throw std::invalid_argument(stream.str());
@@ -171,4 +148,17 @@ namespace Rice::detail
     std::string message = "Type is not registered with Rice: " + typeName;
     throw std::invalid_argument(message);
   }
+
+  inline VALUE TypeRegistry::klasses()
+  {
+    Array result;
+
+    for (auto& pair : this->registry_)
+    {
+      std::pair<VALUE, rb_data_type_t*>& value = pair.second;
+      Class klass = value.first;
+      result.push(klass, false);
+    }
+    return result;
+  }
 }