rice 3.0.0 → 4.0.0

data/rice/detail/from_ruby_defn.hpp

@@ -0,0 +1,38 @@
+#ifndef Rice__detail__from_ruby_defn__hpp_
+#define Rice__detail__from_ruby_defn__hpp_
+
+#include <type_traits>
+
+#include "ruby.hpp"
+
+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
+   */
+
+  template <typename T>
+  class From_Ruby;
+}
+
+#endif // Rice__detail__From_Ruby2_defn__hpp_

data/rice/detail/function_traits.hpp

@@ -0,0 +1,124 @@
+#ifndef Rice__detail__function_traits__hpp_
+#define Rice__detail__function_traits__hpp_
+
+#include <tuple>
+
+namespace Rice::detail
+{
+  // --------------   Function Traits --------------
+  // Base class
+  template<typename Function_T>
+  struct function_traits;
+
+  // Base definition that support functors and lambdas
+  template<class Function_T>
+  struct function_traits
+  {
+  private:
+    using functor_t = function_traits<decltype(&Function_T::operator())>;
+
+  public:
+    using arg_types = typename functor_t::arg_types;
+
+    static constexpr std::size_t arity = functor_t::arity - 1;
+
+    template<std::size_t N>
+    using nth_arg = typename std::tuple_element<N, typename functor_t::arg_types>::type;
+
+    using return_type = typename functor_t::return_type;
+    using class_type = std::nullptr_t;
+  };
+
+  // Specialization for functions, member functions and static member functions
+  template<typename Return_T, typename Class_T, typename...Arg_Ts>
+  struct function_traits<Return_T(Class_T, Arg_Ts...)>
+  {
+    using arg_types = std::tuple<Arg_Ts...>;
+
+    static constexpr std::size_t arity = sizeof...(Arg_Ts);
+
+    template<std::size_t N>
+    using nth_arg = typename std::tuple_element<N, arg_types>::type;
+
+    using return_type = Return_T;
+    using class_type = Class_T;
+  };
+
+  // Free functions and static member functions passed by pointer or reference
+  template<typename Return_T, typename ...Arg_Ts>
+  struct function_traits<Return_T(*)(Arg_Ts...)> : public function_traits<Return_T(std::nullptr_t, Arg_Ts...)>
+  {
+  };
+  
+  template<typename Return_T, typename ...Arg_Ts>
+  struct function_traits<Return_T(&)(Arg_Ts...)> : public function_traits<Return_T(std::nullptr_t, Arg_Ts...)>
+  {
+  };
+
+  // Member Functions
+  template<typename Return_T, typename Class_T, typename...Arg_Ts>
+  struct function_traits<Return_T(Class_T::*)(Arg_Ts...)> : public function_traits<Return_T(Class_T*, Arg_Ts...)>
+  {
+  };
+
+  template<typename Return_T, typename Class_T, typename...Arg_Ts>
+  struct function_traits<Return_T(Class_T::*)(Arg_Ts...) const> : public function_traits<Return_T(Class_T*, Arg_Ts...)>
+  {
+  };
+
+  template<typename Return_T, typename Class_T, typename...Arg_Ts>
+  struct function_traits<Return_T(Class_T::*)(Arg_Ts...) noexcept> : public function_traits<Return_T(Class_T*, Arg_Ts...)>
+  {
+  };
+
+  template<typename Return_T, typename Class_T, typename...Arg_Ts>
+  struct function_traits<Return_T(Class_T::*)(Arg_Ts...) const noexcept> : public function_traits<Return_T(Class_T*, Arg_Ts...)>
+  {
+  };
+
+  // Functors and lambdas
+  template<class Function_T>
+  struct function_traits<Function_T&> : public function_traits<Function_T>
+  {
+  };
+
+  template<class Function_T>
+  struct function_traits<Function_T&&> : public function_traits<Function_T>
+  {
+  };
+
+  // --------------   Method Traits --------------
+  // Declare struct
+  template<typename Function_T, bool IsMethod, typename = void>
+  struct method_traits;
+
+  // Functions that do not have a self parameter
+  template<typename Function_T, bool IsMethod>
+  struct method_traits<Function_T, IsMethod, std::enable_if_t<!IsMethod>>
+  {
+    using Self_T = std::nullptr_t;
+    using Arg_Ts = typename function_traits<Function_T>::arg_types;
+    static constexpr std::size_t arity = std::tuple_size_v<Arg_Ts>;
+  };
+
+  // Functions that do have a self parameter (thus we call them methods)
+  template<typename Function_T, bool IsMethod>
+  struct method_traits<Function_T, IsMethod, std::enable_if_t<IsMethod && std::is_same_v<typename function_traits<Function_T>::class_type, std::nullptr_t>>>
+  {
+    using Self_T = typename function_traits<Function_T>::template nth_arg<0>;
+    using Arg_Ts = typename tuple_shift<typename function_traits<Function_T>::arg_types>::type;
+    static constexpr std::size_t arity = std::tuple_size_v<Arg_Ts>;
+  };
+
+  // Member functions that have an implied self parameter of an object instance
+  template<typename Function_T, bool IsMethod>
+  struct method_traits<Function_T, IsMethod, std::enable_if_t<IsMethod && !std::is_same_v<typename function_traits<Function_T>::class_type, std::nullptr_t>>>
+  {
+    using Self_T = typename function_traits<Function_T>::class_type;
+    using Arg_Ts = typename function_traits<Function_T>::arg_types;
+    static constexpr std::size_t arity = std::tuple_size_v<Arg_Ts>;
+  };
+
+}
+
+#endif // Rice__detail__function_traits__hpp_

data/rice/detail/method_data.hpp

@@ -1,21 +1,29 @@
 #ifndef Rice__detail__method_data__hpp
 #define Rice__detail__method_data__hpp
 
-#include "ruby.hpp"
+#include <unordered_map>
+#include <any>
 
-namespace Rice
-{
+#include "ruby.hpp"
 
-namespace detail
+namespace Rice::detail
 {
-
-VALUE define_method_with_data(
-    VALUE klass, ID id, VALUE (*cfunc)(ANYARGS), int arity, VALUE data);
-
-VALUE method_data();
-
-} // namespace detail
-
-} // namespace Rice
-
-#endif // Rice__detail__method_data__hpp
+  class MethodData
+  {
+  public:
+    // Defines a new Ruby method and stores the Rice metadata about it
+    template<typename Function_T>
+    static void define_method(VALUE klass, ID id, Function_T func, int arity, std::any data);
+
+    // Returns the Rice data for the currently active Ruby method
+    template <typename Return_T>
+    static Return_T data();
+
+  private:
+    static size_t key(VALUE klass, ID id);
+    inline static std::unordered_map<size_t, std::any> methodWrappers_ = {};
+  };
+} 
+#include "method_data.ipp"
+
+#endif // Rice__detail__method_data__hpp

data/rice/detail/method_data.ipp

@@ -0,0 +1,53 @@
+
+// Ruby 2.7 now includes a similarly named macro that uses templates to
+// pick the right overload for the underlying function. That doesn't work
+// for our cases because we are using this method dynamically and get a
+// compilation error otherwise. This removes the macro and lets us fall
+// back to the C-API underneath again.
+#undef rb_define_method_id
+
+namespace Rice::detail
+{
+  // Effective Java (2nd edition)
+  // https://stackoverflow.com/a/2634715
+  inline size_t MethodData::key(VALUE klass, ID id)
+  {
+    if (rb_type(klass) == T_ICLASS)
+    {
+      klass = detail::protect(rb_class_of, klass);
+    }
+
+    uint32_t prime = 53;
+    return (prime + klass) * prime + id;
+  }
+
+  template <typename Return_T>
+  inline Return_T MethodData::data()
+  {
+    ID id;
+    VALUE klass;
+    if (!rb_frame_method_id_and_class(&id, &klass))
+    {
+      rb_raise(rb_eRuntimeError, "Cannot get method id and class for function");
+    }
+
+    auto iter = methodWrappers_.find(key(klass, id));
+    if (iter == methodWrappers_.end())
+    {
+      rb_raise(rb_eRuntimeError, "Could not find data for klass and method id");
+    }
+
+    std::any data = iter->second;
+    return std::any_cast<Return_T>(data);
+  }
+
+  template<typename Function_T>
+  inline void MethodData::define_method(VALUE klass, ID id, Function_T func, int arity, std::any data)
+  {
+    // Define the method
+    protect(rb_define_method_id, klass, id, (RUBY_METHOD_FUNC)func, arity);
+
+    // Now store data about it
+    methodWrappers_[key(klass, id)] = data;
+  }
+}

data/rice/detail/rice_traits.hpp

@@ -0,0 +1,116 @@
+#ifndef Rice__detail__traits__hpp_
+#define Rice__detail__traits__hpp_
+
+#include <ostream>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+namespace Rice
+{
+  namespace detail
+  {
+    // Get the base_type of T - without pointer, reference, const or volatile
+    template<typename T>
+    using intrinsic_type = typename std::remove_cv_t<std::remove_reference_t<std::remove_pointer_t<T>>>;
+
+    // Recursively remove const/volatilr
+    template<typename T>
+    struct remove_cv_recursive
+    {
+      using type = T;
+    };
+
+    template<typename T>
+    struct remove_cv_recursive<T const volatile>
+    {
+      using type = typename remove_cv_recursive<T>::type;
+    };
+
+    template<typename T>
+    struct remove_cv_recursive<T volatile>
+    {
+      using type = typename remove_cv_recursive<T>::type;
+    };
+
+    template<typename T>
+    struct remove_cv_recursive<T const>
+    {
+      using type = typename remove_cv_recursive<T>::type;
+    };
+
+    template<typename T>
+    struct remove_cv_recursive<T&>
+    {
+      using type = typename remove_cv_recursive<T>::type&;
+    };
+
+   /* template<typename T>
+    struct remove_cv_recursive<T&&>
+    {
+      using type = typename remove_cv_recursive<T>::type&&;
+    };*/
+
+    template<typename T>
+    struct remove_cv_recursive<T*>
+    {
+      using type = typename remove_cv_recursive<T>::type*;
+    };
+
+    template<typename T>
+    using remove_cv_recursive_t = typename remove_cv_recursive<T>::type;
+
+    // Does the Type work with ostreams? This is used to implement #to_s
+    template<typename T, typename = void>
+    struct is_ostreamable : std::false_type {};
+
+    template<typename T>
+    struct is_ostreamable<T, std::void_t<decltype(std::declval<std::ostream&>() << std::declval<T>())>> : std::true_type {};
+
+    template<typename T>
+    constexpr bool is_ostreamable_v = is_ostreamable<T>::value;
+
+    // Is the type comparable?
+    template<typename T, typename SFINAE = void>
+    struct is_comparable : std::false_type {};
+
+    template<typename T>
+    struct is_comparable<T, std::void_t<decltype(std::declval<T>() == std::declval<T>())>> : std::true_type {};
+
+    template<typename T>
+    constexpr bool is_comparable_v = is_comparable<T>::value;
+
+    template <typename U, typename V>
+    struct is_comparable<std::pair<U, V>>
+    {
+      static const bool value = is_comparable_v<U> && is_comparable_v<V>;
+    };
+
+    template <typename T>
+    struct is_comparable<std::vector<T>>
+    {
+      static const bool value = is_comparable_v<T>;
+    };
+
+    // -- Tuple Helpers ---
+    template<typename T>
+    struct tuple_shift;
+
+    template<typename T, typename...Arg_Ts>
+    struct tuple_shift<std::tuple<T, Arg_Ts...>>
+    {
+      using type = std::tuple<Arg_Ts...>;
+    };
+     
+    template<template<typename, typename...> typename T, typename...Arg_Ts>
+    struct tuple_map;
+
+    template<template<typename, typename...> typename T, typename...Arg_Ts>
+    struct tuple_map<T, std::tuple<Arg_Ts...>>
+    {
+      using type = std::tuple<T<remove_cv_recursive_t<Arg_Ts>>...>;
+    };
+  } // detail
+} // Rice
+
+#endif // Rice__detail__traits__hpp_

data/rice/detail/ruby.hpp

@@ -8,23 +8,19 @@
 
 #include <cmath>
 
-// missing.h that comes with the one-click installer doesn't properly
-// check for double-definition of isinf
-#ifdef isinf
-#define HAVE_ISINF
-#endif
-
-#include "ruby_version_code.hpp"
-#include "../config.hpp"
-
 #include <ruby.h>
 
-#ifdef WIN32
-#include "win32.hpp"
+// ruby.h has a few defines that conflict with Visual Studio's STL
+#if defined(_MSC_VER)
+#undef write
+#undef read
+#undef bind
 #endif
 
-// This causes problems with certain C++ libraries
-#undef TYPE
+// And some c library conflicts
+#undef isnan
+#undef snprintf
+#undef vsnprintf
 
 //! A function that takes a VALUE as a parameter and returns a VALUE.
 // TODO: Casting from a C++ function to an extern "C" function won't
@@ -37,38 +33,5 @@ extern "C" typedef VALUE (*RUBY_VALUE_FUNC)(VALUE);
   extern "C" typedef VALUE (*RUBY_METHOD_FUNC)(ANYARGS);
 #endif
 
-#ifndef RSTRING_LEN
-#define RSTRING_LEN(str) RSTRING(str)->len
-#endif
-
-#ifndef RSTRING_PTR
-#define RSTRING_PTR(str) RSTRING(str)->ptr
-#endif
-
-#ifndef RARRAY_LEN
-#define RARRAY_LEN(arr) RARRAY(arr)->len
-#endif
-
-#ifndef RARRAY_PTR
-#define RARRAY_PTR(arr) RARRAY(arr)->ptr
-#endif
-
-#ifndef RHASH_TBL
-#define RHASH_TBL(hsh) RHASH(hsh)->tbl
-#endif
-
-#ifndef RCLASS_M_TBL
-#define RCLASS_M_TBL(c) RCLASS(c)->m_tbl
-#endif
-
-// ruby.h has a few defines that conflict with Visual Studio's STL
-#if defined(_MSC_VER)
-  #undef write
-  #undef read
-  #undef bind
-#endif
-
-#define std_unique_ptr std::unique_ptr
-
 #endif // Rice__detail__ruby__hpp_