rice 4.6.1 → 4.7.0

data/rice/detail/MethodInfo.hpp

@@ -29,18 +29,20 @@ namespace Rice
     Arg* arg(std::string name);
 
     int argCount();
+    Return* returnInfo();
+    Function* function();
 
     // Iterator support
     std::vector<Arg>::iterator begin();
     std::vector<Arg>::iterator end();
 
-    Return returnInfo;
-
   private:
     template <typename Arg_T>
     void processArg(const Arg_T& arg);
 
     std::vector<Arg> args_;
+    Return returnInfo_;
+    Function function_;
   };
 }
 #endif // Rice__MethodInfo__hpp_

data/rice/detail/MethodInfo.ipp

@@ -25,16 +25,22 @@ namespace Rice
   template <typename Arg_T>
   inline void MethodInfo::processArg(const 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->returnInfo = arg;
+      this->returnInfo_ = arg;
+    }
+    else if constexpr (std::is_same_v<Arg_T, Function>)
+    {
+      this->function_ = arg;
     }
     else if constexpr (std::is_same_v<Arg_T, Arg>)
     {
       this->addArg(arg);
     }
+    else
+    {
+      static_assert(true, "Unknown argument type");
+    }
   }
 
   inline void MethodInfo::addArg(const Arg& arg)
@@ -71,6 +77,16 @@ namespace Rice
     return nullptr;
   }
 
+  inline Return* MethodInfo::returnInfo()
+  {
+    return &this->returnInfo_;
+  }
+  
+  inline Function* MethodInfo::function()
+  {
+    return &this->function_;
+  }
+
   inline std::vector<Arg>::iterator MethodInfo::begin()
   {
     return this->args_.begin();

data/rice/detail/ModuleRegistry.hpp

@@ -0,0 +1,18 @@
+#ifndef Rice__ModuleRegistry__hpp_
+#define Rice__ModuleRegistry__hpp_
+
+namespace Rice::detail
+{
+  class ModuleRegistry
+  {
+  public:
+    void add(VALUE module);
+    // API for access from Ruby
+    VALUE modules();
+
+  private:
+    std::set<VALUE> modules_{};
+  };
+}
+
+#endif // Rice__ModuleRegistry__hpp_

data/rice/detail/ModuleRegistry.ipp

@@ -0,0 +1,25 @@
+#include <iostream>
+#include <stdexcept>
+#include <sstream>
+#include <typeindex>
+
+
+namespace Rice::detail
+{
+  inline void ModuleRegistry::add(VALUE module)
+  {
+    this->modules_.insert(module);
+  }
+
+  inline VALUE ModuleRegistry::modules()
+  {
+    Array result;
+
+    for (const VALUE& value : this->modules_)
+    {
+      Module module(value);
+      result.push(module, false);
+    }
+    return result;
+  }
+}

data/rice/detail/Native.hpp

@@ -16,17 +16,60 @@ namespace Rice::detail
     Native* native;
   };
 
+  enum class NativeKind
+  {
+    Function,
+    Method,
+    Iterator,
+    AttributeReader,
+    AttributeWriter,
+    Proc
+  };
+
   class Native
   {
   public:
     static VALUE resolve(int argc, VALUE* argv, VALUE self);
   public:
+    Native() = default;
+    Native(std::vector<std::unique_ptr<ParameterAbstract>>&& parameters);
     virtual ~Native() = default;
-    VALUE call(int argc, VALUE* argv, VALUE self);
 
-    virtual Resolved matches(size_t argc, const VALUE* argv, VALUE self) = 0;
+    Native(const Native&) = delete;
+    Native(Native&&) = delete;
+    void operator=(const Native&) = delete;
+    void operator=(Native&&) = delete;
+
+    virtual Resolved matches(size_t argc, const VALUE* argv, VALUE self);
     virtual VALUE operator()(size_t argc, const VALUE* argv, VALUE self) = 0;
     virtual std::string toString() = 0;
+
+    // Ruby API access
+    virtual std::string name() = 0;
+    virtual NativeKind kind() = 0;
+    virtual VALUE returnKlass() = 0;
+    std::vector<const ParameterAbstract*> parameters();
+
+  protected:
+    template<typename T>
+    static void verify_type(bool isBuffer);
+
+    template<typename Tuple_T, std::size_t ...Indices>
+    static void verify_args(MethodInfo* methodInfo, std::index_sequence<Indices...> indices);
+
+    std::vector<std::optional<VALUE>> getRubyValues(size_t argc, const VALUE* argv, bool validate);
+    ParameterAbstract* getParameterByName(std::string name);
+    Convertible matchParameters(std::vector<std::optional<VALUE>>& values);
+
+    template<typename Tuple_T>
+    static std::vector<std::unique_ptr<ParameterAbstract>> create_parameters(MethodInfo* methodInfo);
+
+    template<typename Tuple_T, std::size_t ...Indices>
+    static inline void create_parameters_impl(std::vector<std::unique_ptr<ParameterAbstract>>& parameters, MethodInfo* methodInfo, std::index_sequence<Indices...> indices);
+
+  protected:
+    std::vector<std::unique_ptr<ParameterAbstract>> parameters_;
+
   };
 }
 

data/rice/detail/Native.ipp

@@ -79,7 +79,7 @@ namespace Rice::detail
       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());
+        rb_enc_raise(rb_utf8_encoding(), rb_eArgError, "Could not find method call for %s#%s", rb_class2name(klass), identifier.c_str());
       }
       else
       {
@@ -145,7 +145,7 @@ namespace Rice::detail
               message << "\n     " << resolve.native->toString();
             }
 
-            rb_raise(rb_eArgError, message.str().c_str(), rb_class2name(klass), identifier.c_str(), natives.size());
+            rb_enc_raise(rb_utf8_encoding(), rb_eArgError, message.str().c_str(), rb_class2name(klass), identifier.c_str(), natives.size());
           }
         }
       }
@@ -154,4 +154,198 @@ namespace Rice::detail
       return (*native)(argc, argv, self);
     });
   }
+
+  inline Native::Native(std::vector<std::unique_ptr<ParameterAbstract>>&& parameters) : parameters_(std::move(parameters))
+  {
+  }
+
+  inline ParameterAbstract* Native::getParameterByName(std::string name)
+  {
+    for (std::unique_ptr<ParameterAbstract>& parameter : this->parameters_)
+    {
+      if (parameter->arg->name == name)
+      {
+        return parameter.get();
+      }
+    }
+
+    return nullptr;
+  }
+
+  // -----------  Helpers ----------------
+  template<typename T>
+  inline void Native::verify_type(bool isBuffer)
+  {
+    using Base_T = std::remove_pointer_t<remove_cv_recursive_t<T>>;
+
+    detail::verifyType<T>();
+
+    if constexpr (std::is_pointer_v<T> && std::is_fundamental_v<std::remove_pointer_t<T>>)
+    {
+      Type<Pointer<std::remove_pointer_t<T>>>::verify();
+      Type<Buffer<std::remove_pointer_t<T>>>::verify();
+    }
+    if constexpr (std::is_array_v<T>)
+    {
+      Type<Pointer<std::remove_extent_t<remove_cv_recursive_t<T>>>>::verify();
+      Type<Buffer<std::remove_extent_t<remove_cv_recursive_t<T>>>>::verify();
+    }
+    else if (isBuffer)
+    {
+      if constexpr (std::is_pointer_v<T> && !std::is_function_v<Base_T> && !std::is_abstract_v<Base_T>)
+      {
+        Type<Pointer<Base_T>>::verify();
+        Type<Buffer<Base_T>>::verify();
+      }
+      else
+      {
+        static_assert(true, "Only pointer types can be marked as buffers");
+      }
+    }
+  }
+
+  template<typename Tuple_T, std::size_t ...Indices>
+  inline void Native::verify_args(MethodInfo* methodInfo, std::index_sequence<Indices...> indices)
+  {
+    (Native::verify_type<std::tuple_element_t<Indices, Tuple_T>>(methodInfo->arg(Indices)->isBuffer()), ...);
+  }
+
+  template<typename Tuple_T, std::size_t ...Indices>
+  inline void Native::create_parameters_impl(std::vector<std::unique_ptr<ParameterAbstract>>& parameters, MethodInfo* methodInfo, std::index_sequence<Indices...> indices)
+  {
+    (parameters.push_back(std::move(std::make_unique<Parameter<std::tuple_element_t<Indices, Tuple_T>>>(methodInfo->arg(Indices)))), ...);
+  }
+
+  template<typename Tuple_T>
+  inline std::vector<std::unique_ptr<ParameterAbstract>> Native::create_parameters(MethodInfo* methodInfo)
+  {
+    std::vector<std::unique_ptr<ParameterAbstract>> result;
+    auto indices = std::make_index_sequence<std::tuple_size_v<Tuple_T>>{};
+    Native::create_parameters_impl<Tuple_T>(result, methodInfo, indices);
+    return result;
+  }
+
+  inline std::vector<std::optional<VALUE>> Native::getRubyValues(size_t argc, const VALUE* argv, bool validate)
+  {
+#undef max
+    int size = std::max(this->parameters_.size(), argc);
+    std::vector<std::optional<VALUE>> result(size);
+
+    // Keyword handling
+    if (rb_keyword_given_p())
+    {
+      // Keywords are stored in the last element in a hash
+      int actualArgc = argc - 1;
+
+      VALUE value = argv[actualArgc];
+      Hash keywords(value);
+
+      // Copy over leading non-keyword arguments
+      for (int i = 0; i < actualArgc; i++)
+      {
+        result[i] = argv[i];
+      }
+
+      // Copy over keyword arguments
+      for (auto pair : keywords)
+      {
+        Symbol key(pair.first);
+        ParameterAbstract* parameter = this->getParameterByName(key.str());
+        if (!parameter)
+        {
+          throw std::invalid_argument("Unknown keyword: " + key.str());
+        }
+
+        const Arg* arg = parameter->arg;
+
+        result[arg->position] = pair.second.value();
+      }
+    }
+    else
+    {
+      std::copy(argv, argv + argc, result.begin());
+    }
+
+    // Block handling. If we find a block and the last parameter is missing then
+    // set it to the block
+    if (rb_block_given_p() && result.size() > 0 && !result.back().has_value())
+    {
+      VALUE proc = rb_block_proc();
+      result.back() = proc;
+    }
+
+    if (validate)
+    {
+      // Protect against user sending too many arguments
+      if (argc > this->parameters_.size())
+      {
+        std::string message = "wrong number of arguments (given " +
+          std::to_string(argc) + ", expected " + std::to_string(this->parameters_.size()) + ")";
+        throw std::invalid_argument(message);
+      }
+
+      for (size_t i = 0; i < result.size(); i++)
+      {
+        std::optional<VALUE> value = result[i];
+        ParameterAbstract* parameter = this->parameters_[i].get();
+
+        if (!parameter->arg->hasDefaultValue() && !value.has_value())
+        {
+          std::string message;
+          message = "Missing argument. Name: " + parameter->arg->name + ". Index: " + std::to_string(parameter->arg->position) + ".";
+          throw std::invalid_argument(message);
+        }
+      }
+    }
+
+    return result;
+  }
+
+  inline Convertible Native::matchParameters(std::vector<std::optional<VALUE>>& values)
+  {
+    Convertible result = Convertible::Exact;
+    for (size_t i = 0; i < this->parameters_.size(); i++)
+    {
+      ParameterAbstract* parameter = this->parameters_[i].get();
+      std::optional<VALUE>& value = values[i];
+      result = result & parameter->matches(value);
+    }
+    return result;
+  }
+
+  inline Resolved Native::matches(size_t argc, const VALUE* argv, VALUE self)
+  {
+    // Return false if Ruby provided more arguments than the C++ method takes
+    if (argc > this->parameters_.size())
+      return Resolved{ Convertible::None, 0, this };
+
+    Resolved result{ Convertible::Exact, 1, this };
+
+    std::vector<std::optional<VALUE>> rubyValues = this->getRubyValues(argc, argv, false);
+    result.convertible = this->matchParameters(rubyValues);
+
+    if (this->parameters_.size() > 0)
+    {
+      int providedValues = std::count_if(rubyValues.begin(), rubyValues.end(), [](std::optional<VALUE>& value)
+        {
+          return value.has_value();
+        });
+
+      result.parameterMatch = providedValues / (double)this->parameters_.size();
+    }
+    return result;
+  }
+
+  inline std::vector<const ParameterAbstract*> Native::parameters()
+  {
+    std::vector<const ParameterAbstract*> result;
+
+    std::transform(this->parameters_.begin(), this->parameters_.end(), std::back_inserter(result),
+      [](std::unique_ptr<ParameterAbstract>& parameter) -> ParameterAbstract*
+      {
+        return parameter.get();
+      });
+      
+    return result;
+  }
 }

data/rice/detail/NativeAttributeGet.hpp

@@ -18,13 +18,13 @@ namespace Rice
     public:
       using NativeAttribute_T = NativeAttributeGet<Attribute_T>;
 
-      using T = typename attribute_traits<Attribute_T>::attr_type;
+      using Attr_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>;
+      using To_Ruby_T = remove_cv_recursive_t<Attr_T>;
 
     public:
       // Register attribute getter with Ruby
-      static void define(VALUE klass, std::string name, Attribute_T attribute);
+      static void define(VALUE klass, std::string name, Attribute_T attribute, Return returnInfo);
 
     public:
       // Disallow creating/copying/moving
@@ -38,13 +38,18 @@ namespace Rice
       VALUE operator()(size_t argc, const VALUE* argv, VALUE self) override;
       std::string toString() override;
 
+      std::string name() override;
+      NativeKind kind() override;
+      VALUE returnKlass() override;
+
     protected:
-      NativeAttributeGet(VALUE klass, std::string name, Attribute_T attr);
+      NativeAttributeGet(VALUE klass, std::string name, Attribute_T attr, Return returnInfo);
 
     private:
       VALUE klass_;
       std::string name_;
       Attribute_T attribute_;
+      Return return_;
     };
   } // detail
 } // Rice

data/rice/detail/NativeAttributeGet.ipp

@@ -1,14 +1,16 @@
 #include <array>
 #include <algorithm>
 
-
 namespace Rice::detail
 {
   template<typename Attribute_T>
-  void NativeAttributeGet<Attribute_T>::define(VALUE klass, std::string name, Attribute_T attribute)
+  void NativeAttributeGet<Attribute_T>::define(VALUE klass, std::string name, Attribute_T attribute, Return returnInfo)
   {
+    // Verify attribute type
+    Native::verify_type<Attr_T>(returnInfo.isBuffer());
+
     // 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));
+    NativeAttribute_T* nativeAttribute = new NativeAttribute_T(klass, name, std::forward<Attribute_T>(attribute), returnInfo);
     std::unique_ptr<Native> native(nativeAttribute);
 
     detail::protect(rb_define_method, klass, name.c_str(), (RUBY_METHOD_FUNC)&Native::resolve, -1);
@@ -30,8 +32,8 @@ namespace Rice::detail
   }
   
   template<typename Attribute_T>
-  NativeAttributeGet<Attribute_T>::NativeAttributeGet(VALUE klass, std::string name, Attribute_T attribute)
-    : klass_(klass), name_(name), attribute_(attribute)
+  NativeAttributeGet<Attribute_T>::NativeAttributeGet(VALUE klass, std::string name, Attribute_T attribute, Return returnInfo)
+    : klass_(klass), name_(name), attribute_(attribute), return_(returnInfo)
   {
   }
 
@@ -42,21 +44,45 @@ namespace Rice::detail
     {
       Receiver_T* nativeSelf = From_Ruby<Receiver_T*>().convert(self);
 
-      if constexpr (std::is_fundamental_v<detail::intrinsic_type<To_Ruby_T>> ||
-                    (std::is_array_v<To_Ruby_T> && std::is_fundamental_v<std::remove_extent_t<To_Ruby_T>>))
+      if constexpr (std::is_fundamental_v<detail::intrinsic_type<To_Ruby_T>>)
       {
-        return To_Ruby<To_Ruby_T>().convert(nativeSelf->*attribute_);
+        return To_Ruby<To_Ruby_T>(&this->return_).convert(nativeSelf->*attribute_);
+      }
+      else if constexpr (std::is_array_v<To_Ruby_T>)
+      {
+        return To_Ruby<To_Ruby_T>(&this->return_).convert(nativeSelf->*attribute_);
+      }
+      else if constexpr (std::is_pointer_v<To_Ruby_T>)
+      {
+        return To_Ruby<To_Ruby_T>(&this->return_).convert(nativeSelf->*attribute_);
       }
       else
       {
         // If the attribute is an object return a reference to avoid a copy (and avoid issues with
         // attributes that are not assignable, copy constructible or move constructible)
-        return To_Ruby<To_Ruby_T&>().convert(nativeSelf->*attribute_);
+        return To_Ruby<To_Ruby_T&>(&this->return_).convert(nativeSelf->*attribute_);
       }
     }
     else
     {
-      return To_Ruby<To_Ruby_T>().convert(*attribute_);
+      if constexpr (std::is_fundamental_v<detail::intrinsic_type<To_Ruby_T>>)
+      {
+        return To_Ruby<To_Ruby_T>(&this->return_).convert(*attribute_);
+      }
+      else if constexpr (std::is_array_v<To_Ruby_T>)
+      {
+        return To_Ruby<To_Ruby_T>(&this->return_).convert(*attribute_);
+      }
+      else if constexpr (std::is_pointer_v<To_Ruby_T>)
+      {
+        return To_Ruby<To_Ruby_T>(&this->return_).convert(*attribute_);
+      }
+      else
+      {
+        // If the attribute is an object return a reference to avoid a copy (and avoid issues with
+        // attributes that are not assignable, copy constructible or move constructible)
+        return To_Ruby<To_Ruby_T&>(&this->return_).convert(*attribute_);
+      }
     }
   }
 
@@ -65,4 +91,32 @@ namespace Rice::detail
   {
     return "";
   }
-} // Rice
+
+  template<typename Attribute_T>
+  inline std::string NativeAttributeGet<Attribute_T>::name()
+  {
+    return this->name_;
+  }
+
+  template<typename Attribute_T>
+  inline NativeKind NativeAttributeGet<Attribute_T>::kind()
+  {
+    return NativeKind::AttributeReader;
+  }
+
+  template<typename Attribute_T>
+  inline VALUE NativeAttributeGet<Attribute_T>::returnKlass()
+  {
+    // Check if an array is being returned
+    if (this->return_.isBuffer())
+    {
+      TypeMapper<Pointer<Attr_T>> typeMapper;
+      return typeMapper.rubyKlass();
+    }
+    else
+    {
+      TypeMapper<Attr_T> typeMapper;
+      return typeMapper.rubyKlass();
+    }
+  }
+}

data/rice/detail/NativeAttributeSet.hpp

@@ -30,6 +30,10 @@ namespace Rice
       VALUE operator()(size_t argc, const VALUE* argv, VALUE self) override;
       std::string toString() override;
 
+      std::string name() override;
+      NativeKind kind() override;
+      VALUE returnKlass() override;
+
     protected:
       NativeAttributeSet(VALUE klass, std::string name, Attribute_T attr);
 

data/rice/detail/NativeAttributeSet.ipp

@@ -52,7 +52,16 @@ namespace Rice::detail
     if constexpr (!std::is_null_pointer_v<Receiver_T>)
     {
       Receiver_T* nativeSelf = From_Ruby<Receiver_T*>().convert(self);
-      nativeSelf->*attribute_ = From_Ruby<T_Unqualified>().convert(value);
+
+      // Deal with pointers to pointes, see Parameter::convertToNative commment
+      if constexpr (is_pointer_pointer_v<Attr_T> && !std::is_convertible_v<remove_cv_recursive_t<Attr_T>, Attr_T>)
+      {
+        nativeSelf->*attribute_ = (Attr_T)From_Ruby<T_Unqualified>().convert(value);
+      }
+      else
+      {
+        nativeSelf->*attribute_ = From_Ruby<T_Unqualified>().convert(value);
+      }
     }
     else
     {
@@ -67,4 +76,23 @@ namespace Rice::detail
   {
     return "";
   }
-} // Rice
+
+  template<typename Attribute_T>
+  inline std::string NativeAttributeSet<Attribute_T>::name()
+  {
+    return this->name_;
+  }
+
+  template<typename Attribute_T>
+  inline NativeKind NativeAttributeSet<Attribute_T>::kind()
+  {
+    return NativeKind::AttributeWriter;
+  }
+
+  template<typename Attribute_T>
+  inline VALUE NativeAttributeSet<Attribute_T>::returnKlass()
+  {
+    TypeMapper<Attr_T> typeMapper;
+    return typeMapper.rubyKlass();
+  }
+}

data/rice/detail/NativeCallbackFFI.ipp

@@ -64,7 +64,7 @@ namespace Rice::detail
        on the arguments (Arg_Ts) required by the C++ function. Arg_T may have const/volatile while
        the associated From_Ruby<T> template parameter will not. Thus From_Ruby produces non-const values
        which we let the compiler convert to const values as needed. This works except for
-       T** -> const T**, see comment in getNativeValue method. */
+       T** -> const T**, see comment in convertToNative method. */
     return std::forward_as_tuple(*(std::tuple_element_t<I, Tuple_T>*)(args[I])...);
   }
 
@@ -137,7 +137,7 @@ namespace Rice::detail
     VALUE result = detail::protect(rb_funcallv, this->proc_, id.id(), (int)sizeof...(Arg_Ts), values.data());
     if constexpr (!std::is_void_v<Return_T>)
     {
-      static From_Ruby<Return_T> fromRuby(dynamic_cast<Arg*>(&methodInfo_->returnInfo));
+      static From_Ruby<Return_T> fromRuby(dynamic_cast<Arg*>(methodInfo_->returnInfo()));
       return fromRuby.convert(result);
     }
   }

data/rice/detail/NativeCallbackSimple.ipp

@@ -15,7 +15,7 @@ namespace Rice::detail
     VALUE result = detail::protect(rb_funcallv, proc, id.id(), (int)sizeof...(Arg_Ts), values.data());
     if constexpr (!std::is_void_v<Return_T>)
     {
-      static From_Ruby<Return_T> fromRuby(dynamic_cast<Arg*>(&methodInfo_->returnInfo));
+      static From_Ruby<Return_T> fromRuby(dynamic_cast<Arg*>(methodInfo_->returnInfo()));
       return fromRuby.convert(result);
     }
   }