rice 2.1.2 → 4.0.1

data/rice/detail/RubyFunction.hpp

@@ -0,0 +1,39 @@
+#ifndef Rice__detail__ruby_function__hpp_
+#define Rice__detail__ruby_function__hpp_
+
+#include "ruby.hpp"
+
+namespace Rice::detail
+{
+  /* This is functor class that wraps calls to a Ruby C API method. It is needed because
+     rb_protect only supports calling methods that take one argument. Thus 
+     we invoke rb_protect telling it to invoke Ruby_Function::call with an 
+     instance of a Ruby_Function. That instance then in turn calls the original
+     Ruby method passing along its required arguments. */
+
+  template<typename Function_T, typename Return_T, typename...Arg_Ts>
+  class RubyFunction
+  {
+  public:
+    RubyFunction(Function_T func, const Arg_Ts&... args);
+    Return_T operator()();
+
+  private:
+    Function_T func_;
+    std::tuple<Arg_Ts...> args_;
+  };
+
+  template<typename Return_T, typename ...Arg_Ts>
+  Return_T protect(Return_T(*func)(Arg_Ts...), Arg_Ts...args);
+}
+
+namespace Rice
+{
+  template<typename Return_T, typename ...Arg_Ts>
+  [[deprecated("Please use detail::protect")]]
+  Return_T protect(Return_T(*func)(Arg_Ts...), Arg_Ts...args);
+}
+
+#include "RubyFunction.ipp"
+
+#endif // Rice__detail__ruby_function__hpp_

data/rice/detail/RubyFunction.ipp

@@ -0,0 +1,92 @@
+#include "Jump_Tag.hpp"
+#include "../Exception_defn.hpp"
+
+#include <any>
+
+namespace Rice::detail
+{
+  template<typename Function_T, typename Return_T, typename...Arg_Ts>
+  inline RubyFunction<Function_T, Return_T, Arg_Ts...>::RubyFunction(Function_T func, const Arg_Ts&... args)
+    : func_(func), args_(std::forward_as_tuple(args...))
+  {
+  }
+
+  template<typename Function_T, typename Return_T, typename...Arg_Ts>
+  inline Return_T RubyFunction<Function_T, Return_T, Arg_Ts...>::operator()()
+  {
+    const int TAG_RAISE = 0x6; // From Ruby header files
+    int state = 0;
+
+    // Setup a thread local variable to capture the result of the Ruby function call.
+    // We use thread_local because the lambda has to be captureless so it can
+    // be converted to a function pointer callable by C.
+    // The thread local variable avoids having to cast the result to VALUE and then 
+    // back again to Return_T. The problem with that is the translation is not lossless
+    // in some cases - for example a double with value of -1.0 does not roundrip.
+    // 
+    thread_local std::any result;
+
+    // Callback that will invoke the Ruby function
+    using Functor_T = RubyFunction<Function_T, Return_T, Arg_Ts...>;
+    auto callback = [](VALUE value)
+    {
+      Functor_T* functor = (Functor_T*)value;
+
+      if constexpr (std::is_same_v<Return_T, void>)
+      {
+        std::apply(functor->func_, functor->args_);
+      }
+      else
+      {
+        result = std::apply(functor->func_, functor->args_);
+      }
+
+      return Qnil;
+    };
+
+    // Now call rb_protect which will invoke the callback lambda above
+    rb_protect(callback, (VALUE)this, &state);
+
+    // Did anything go wrong?
+    if (state == 0)
+    {
+      if constexpr (!std::is_same_v<Return_T, void>)
+      {
+        return std::any_cast<Return_T>(result);
+      }
+    }
+    else
+    {
+      VALUE err = rb_errinfo();
+      if (state == TAG_RAISE && RTEST(err))
+      {
+        rb_set_errinfo(Qnil);
+        throw Rice::Exception(err);
+      }
+      else
+      {
+        throw Jump_Tag(state);
+      }
+    }
+  }
+    
+  // Create a functor for calling a Ruby function and define some aliases for readability.
+  template<typename Return_T, typename ...Arg_Ts>
+  inline Return_T protect(Return_T(*func)(Arg_Ts...), Arg_Ts...args)
+  {
+    using Function_T = Return_T(*)(Arg_Ts...);
+    auto rubyFunction = RubyFunction<Function_T, Return_T, Arg_Ts...>(func, args...);
+    return rubyFunction();
+  }
+}
+
+namespace Rice
+{
+  template<typename Return_T, typename ...Arg_Ts>
+  inline Return_T protect(Return_T(*func)(Arg_Ts...), Arg_Ts...args)
+  {
+    using Function_T = Return_T(*)(Arg_Ts...);
+    auto rubyFunction = detail::RubyFunction<Function_T, Return_T, Arg_Ts...>(func, args...);
+    return rubyFunction();
+  }
+}

data/rice/detail/Type.hpp

@@ -0,0 +1,29 @@
+#ifndef Rice__Type__hpp_
+#define Rice__Type__hpp_
+
+#include <string>
+#include <typeinfo>
+#include "rice_traits.hpp"
+
+namespace Rice::detail
+{
+  template<typename T>
+  struct Type
+  {
+    static bool verify();
+  };
+
+  // Return the name of a type
+  std::string typeName(const std::type_info& typeInfo);
+  std::string makeClassName(const std::type_info& typeInfo);
+
+  template<typename T>
+  void verifyType();
+
+  template<typename Tuple_T>
+  void verifyTypes();
+}
+
+#include "Type.ipp"
+
+#endif // Rice__Type__hpp_

data/rice/detail/Type.ipp

@@ -0,0 +1,138 @@
+#include "rice_traits.hpp"
+
+#include <iosfwd>
+#include <numeric>
+#include <regex>
+#include <sstream>
+#include <tuple>
+
+#ifdef __GNUC__
+#include <cxxabi.h>
+#include <cstdlib>
+#include <cstring>
+#endif
+
+namespace Rice::detail
+{
+  template<>
+  struct Type<void>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+  };
+
+  template<typename T>
+  void verifyType()
+  {
+    Type<intrinsic_type<T>>::verify();
+  }
+
+  template<typename Tuple_T, size_t...Is>
+  void verifyTypesImpl()
+  {
+    (Type<intrinsic_type<typename std::tuple_element<Is, Tuple_T>::type>>::verify(), ...);
+  }
+
+  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>();
+    }
+  }
+
+  inline std::string demangle(char const* mangled_name)
+  {
+#ifdef __GNUC__
+    struct Helper
+    {
+      Helper(
+        char const* mangled_name)
+        : name_(0)
+      {
+        int status = 0;
+        name_ = abi::__cxa_demangle(mangled_name, 0, 0, &status);
+      }
+
+      ~Helper()
+      {
+        std::free(name_);
+      }
+
+      char* name_;
+
+    private:
+      Helper(Helper const&);
+      void operator=(Helper const&);
+    };
+
+    Helper helper(mangled_name);
+    if (helper.name_)
+    {
+      return helper.name_;
+    }
+    else
+    {
+      return mangled_name;
+    }
+#else
+    return mangled_name;
+#endif
+  }
+
+  inline std::string typeName(const std::type_info& typeInfo)
+  {
+    return demangle(typeInfo.name());
+  }
+
+  inline std::string makeClassName(const std::type_info& typeInfo)
+  {
+    std::string base = demangle(typeInfo.name());
+
+    // Remove class keyword
+    auto classRegex = std::regex("class +");
+    base = std::regex_replace(base, classRegex, "");
+
+    // Remove struct keyword
+    auto structRegex = std::regex("struct +");
+    base = std::regex_replace(base, structRegex, "");
+
+    // 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, "");
+
+    // Replace > > 
+    auto trailingAngleBracketSpaceRegex = std::regex(" >");
+    base = std::regex_replace(base, trailingAngleBracketSpaceRegex, ">");
+
+    // Replace < and >
+    auto angleBracketRegex = std::regex("<|>");
+    base = std::regex_replace(base, angleBracketRegex, "__");
+
+    // Replace ,
+    auto commaRegex = std::regex(", *");
+    base = std::regex_replace(base, commaRegex, "_");
+
+    // Now create a vector of strings split on whitespace
+    std::istringstream stream(base);
+    std::vector<std::string> words{ std::istream_iterator<std::string>{stream},
+                                    std::istream_iterator<std::string>{} };
+
+    std::string result = std::accumulate(words.begin(), words.end(), std::string(),
+      [](const std::string& memo, const std::string& word) -> std::string
+      {
+        std::string capitalized = word;
+        capitalized[0] = toupper(capitalized[0]);
+        return memo + capitalized;
+      });
+
+    return result;
+  }
+}

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;
+    }
+  }
+}