rice 4.3.3 → 4.6.0

data/rice/detail/HandlerRegistry.hpp

@@ -1,51 +1,21 @@
 #ifndef Rice__detail__HandlerRegistry__hpp_
 #define Rice__detail__HandlerRegistry__hpp_
 
-#include "ExceptionHandler.hpp"
+#include <functional>
 
 namespace Rice::detail
 {
   class HandlerRegistry
   {
   public:
-    //! Define an exception handler.
-    /*! Whenever an exception of type Exception_T is thrown from a
-     *  function defined on this class, the supplied functor will be called to
-     *  translate the exception into a ruby exception.
-     *  \param Exception_T a template parameter indicating the type of
-     *  exception to be translated.
-     *  \param functor a functor to be called to translate the exception
-     *  into a ruby exception.  This functor should re-throw the exception
-     *  as an Exception.
-     *  Example:
-     *  \code
-     *    Class rb_cFoo;
-     *
-     *    void translate_my_exception(MyException const& ex)
-     *    {
-     *       throw Rice::Exception(rb_eRuntimeError, ex.what_without_backtrace());
-     *    }
-     *
-     *    extern "C"
-     *    void Init_MyExtension()
-     *    {
-     *      rb_cFoo = define_class("Foo");
-     *      register_handler<MyException>(translate_my_exception);
-     *    }
-     *  \endcode
-     */
-    template<typename Exception_T, typename Functor_T>
-    HandlerRegistry& add(Functor_T functor);
-
-    std::shared_ptr<detail::ExceptionHandler> handler() const;
+    HandlerRegistry();
+    void set(std::function<void()> handler);
+    std::function<void()> handler() const;
 
   private:
-    mutable std::shared_ptr<detail::ExceptionHandler> handler_ = std::make_shared<Rice::detail::DefaultExceptionHandler>();
-
+    std::function<void()> handler_;
   };
 } // namespace Rice::detail
 
-#include "HandlerRegistry.ipp"
-
 #endif // Rice__detail__HandlerRegistry__hpp_
 

data/rice/detail/HandlerRegistry.ipp

@@ -1,20 +1,16 @@
-#include <memory>
-
 namespace Rice::detail
 {
-  template<typename Exception_T, typename Functor_T>
-  inline HandlerRegistry& HandlerRegistry::add(Functor_T functor)
+  inline HandlerRegistry::HandlerRegistry() : handler_(DefaultHandler())
   {
-    // Create a new exception handler and pass ownership of the current handler to it (they
-    // get chained together). Then take ownership of the new handler.
-    this->handler_ = std::make_shared<detail::CustomExceptionHandler<Exception_T, Functor_T>>(
-      functor, std::move(this->handler_));
+  }
 
-    return *this;
+  inline void HandlerRegistry::set(std::function<void()> handler)
+  {
+    this->handler_ = handler;
   }
 
-  inline std::shared_ptr<detail::ExceptionHandler> HandlerRegistry::handler() const
+  inline std::function<void()> HandlerRegistry::handler() const
   {
     return this->handler_;
   }
-} // namespace
+}

data/rice/detail/InstanceRegistry.hpp

@@ -2,7 +2,6 @@
 #define Rice__detail__InstanceRegistry__hpp_
 
 #include <map>
-#include "ruby.hpp"
 
 namespace Rice::detail
 {
@@ -14,6 +13,7 @@ namespace Rice::detail
 
     template <typename T>
     VALUE lookup(T* cppInstance);
+    VALUE lookup(void* cppInstance);
 
     void add(void* cppInstance, VALUE rubyInstance);
     void remove(void* cppInstance);
@@ -23,12 +23,9 @@ namespace Rice::detail
     bool isEnabled = false;
 
   private:
-    VALUE lookup(void* cppInstance);
     std::map<void*, VALUE> objectMap_;
   };
 } // namespace Rice::detail
 
-#include "InstanceRegistry.ipp"
-
 #endif // Rice__detail__InstanceRegistry__hpp_
 

data/rice/detail/MethodInfo.hpp

@@ -2,29 +2,33 @@
 #define Rice__MethodInfo__hpp_
 
 #include <vector>
-#include "../Arg.hpp"
-#include "../Return.hpp"
 
 namespace Rice
 {
   class MethodInfo
   {
   public:
+    MethodInfo() = default;
+
     template <typename...Arg_Ts>
     MethodInfo(size_t argCount, const Arg_Ts&...args);
 
     /**
-      * Get the rb_scan_args format string for this
-      * list of arguments.
+      * Add a defined Arg to this list of Arguments
       */
-    std::string formatString();
+    void addArg(const Arg& arg);
 
     /**
-      * Add a defined Arg to this list of Arguments
+      * Get argument by position
       */
-    void addArg(const Arg& arg);
+    Arg* arg(size_t pos);
 
-    Arg& arg(size_t pos);
+    /**
+      * Get argument by name
+      */
+    Arg* arg(std::string name);
+
+    int argCount();
 
     // Iterator support
     std::vector<Arg>::iterator begin();
@@ -39,6 +43,4 @@ namespace Rice
     std::vector<Arg> args_;
   };
 }
-#include "MethodInfo.ipp"
-
 #endif // Rice__MethodInfo__hpp_

data/rice/detail/MethodInfo.ipp

@@ -1,5 +1,4 @@
 #include <sstream>
-#include "from_ruby_defn.hpp"
 
 namespace Rice
 {
@@ -26,13 +25,15 @@ namespace Rice
   template <typename Arg_T>
   inline void MethodInfo::processArg(const Arg_T& arg)
   {
-    if constexpr (std::is_same_v<Arg_T, Arg>)
+    static_assert(std::is_same_v<Arg_T, Return> || std::is_same_v<Arg_T, Arg>, "Unknown argument type");
+
+    if constexpr (std::is_same_v<Arg_T, Return>)
     {
-      this->addArg(arg);
+      this->returnInfo = arg;
     }
-    else
+    else if constexpr (std::is_same_v<Arg_T, Arg>)
     {
-      this->returnInfo = arg;
+      this->addArg(arg);
     }
   }
 
@@ -41,29 +42,33 @@ namespace Rice
     this->args_.push_back(arg);
   }
 
-  inline std::string MethodInfo::formatString()
+  inline int MethodInfo::argCount()
   {
-    size_t required = 0;
-    size_t optional = 0;
+    return this->args_.size();
+  }
 
-    for (const Arg& arg : this->args_)
+  inline Arg* MethodInfo::arg(size_t pos)
+  {
+    if (pos < this->args_.size())
     {
-      if (arg.hasDefaultValue())
-      {
-        optional++;
-      }
-      else
-      {
-        required++;
-      }
+      return &this->args_[pos];
+    }
+    else
+    {
+      return nullptr;
     }
-
-    return std::to_string(required) + std::to_string(optional);
   }
 
-  inline Arg& MethodInfo::arg(size_t pos)
+  inline Arg* MethodInfo::arg(std::string name)
   {
-    return args_[pos];
+    for (Arg& arg : this->args_)
+    {
+      if (arg.name == name)
+      {
+        return &arg;
+      }
+    }
+    return nullptr;
   }
 
   inline std::vector<Arg>::iterator MethodInfo::begin()

data/rice/detail/Native.hpp

@@ -0,0 +1,33 @@
+#ifndef Rice__detail__Native__hpp_
+#define Rice__detail__Native__hpp_
+
+namespace Rice::detail
+{
+  class Native;
+
+  class Resolved
+  {
+  public:
+    inline bool operator<(Resolved other);
+    inline bool operator>(Resolved other);
+
+    Convertible convertible;
+    double parameterMatch;
+    Native* native;
+  };
+
+  class Native
+  {
+  public:
+    static VALUE resolve(int argc, VALUE* argv, VALUE self);
+  public:
+    virtual ~Native() = default;
+    VALUE call(int argc, VALUE* argv, VALUE self);
+
+    virtual Resolved matches(size_t argc, const VALUE* argv, VALUE self) = 0;
+    virtual VALUE operator()(size_t argc, const VALUE* argv, VALUE self) = 0;
+    virtual std::string toString() = 0;
+  };
+}
+
+#endif // Rice__detail__Native__hpp_

data/rice/detail/Native.ipp

@@ -0,0 +1,157 @@
+
+namespace Rice::detail
+{
+  inline bool Resolved::operator<(Resolved other)
+  {
+    if (this->convertible != other.convertible)
+    {
+      return this->convertible < other.convertible;
+    }
+    else
+    {
+      return this->parameterMatch < other.parameterMatch;
+    }
+  }
+
+  inline bool Resolved::operator>(Resolved other)
+  {
+    if (this->convertible != other.convertible)
+    {
+      return this->convertible > other.convertible;
+    }
+    else
+    {
+      return this->parameterMatch > other.parameterMatch;
+    }
+  }
+
+  inline VALUE Native::resolve(int argc, VALUE* argv, VALUE self)
+  {
+    /* This method is called from Ruby and is responsible for determining the correct
+       Native object (ie, NativeFunction, NativeIterator, NativeAttributeGet and 
+       NativeAttributeSet) that shoudl be used to invoke the underlying C++ code.
+       Most of the time there will be a single Native object registered for a C++ function,
+       method, constructor, iterator or attribute. However, there can be multiple Natives 
+       when a C++ function/method/construtor is overloaded.
+
+       In that case, the code iterates over each Native and calls its matches method. The matches
+       method returns a Resolved object which includes a Convertible field and parameterMatch field.
+       The Convertible field is an enum that specifies if the types of the values supplied by Ruby
+       match the types of the C++ function parameters. Allowed values include  can be Exact (example Ruby into to C++ int),
+       TypeCast (example Ruby into to C++ float) or None (cannot be converted). 
+
+       The parameterMatch field is simply the number or arguments provided by Ruby divided by the
+       number of arguments required by C++. These numbers can be different because C++ method 
+       parameters can have default values.
+
+       Taking these two values into account, the method sorts the Natives and picks the one with the 
+       highest score (Convertible::Exact and 1.0 for parameterMatch). Thus given these two C++ functions:
+
+       void some_method(int a);
+       void some_mtehod(int a, float b = 2.0).
+
+       A call from ruby of some_method(1) will exactly match both signatures, but the first one 
+       will be chosen because the parameterMatch will be 1.0 for the first overload but 0.5
+       for the second. */
+
+    Native* native = nullptr;
+
+    ID methodId;
+    VALUE klass;
+    if (!rb_frame_method_id_and_class(&methodId, &klass))
+    {
+      rb_raise(rb_eRuntimeError, "Cannot get method id and class for function");
+    }
+
+    // Execute the function but make sure to catch any C++ exceptions!
+    return cpp_protect([&]
+    {
+      Identifier id(methodId);
+      std::string methodName = id.str();
+      std::string className = rb_class2name(klass);
+
+      const std::vector<std::unique_ptr<Native>>& natives = Registries::instance.natives.lookup(klass, methodId);
+
+      if (natives.size() == 1)
+      {
+        native = natives.front().get();
+      }
+      else if (natives.size() == 0)
+      {
+        Identifier identifier(methodId);
+        rb_raise(rb_eArgError, "Could not find method call for %s#%s", rb_class2name(klass), identifier.c_str());
+      }
+      else
+      {
+        Identifier identifier(methodId);
+
+        // Loop over every native to see how well they match the Ruby parameters
+        std::vector<Resolved> resolves;
+        std::transform(natives.begin(), natives.end(), 
+          std::back_inserter(resolves), 
+          [&](const std::unique_ptr<Native>& native)
+          {
+            return native->matches(argc, argv, self);
+          });
+
+        // Now sort from best to worst
+        std::sort(resolves.begin(), resolves.end(), std::greater{});
+
+        // Get the first one
+        Resolved resolved = resolves.front();
+
+        // Was there more than one match?
+        /*size_t count = std::count_if(resolves.begin(), resolves.end(),
+          [&resolved](Resolved& element)
+          {
+            return resolved.convertible == element.convertible;
+          });
+
+        if (count > 1)
+        {
+          std::ostringstream message;
+          message << "Could not resolve method call for %s#%s" << "\n"
+                  << "  %d overloaded functions matched based on the types of Ruby parameters provided:";
+
+          for (int i = 0; i < count; i++)
+          {
+            message << "\n     " << resolves[i].native->toString();
+          }
+          
+          rb_raise(rb_eArgError, message.str().c_str(), rb_class2name(klass), identifier.c_str(), count);
+        }*/
+
+        // Did it match?
+        if (resolved.convertible != Convertible::None)
+        {
+          native = resolved.native;
+        }
+        else
+        {
+          // Special case == to make the RubyMine debugger work. It calls == with a Module as
+          // the other argument, thus breaking if C++ operator== is implemented.
+          if (identifier.str() == "==")
+          {
+            return detail::protect(rb_call_super, argc, argv);
+          }
+          else
+          {
+            std::ostringstream message;
+            message << "Could not resolve method call for %s#%s" << "\n"
+                    << "  %d overload(s) were evaluated based on the types of Ruby parameters provided:";
+
+            for (Resolved& resolve: resolves)
+            {
+              message << "\n     " << resolve.native->toString();
+            }
+
+            rb_raise(rb_eArgError, message.str().c_str(), rb_class2name(klass), identifier.c_str(), natives.size());
+          }
+        }
+      }
+
+      // Call the C++ function
+      return (*native)(argc, argv, self);
+    });
+  }
+}

data/rice/detail/NativeAttributeGet.hpp

@@ -0,0 +1,52 @@
+#ifndef Rice__detail__Native_Attribute_Get__hpp_
+#define Rice__detail__Native_Attribute_Get__hpp_
+
+namespace Rice
+{
+  enum class AttrAccess
+  {
+    ReadWrite,
+    Read,
+    Write
+  };
+
+  namespace detail
+  {
+    template<typename Attribute_T>
+    class NativeAttributeGet: Native
+    {
+    public:
+      using NativeAttribute_T = NativeAttributeGet<Attribute_T>;
+
+      using T = typename attribute_traits<Attribute_T>::attr_type;
+      using Receiver_T = typename attribute_traits<Attribute_T>::class_type;
+      using To_Ruby_T = remove_cv_recursive_t<T>;
+
+    public:
+      // Register attribute getter with Ruby
+      static void define(VALUE klass, std::string name, Attribute_T attribute);
+
+    public:
+      // Disallow creating/copying/moving
+      NativeAttributeGet() = delete;
+      NativeAttributeGet(const NativeAttribute_T&) = delete;
+      NativeAttributeGet(NativeAttribute_T&&) = delete;
+      void operator=(const NativeAttribute_T&) = delete;
+      void operator=(NativeAttribute_T&&) = delete;
+
+      Resolved matches(size_t argc, const VALUE* argv, VALUE self) override;
+      VALUE operator()(size_t argc, const VALUE* argv, VALUE self) override;
+      std::string toString() override;
+
+    protected:
+      NativeAttributeGet(VALUE klass, std::string name, Attribute_T attr);
+
+    private:
+      VALUE klass_;
+      std::string name_;
+      Attribute_T attribute_;
+    };
+  } // detail
+} // Rice
+
+#endif // Rice__detail__Native_Attribute_Get__hpp_

data/rice/detail/NativeAttributeGet.ipp

@@ -0,0 +1,57 @@
+#include <array>
+#include <algorithm>
+
+
+namespace Rice::detail
+{
+  template<typename Attribute_T>
+  void NativeAttributeGet<Attribute_T>::define(VALUE klass, std::string name, Attribute_T attribute)
+  {
+    // Create a NativeAttributeGet that Ruby will call to read/write C++ variables
+    NativeAttribute_T* nativeAttribute = new NativeAttribute_T(klass, name, std::forward<Attribute_T>(attribute));
+    std::unique_ptr<Native> native(nativeAttribute);
+
+    detail::protect(rb_define_method, klass, name.c_str(), (RUBY_METHOD_FUNC)&Native::resolve, -1);
+
+    // Add to native registry. Since attributes cannot be overridden, there is no need to set the
+    // matches or calls function pointer. Instead Ruby can call the static call method defined on
+    // this class (&NativeAttribute_T::get).
+    Identifier identifier(name);
+    detail::Registries::instance.natives.add(klass, identifier.id(), native);
+  }
+
+  template<typename Attribute_T>
+  inline Resolved NativeAttributeGet<Attribute_T>::matches(size_t argc, const VALUE* argv, VALUE self)
+  {
+    if (argc == 0)
+      return Resolved { Convertible::Exact, 1, this };
+    else
+      return Resolved{ Convertible::None, 0, this };
+  }
+  
+  template<typename Attribute_T>
+  NativeAttributeGet<Attribute_T>::NativeAttributeGet(VALUE klass, std::string name, Attribute_T attribute)
+    : klass_(klass), name_(name), attribute_(attribute)
+  {
+  }
+
+  template<typename Attribute_T>
+  inline VALUE NativeAttributeGet<Attribute_T>::operator()(size_t argc, const VALUE* argv, VALUE self)
+  {
+    if constexpr (std::is_member_object_pointer_v<Attribute_T>)
+    {
+      Receiver_T* nativeSelf = From_Ruby<Receiver_T*>().convert(self);
+      return To_Ruby<To_Ruby_T>().convert(nativeSelf->*attribute_);
+    }
+    else
+    {
+      return To_Ruby<To_Ruby_T>().convert(*attribute_);
+    }
+  }
+
+  template<typename Attribute_T>
+  inline std::string NativeAttributeGet<Attribute_T>::toString()
+  {
+    return "";
+  }
+} // Rice

data/rice/detail/NativeAttributeSet.hpp

@@ -0,0 +1,44 @@
+#ifndef Rice__detail__Native_Attribute_Set__hpp_
+#define Rice__detail__Native_Attribute_Set__hpp_
+
+namespace Rice
+{
+  namespace detail
+  {
+    template<typename Attribute_T>
+    class NativeAttributeSet: Native
+    {
+    public:
+      using NativeAttribute_T = NativeAttributeSet<Attribute_T>;
+      using Attr_T = typename attribute_traits<Attribute_T>::attr_type;
+      using T_Unqualified = remove_cv_recursive_t<Attr_T>;
+      using Receiver_T = typename attribute_traits<Attribute_T>::class_type;
+
+    public:
+      // Register attribute getter/setter with Ruby
+      static void define(VALUE klass, std::string name, Attribute_T attribute);
+
+    public:
+      // Disallow creating/copying/moving
+      NativeAttributeSet() = delete;
+      NativeAttributeSet(const NativeAttribute_T&) = delete;
+      NativeAttributeSet(NativeAttribute_T&&) = delete;
+      void operator=(const NativeAttribute_T&) = delete;
+      void operator=(NativeAttribute_T&&) = delete;
+
+      Resolved matches(size_t argc, const VALUE* argv, VALUE self) override;
+      VALUE operator()(size_t argc, const VALUE* argv, VALUE self) override;
+      std::string toString() override;
+
+    protected:
+      NativeAttributeSet(VALUE klass, std::string name, Attribute_T attr);
+
+    private:
+      VALUE klass_;
+      std::string name_;
+      Attribute_T attribute_;
+    };
+  } // detail
+} // Rice
+
+#endif // Rice__detail__Native_Attribute_Set__hpp_

data/rice/detail/NativeAttributeSet.ipp

@@ -0,0 +1,88 @@
+#include <array>
+#include <algorithm>
+
+
+namespace Rice::detail
+{
+  template<typename Attribute_T>
+  void NativeAttributeSet<Attribute_T>::define(VALUE klass, std::string name, Attribute_T attribute)
+  {
+    // Create a NativeAttributeSet that Ruby will call to read/write C++ variables
+    NativeAttribute_T* nativeAttribute = new NativeAttribute_T(klass, name, std::forward<Attribute_T>(attribute));
+    std::unique_ptr<Native> native(nativeAttribute);
+
+    // Define the write method name
+    std::string setter = name + "=";
+
+    // Tell Ruby to invoke the static method write to get the attribute value
+    detail::protect(rb_define_method, klass, setter.c_str(), (RUBY_METHOD_FUNC)&Native::resolve, -1);
+
+    // Add to native registry. Since attributes cannot be overridden, there is no need to set the
+    // matches or calls function pointer. Instead Ruby can call the static call method defined on
+    // this class (&NativeAttribute_T::set).
+    Identifier identifier(setter);
+    detail::Registries::instance.natives.add(klass, identifier.id(), native);
+  }
+
+  template<typename Attribute_T>
+  NativeAttributeSet<Attribute_T>::NativeAttributeSet(VALUE klass, std::string name, Attribute_T attribute)
+    : klass_(klass), name_(name), attribute_(attribute)
+  {
+  }
+
+  template<typename Attribute_T>
+  inline Resolved NativeAttributeSet<Attribute_T>::matches(size_t argc, const VALUE* argv, VALUE self)
+  {
+    if (argc == 1)
+      return Resolved{ Convertible::Exact, 1, this };
+    else
+      return Resolved{ Convertible::None, 0, this };
+  }
+
+  template<typename Attribute_T>
+  inline VALUE NativeAttributeSet<Attribute_T>::operator()(size_t argc, const VALUE* argv, VALUE self)
+  {
+    if constexpr (std::is_fundamental_v<intrinsic_type<Attr_T>> && std::is_pointer_v<Attr_T>)
+    {
+      static_assert(true, "An fundamental value, such as an integer, cannot be assigned to an attribute that is a pointer.");
+    }
+    else if constexpr (std::is_same_v<intrinsic_type<Attr_T>, std::string> && std::is_pointer_v<Attr_T>)
+    {
+      static_assert(true, "An string cannot be assigned to an attribute that is a pointer.");
+    }
+
+    if (argc != 1)
+    {
+      throw std::runtime_error("Incorrect number of parameters for setting attribute. Attribute: " + this->name_);
+    }
+
+    VALUE value = argv[0];
+    
+    if constexpr (!std::is_null_pointer_v<Receiver_T> && 
+                  !std::is_const_v<Attr_T> && 
+                  (std::is_fundamental_v<Attr_T> || std::is_assignable_v<Attr_T, Attr_T>))
+    {
+      Receiver_T* nativeSelf = From_Ruby<Receiver_T*>().convert(self);
+      nativeSelf->*attribute_ = From_Ruby<T_Unqualified>().convert(value);
+    }
+    else if constexpr (std::is_null_pointer_v<Receiver_T> && 
+                       !std::is_const_v<Attr_T> &&
+                       (std::is_fundamental_v<Attr_T> || std::is_assignable_v<Attr_T, Attr_T>))
+    {
+      *attribute_ = From_Ruby<T_Unqualified>().convert(value);
+    }
+    else
+    {
+      // Should never get here because define_attr won't compile this code, but just in case!
+      throw std::invalid_argument("Could not set attribute. Attribute: " + this->name_);
+    }
+
+    return value;
+  }
+
+  template<typename Attribute_T>
+  inline std::string NativeAttributeSet<Attribute_T>::toString()
+  {
+    return "";
+  }
+} // Rice