rice 4.0.4 → 4.1.0

data/rice/detail/NativeIterator.hpp

@@ -0,0 +1,49 @@
+#ifndef Rice_NativeIterator__hpp_
+#define Rice_NativeIterator__hpp_
+
+#include "traits/function_traits.hpp"
+
+namespace Rice::detail
+{
+  template<typename T, typename Iterator_Func_T>
+  class NativeIterator
+  {
+  public:
+    using NativeIterator_T = NativeIterator<T, Iterator_Func_T>;
+    using Iterator_T = typename function_traits<Iterator_Func_T>::return_type;
+    using Value_T = typename std::iterator_traits<Iterator_T>::value_type;
+    using Difference_T = typename std::iterator_traits<Iterator_T>::difference_type;
+
+  public:
+    // Register function with Ruby
+    void static define(VALUE klass, std::string method_name, Iterator_Func_T begin, Iterator_Func_T end);
+
+    // Static member function that Ruby calls
+    static VALUE call(VALUE self);
+
+  public:
+    // Disallow creating/copying/moving
+    NativeIterator() = delete;
+    NativeIterator(const NativeIterator_T&) = delete;
+    NativeIterator(NativeIterator_T&&) = delete;
+    void operator=(const NativeIterator_T&) = delete;
+    void operator=(NativeIterator_T&&) = delete;
+
+    VALUE operator()(VALUE self);
+
+  protected:
+    NativeIterator(VALUE klass, std::string method_name, Iterator_Func_T begin, Iterator_Func_T end);
+
+  private:
+    VALUE createRubyEnumerator(VALUE self);
+
+  private:
+    VALUE klass_;
+    std::string method_name_;
+    Iterator_Func_T begin_;
+    Iterator_Func_T end_;
+  };
+}
+#include "NativeIterator.ipp"
+
+#endif // Rice_NativeIterator__hpp_

data/rice/detail/NativeIterator.ipp

@@ -0,0 +1,102 @@
+#include <iterator>
+#include <functional>
+#include <type_traits>
+
+#include "cpp_protect.hpp"
+#include "NativeRegistry.hpp"
+
+namespace Rice::detail
+{
+  template <typename T, typename Iterator_Func_T>
+  inline void NativeIterator<T, Iterator_Func_T>::define(VALUE klass, std::string method_name, Iterator_Func_T begin, Iterator_Func_T end)
+  {
+    // Tell Ruby to invoke the static method call on this class
+    detail::protect(rb_define_method, klass, method_name.c_str(), (RUBY_METHOD_FUNC)&NativeIterator_T::call, 0);
+
+    // Now create a NativeIterator instance and save it to the natives registry keyed on
+    // Ruby klass and method id. There may be multiple NativeIterator instances
+    // because the same C++ method could be mapped to multiple Ruby methods.
+    NativeIterator_T* native = new NativeIterator_T(klass, method_name, begin, end);
+    detail::Registries::instance.natives.add(klass, Identifier(method_name).id(), native);
+  }
+
+  template<typename T, typename Iterator_Func_T>
+  inline VALUE NativeIterator<T, Iterator_Func_T>::call(VALUE self)
+  {
+    // Look up the native function based on the Ruby klass and method id
+    NativeIterator_T* nativeIterator = detail::Registries::instance.natives.lookup<NativeIterator_T*>();
+
+    return cpp_protect([&]
+    {
+      return nativeIterator->operator()(self);
+    });
+  }
+
+  template <typename T, typename Iterator_Func_T>
+  inline NativeIterator<T, Iterator_Func_T>::NativeIterator(VALUE klass, std::string method_name, Iterator_Func_T begin, Iterator_Func_T end) :
+    klass_(klass), method_name_(method_name), begin_(begin), end_(end)
+  {
+  }
+
+  template<typename T, typename Iterator_Func_T>
+  inline VALUE NativeIterator<T, Iterator_Func_T>::createRubyEnumerator(VALUE self)
+  {
+    auto rb_size_function = [](VALUE recv, VALUE argv, VALUE eobj) -> VALUE
+    {
+      // Since we can't capture VALUE self from above (because then we can't send
+      // this lambda to rb_enumeratorize_with_size), extract it from recv
+      return cpp_protect([&]
+      {
+        // Get the iterator instance
+        using Iter_T = NativeIterator<T, Iterator_Func_T>;
+        // Class is easy
+        VALUE klass = protect(rb_class_of, recv);
+        // Read the method_id from an attribute we added to the enumerator instance
+        ID method_id = protect(rb_ivar_get, eobj, rb_intern("rice_method"));
+        Iter_T* iterator = detail::Registries::instance.natives.lookup<Iter_T*>(klass, method_id);
+
+        // Get the wrapped C++ instance
+        T* receiver = detail::From_Ruby<T*>().convert(recv);
+
+        // Get the distance
+        Iterator_T begin = std::invoke(iterator->begin_, *receiver);
+        Iterator_T end = std::invoke(iterator->end_, *receiver);
+        Difference_T distance = std::distance(begin, end);
+
+        return detail::To_Ruby<Difference_T>().convert(distance);
+      });
+    };
+
+    VALUE method_sym = Identifier(this->method_name_).to_sym();
+    VALUE enumerator = protect(rb_enumeratorize_with_size, self, method_sym, 0, nullptr, rb_size_function);
+    
+    // Hack the enumerator object by storing name_ on the enumerator object so
+    // the rb_size_function above has access to it
+    ID method_id = Identifier(this->method_name_).id();
+    protect(rb_ivar_set, enumerator, rb_intern("rice_method"), method_id  );
+
+    return enumerator;
+  }
+
+  template<typename T, typename Iterator_Func_T>
+  inline VALUE NativeIterator<T, Iterator_Func_T>::operator()(VALUE self)
+  {
+    if (!protect(rb_block_given_p))
+    {
+      return createRubyEnumerator(self);
+    }
+    else
+    {
+      T* receiver = detail::From_Ruby<T*>().convert(self);
+      Iterator_T it = std::invoke(this->begin_, *receiver);
+      Iterator_T end = std::invoke(this->end_, *receiver);
+
+      for (; it != end; ++it)
+      {
+        protect(rb_yield, detail::To_Ruby<Value_T>().convert(*it));
+      }
+
+      return self;
+    }
+  }
+}

data/rice/detail/NativeRegistry.hpp

@@ -0,0 +1,31 @@
+#ifndef Rice__detail__NativeRegistry__hpp
+#define Rice__detail__NativeRegistry__hpp
+
+#include <unordered_map>
+#include <any>
+
+#include "ruby.hpp"
+
+namespace Rice::detail
+{
+  class NativeRegistry
+  {
+  public:
+    // Add a new native callable object keyed by Ruby class and method_id
+    void add(VALUE klass, ID method_id, std::any callable);
+
+    // Returns the Rice data for the currently active Ruby method
+    template <typename Return_T>
+    Return_T lookup();
+
+    template <typename Return_T>
+    Return_T lookup(VALUE klass, ID method_id);
+
+  private:
+    size_t key(VALUE klass, ID method_id);
+    std::unordered_map<size_t, std::any> natives_ = {};
+  };
+} 
+#include "NativeRegistry.ipp"
+
+#endif // Rice__detail__NativeRegistry__hpp

data/rice/detail/{method_data.ipp → NativeRegistry.ipp}

@@ -6,11 +6,13 @@
 // back to the C-API underneath again.
 #undef rb_define_method_id
 
+#include "RubyFunction.hpp"
+
 namespace Rice::detail
 {
   // Effective Java (2nd edition)
   // https://stackoverflow.com/a/2634715
-  inline size_t MethodData::key(VALUE klass, ID id)
+  inline size_t NativeRegistry::key(VALUE klass, ID id)
   {
     if (rb_type(klass) == T_ICLASS)
     {
@@ -21,18 +23,30 @@ namespace Rice::detail
     return (prime + klass) * prime + id;
   }
 
+  inline void NativeRegistry::add(VALUE klass, ID method_id, std::any callable)
+  {
+    // Now store data about it
+    this->natives_[key(klass, method_id)] = callable;
+  }
+
   template <typename Return_T>
-  inline Return_T MethodData::data()
+  inline Return_T NativeRegistry::lookup()
   {
-    ID id;
+    ID method_id;
     VALUE klass;
-    if (!rb_frame_method_id_and_class(&id, &klass))
+    if (!rb_frame_method_id_and_class(&method_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())
+    return this->lookup<Return_T>(klass, method_id);
+  }
+
+  template <typename Return_T>
+  inline Return_T NativeRegistry::lookup(VALUE klass, ID method_id)
+  {
+    auto iter = this->natives_.find(key(klass, method_id));
+    if (iter == this->natives_.end())
     {
       rb_raise(rb_eRuntimeError, "Could not find data for klass and method id");
     }
@@ -40,14 +54,4 @@ namespace Rice::detail
     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/Registries.hpp

@@ -0,0 +1,26 @@
+#ifndef Rice__Registries__hpp_
+#define Rice__Registries__hpp_
+
+#include "HandlerRegistry.hpp"
+#include "InstanceRegistry.hpp"
+#include "NativeRegistry.hpp"
+#include "TypeRegistry.hpp"
+
+namespace Rice::detail
+{
+  class Registries
+  {
+  public:
+    static Registries instance;
+
+  public:
+    HandlerRegistry handlers;
+    InstanceRegistry instances;
+    NativeRegistry natives;
+    TypeRegistry types;
+  };
+}
+
+#include "Registries.ipp"
+
+#endif // Rice__Registries__hpp_

data/rice/detail/Registries.ipp

@@ -0,0 +1,23 @@
+namespace Rice::detail
+{
+  //Initialize static variables here.
+  inline Registries Registries::instance;
+
+  // TODO - Big hack here but this code is dependent on internals
+  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
+    {
+      return Registries::instance.types.verifyDefined<Intrinsic_T>();
+    }
+  }
+}

data/rice/detail/RubyFunction.hpp

@@ -11,9 +11,12 @@ namespace Rice::detail
      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>
+  template<typename Function_T, typename...Arg_Ts>
   class RubyFunction
   {
+  public:
+    using Return_T = typename function_traits<Function_T>::return_type;
+
   public:
     RubyFunction(Function_T func, const Arg_Ts&... args);
     Return_T operator()();
@@ -23,17 +26,9 @@ namespace Rice::detail
     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);
+  template<typename Function_T, typename ...Arg_Ts>
+  auto protect(Function_T func, Arg_Ts...args);
 }
-
 #include "RubyFunction.ipp"
 
 #endif // Rice__detail__ruby_function__hpp_

data/rice/detail/RubyFunction.ipp

@@ -5,14 +5,14 @@
 
 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)
+  template<typename Function_T, typename...Arg_Ts>
+  inline RubyFunction<Function_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()()
+  template<typename Function_T, typename...Arg_Ts>
+  inline typename RubyFunction<Function_T, Arg_Ts...>::Return_T RubyFunction<Function_T, Arg_Ts...>::operator()()
   {
     const int TAG_RAISE = 0x6; // From Ruby header files
     int state = 0;
@@ -27,8 +27,8 @@ namespace Rice::detail
     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)
+    using Functor_T = RubyFunction<Function_T, Arg_Ts...>;
+    auto callback = [](VALUE value) -> VALUE
     {
       Functor_T* functor = (Functor_T*)value;
 
@@ -58,7 +58,7 @@ namespace Rice::detail
     else
     {
       VALUE err = rb_errinfo();
-      if (state == TAG_RAISE && RTEST(err))
+      if (state == TAG_RAISE && RB_TEST(err))
       {
         rb_set_errinfo(Qnil);
         throw Rice::Exception(err);
@@ -71,22 +71,10 @@ namespace Rice::detail
   }
     
   // 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)
+  template<typename Function_T, typename ...Arg_Ts>
+  auto protect(Function_T func, 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...);
+    auto rubyFunction = RubyFunction<Function_T, Arg_Ts...>(func, std::forward<Arg_Ts>(args)...);
     return rubyFunction();
   }
 }

data/rice/detail/Type.hpp

@@ -3,7 +3,7 @@
 
 #include <string>
 #include <typeinfo>
-#include "rice_traits.hpp"
+#include "../traits/rice_traits.hpp"
 
 namespace Rice::detail
 {

data/rice/detail/Type.ipp

@@ -1,4 +1,4 @@
-#include "rice_traits.hpp"
+#include "../traits/rice_traits.hpp"
 
 #include <iosfwd>
 #include <iterator>
@@ -33,7 +33,7 @@ namespace Rice::detail
   template<typename Tuple_T, size_t...Is>
   void verifyTypesImpl()
   {
-    (Type<intrinsic_type<typename std::tuple_element<Is, Tuple_T>::type>>::verify(), ...);
+    (verifyType<typename std::tuple_element<Is, Tuple_T>::type>(), ...);
   }
 
   template<typename Tuple_T>

data/rice/detail/TypeRegistry.hpp

@@ -9,7 +9,7 @@
 
 #include "ruby.hpp"
 
-/* The type registery keeps track of all C++ types wrapped by Rice. When a native function returns 
+/* The type registry 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
@@ -22,26 +22,23 @@ namespace Rice::detail
   {
   public:
     template <typename T>
-    static void add();
+    void add(VALUE klass, rb_data_type_t* rbType);
 
     template <typename T>
-    static void add(VALUE klass, rb_data_type_t* rbType);
+    void remove();
 
     template <typename T>
-    static void remove();
+    bool isDefined();
 
     template <typename T>
-    static bool isDefined();
-
-    template <typename T>
-    static void verifyDefined();
+    bool verifyDefined();
       
     template <typename T>
-    static std::pair<VALUE, rb_data_type_t*> figureType(const T& object);
+    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_{};
+    std::optional<std::pair<VALUE, rb_data_type_t*>> lookup(const std::type_info& typeInfo);
+    std::unordered_map<std::type_index, std::pair<VALUE, rb_data_type_t*>> registry_{};
   };
 }
 

data/rice/detail/TypeRegistry.ipp

@@ -1,18 +1,11 @@
 #include <stdexcept>
 
 #include "ruby.hpp"
-#include "rice_traits.hpp"
+#include "../traits/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)
   {
@@ -36,13 +29,14 @@ namespace Rice::detail
   }
 
   template <typename T>
-  inline void TypeRegistry::verifyDefined()
+  inline bool TypeRegistry::verifyDefined()
   {
     if (!isDefined<T>())
     {
       std::string message = "Type is not defined with Rice: " + detail::typeName(typeid(T));
       throw std::invalid_argument(message);
     }
+    return true;
   }
 
   inline std::optional<std::pair<VALUE, rb_data_type_t*>> TypeRegistry::lookup(const std::type_info& typeInfo)
@@ -84,23 +78,4 @@ namespace Rice::detail
     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;
-    }
-  }
 }

data/rice/detail/Wrapper.hpp

@@ -35,8 +35,6 @@ T* unwrap(VALUE value, rb_data_type_t* rb_type);
 
 Wrapper* getWrapper(VALUE value, rb_data_type_t* rb_type);
 
-void* unwrap(VALUE value);
-
 template <typename T>
 void replace(VALUE value, rb_data_type_t* rb_type, T* data, bool isOwner);