rice 4.5.0 → 4.6.0

data/rice/cpp_api/Struct.hpp

@@ -0,0 +1,113 @@
+#ifndef Rice__ruby_struct__hpp_
+#define Rice__ruby_struct__hpp_
+
+namespace Rice
+{
+  //! A wrapper for creating Struct classes.
+  /*! The Struct class is used for creating new Classes.  Note that the
+   *  notation used here differs slightly from the notation inside the
+   *  interpreter.
+   *
+   *  Inside the interpreter, calling Struct.new creates a new Class:
+   *  \code
+   *  irb(main):001:0> MyStruct = Struct.new(:a, :b, :c)
+   *  => S
+   *  irb(main):002:0> MyStruct.class
+   *  => Class
+   *  \endcode
+   *
+   *  Instantiating that Class creates an instance of that Class:
+   *  \code
+   *  irb(main):003:0> mystruct_instance = MyStruct.new
+   *  => #<struct MyStruct a=nil, b=nil, c=nil>
+   *  irb(main):004:0> mystruct_instance.class
+   *  => MyStruct
+   *  irb(main):005:0> mystruct_instance.class.ancestors
+   *  => [MyStruct, Struct, Enumerable, Object, Kernel]
+   *  \endcode
+   *
+   *  Thus, inside the interpreter, MyStruct is a Class which inherits
+   *  from Struct, and mystruct_instance is an instance of MyStruct.
+   *
+   *  At the C++ level, we might do this instead:
+   *  \code
+   *  Struct rb_cMyStruct = define_struct()
+   *    .define_member("a")
+   *    .define_member("b")
+   *    .define_member("c")
+   *    .initialize("MyStruct");
+   *  Struct::Instance mystruct_instance(rb_cMyStruct.new_instance());
+   *  \endcode
+   *
+   * Here rb_cMyStruct is an instance of Struct and that mystruct_instance
+   * is an instance of Struct::Instance.
+   */
+  class Struct : public Class
+  {
+  public:
+    //! Define a new Struct member.
+    /*! Defines a new member of the Struct.  Must be called before the
+     *  Struct is initialized.
+     *  \return *this
+     */
+    Struct& define_member(Identifier name);
+
+    //! Initialize the Struct class.
+    /*! Must be called after all Struct members have been defined.
+     *  \param module the module under which to define the Struct.
+     *  \param name the name of the Class at the ruby level.
+     */
+    Struct& initialize(Module module, Identifier name);
+
+    //! Get the members in Struct.
+    Array members() const;
+
+    class Instance;
+    friend class Instance;
+    //friend Struct Rice::define_struct();
+
+    //! Create a new instance of the Struct
+    /*! \param args the arguments to the constructor.
+     *  \return a new Struct::Instance
+     */
+    Instance new_instance(Array args = Array()) const;
+
+  private:
+    std::vector<Symbol> members_;
+  };
+
+  //! An instance of a Struct
+  //! \sa Struct
+  class Struct::Instance : public Builtin_Object<T_STRUCT>
+  {
+  public:
+    //! Create a new Instance of a Struct.
+    /*! \param type the Struct type to create.
+     *  \param args the initial values for the objects of the instance.
+     */
+    Instance(Struct const& type,Array args = Array());
+
+    //! Encapsulate an existing Struct instance.
+    /*! \param type the Struct type to encapsulate.
+     *  \param s the instance to encapsulate.
+     */
+    Instance(Struct const& type, Object s);
+
+    //! Get a member, given its offset.
+    /*! \param index the (integral) index into the Struct's internal
+     *  array or its name (an Identifier or char const *)
+     *  \return the member.
+     */
+    template<typename T>
+    Object operator[](T index);
+
+  private:
+    Struct type_;
+  };
+
+  //! Define a new Struct
+  Struct define_struct();
+
+} // namespace Rice
+
+#endif // Rice__ruby_struct__hpp_

data/rice/cpp_api/Struct.ipp

@@ -0,0 +1,92 @@
+
+namespace Rice
+{
+  inline Struct& Struct::initialize(Module module, Identifier name)
+  {
+    Class struct_class(rb_cStruct);
+
+    Object type = struct_class.vcall("new", this->members());
+
+    set_value(type);
+    module.const_set(name, type);
+
+    return *this;
+  }
+
+  inline Struct& Struct::define_member(Identifier name)
+  {
+    if (value() != rb_cObject)
+    {
+      throw std::runtime_error("struct is already initialized");
+    }
+
+    members_.push_back(name.to_sym());
+
+    return *this;
+  }
+
+  inline Array Struct::members() const
+  {
+    if (value() == rb_cObject)
+    {
+      // Struct is not yet defined
+      return Array(members_.begin(), members_.end());
+    }
+    else
+    {
+      // Struct is defined, call Ruby API
+      return rb_struct_s_members(this->value());
+    }
+  }
+
+  inline Struct::Instance Struct::new_instance(Array args) const
+  {
+    Object instance = const_cast<Struct*>(this)->vcall("new", args);
+    return Instance(*this, instance);
+  }
+
+  inline Struct::Instance::Instance(Struct const& type, Array args) :
+    Builtin_Object<T_STRUCT>(type.new_instance(args)), type_(type)
+  {
+  }
+
+  inline Struct::Instance::Instance(Struct const& type, Object s) :
+    Builtin_Object<T_STRUCT>(s), type_(type)
+  {
+  }
+
+  inline Struct define_struct()
+  {
+    return Struct();
+  }
+
+  template<typename T>
+  inline Object Struct::Instance::operator[](T index)
+  {
+    return rb_struct_aref(value(), ULONG2NUM(index));
+  }
+
+  template<>
+  inline Object Struct::Instance::operator[]<Identifier>(Identifier member)
+  {
+    return rb_struct_aref(value(), Symbol(member));
+  }
+
+  template<>
+  inline Object Struct::Instance::operator[]<char const*>(char const* name)
+  {
+    return (*this)[Identifier(name)];
+  }
+}
+
+namespace Rice::detail
+{
+  template<>
+  struct Type<Struct>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+  };
+}

data/rice/cpp_api/Symbol.hpp

@@ -0,0 +1,46 @@
+#ifndef Rice__Symbol__hpp_
+#define Rice__Symbol__hpp_
+
+namespace Rice
+{
+  //! A wrapper for ruby's Symbol class.
+  /*! Symbols are internal identifiers in ruby.  They are singletons and
+   *  can be thought of as frozen strings.  They differ from an Identifier
+   *  in that they are in fact real Objects, but they can be converted
+   *  back and forth between Identifier and Symbol.
+   */
+  class Symbol
+    : public Object
+  {
+  public:
+    //! Wrap an existing symbol.
+    Symbol(VALUE v);
+
+    //! Wrap an existing symbol.
+    Symbol(Object v);
+
+    //! Construct a Symbol from an Identifier.
+    Symbol(Identifier id);
+
+    //! Construct a Symbol from a null-terminated C string.
+    Symbol(char const* s = "");
+
+    //! Construct a Symbol from an std::string.
+    Symbol(std::string const& s);
+
+    //! Construct a Symbol from an std::string_view.
+    Symbol(std::string_view const& s);
+
+    //! Return a string representation of the Symbol.
+    char const* c_str() const;
+
+    //! Return a string representation of the Symbol.
+    std::string str() const;
+
+    //! Return the Symbol as an Identifier.
+    Identifier to_id() const;
+  };
+} // namespace Rice
+
+#endif // Rice__Symbol__hpp_
+

data/rice/cpp_api/Symbol.ipp

@@ -0,0 +1,93 @@
+namespace Rice
+{
+  inline Symbol::Symbol(VALUE value) : Object(value)
+  {
+    detail::protect(rb_check_type, value, (int)T_SYMBOL);
+  }
+
+  inline Symbol::Symbol(Object value) : Object(value)
+  {
+    detail::protect(rb_check_type, value.value(), (int)T_SYMBOL);
+  }
+
+  inline Symbol::Symbol(char const* s)
+    : Object(detail::protect(rb_id2sym, detail::protect(rb_intern, s)))
+  {
+  }
+
+  inline Symbol::Symbol(std::string const& s)
+    : Object(detail::protect(rb_id2sym, detail::protect(rb_intern2, s.c_str(), (long)s.length())))
+  {
+  }
+
+  inline Symbol::Symbol(std::string_view const& view)
+    : Object(detail::protect(rb_id2sym, detail::protect(rb_intern2, view.data(), (long)view.length())))
+  {
+  }
+
+  inline Symbol::Symbol(Identifier id) : Object(detail::protect(rb_id2sym, id))
+  {
+  }
+
+  inline char const* Symbol::c_str() const
+  {
+    return to_id().c_str();
+  }
+
+  inline std::string Symbol::str() const
+  {
+    return to_id().str();
+  }
+
+  inline Identifier Symbol::to_id() const
+  {
+    return rb_to_id(value());
+  }
+}
+
+namespace Rice::detail
+{
+  template<>
+  struct Type<Symbol>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+  };
+  
+  template<>
+  class To_Ruby<Symbol>
+  {
+  public:
+    VALUE convert(Symbol const& x)
+    {
+      return x.value();
+    }
+  };
+
+  template<>
+  class From_Ruby<Symbol>
+  {
+  public:
+    Convertible is_convertible(VALUE value)
+    {
+      switch (rb_type(value))
+      {
+        case RUBY_T_SYMBOL:
+          return Convertible::Exact;
+          break;
+      case RUBY_T_STRING:
+          return Convertible::Cast;
+          break;
+        default:
+          return Convertible::None;
+        }
+    }
+
+    Symbol convert(VALUE value)
+    {
+      return Symbol(value);
+    }
+  };
+}

data/rice/cpp_api/shared_methods.hpp

@@ -0,0 +1,134 @@
+// Include these methods to call methods from Module but return
+// an instance of the current classes. This is an alternative to
+// using CRTP.
+
+
+//! Include a module.
+/*! \param inc the module to be included.
+*  \return *this
+*/
+inline auto& include_module(Module const& inc)
+{
+  detail::protect(rb_include_module, this->value(), inc.value());
+  return *this;
+}
+
+//! Define an instance method.
+/*! The method's implementation can be a member function, plain function
+ *  or lambda. The easiest case is a member function where the Ruby
+ *  method maps one-to-one to the C++ method. In the case of a
+ *  plain function or lambda, the first argument must be SELF - ie,
+ *  the current object. If the type of the first argument is VALUE, then
+ *  the current Ruby object is passed. If the type is a C++ class,
+ *  then the C++ object is passed. If you don't want to include the
+ *  SELF argument see define_function.
+ *  Rice will automatically convert method parameters from Ruby to C++ and
+ *  convert the return value from C++ to Ruby.
+ *  \param name the name of the method
+ *  \param func the implementation of the function, either a function
+ *  pointer or a member function pointer.
+ *  \param args a list of Arg instance used to define default parameters.
+ *  \return *this
+ */
+template<typename Function_T, typename...Arg_Ts>
+inline auto& define_method(std::string name, Function_T&& func, const Arg_Ts&...args)
+{
+  MethodInfo* methodInfo = new MethodInfo(detail::method_traits<Function_T, true>::arity, args...);
+  this->wrap_native_call<true>(this->value(), name, std::forward<Function_T>(func), methodInfo);
+  return *this;
+}
+
+//! Define a function.
+/*! The function implementation is a plain function or a static
+ *  member function.
+ *  Rice will automatically convert method method from Ruby to C++ and
+ *  then convert the return value from C++ to Ruby.
+ *  \param name the name of the method
+ *  \param func the implementation of the function, either a function
+ *  pointer or a member function pointer.
+ *  \param args a list of Arg instance used to define default parameters (optional)
+ *  \return *this
+ */
+template<typename Function_T, typename...Arg_Ts>
+inline auto& define_function(std::string name, Function_T&& func, const Arg_Ts&...args)
+{
+  MethodInfo* methodInfo = new MethodInfo(detail::method_traits<Function_T, false>::arity, args...);
+  this->wrap_native_call<false>(this->value(), name, std::forward<Function_T>(func), methodInfo);
+  return *this;
+}
+
+//! Define a singleton method.
+/*! The method's implementation can be a static member function,
+*   plain function or lambda. In all cases the first argument
+*   must be SELF - ie, the current object. If it is specified as a VALUE, then
+ *  the current Ruby object is passed. If it is specified as a C++ class,
+ *  then the C++ object is passed. If you don't want to include the
+ *  SELF argument see define_singleton_function.
+ *  Rice will automatically convert method method from Ruby to C++ and
+ *  then convert the return value from C++ to Ruby.
+ *  \param name the name of the method
+ *  \param func the implementation of the function, either a function
+ *  pointer or a member function pointer.
+ *  \param args a list of Arg instance used to define default parameters (optional)
+ *  \return *this
+ */
+template<typename Function_T, typename...Arg_Ts>
+inline auto& define_singleton_method(std::string name, Function_T&& func, const Arg_Ts&...args)
+{
+  MethodInfo* methodInfo = new MethodInfo(detail::method_traits<Function_T, true>::arity, args...);
+  this->wrap_native_call<true>(rb_singleton_class(*this), name, std::forward<Function_T>(func), methodInfo);
+  return *this;
+}
+
+//! Define a singleton method.
+/*! The method's implementation can be a static member function, plain
+ *  function or lambda. A wrapper will be generated which will convert the method
+ *  from ruby types to C++ types before calling the function.  The return
+ *  value will be converted back to ruby.
+ *  \param name the name of the method
+ *  \param func the implementation of the function, either a function
+ *  pointer or a member function pointer.
+ *  \param args a list of Arg instance used to define default parameters (optional)
+ *  \return *this
+ */
+template<typename Function_T, typename...Arg_Ts>
+inline auto& define_singleton_function(std::string name, Function_T&& func, const Arg_Ts& ...args)
+{
+  MethodInfo* methodInfo = new MethodInfo(detail::method_traits<Function_T, false>::arity, args...);
+  this->wrap_native_call<false>(rb_singleton_class(*this), name, std::forward<Function_T>(func), methodInfo);
+  return *this;
+}
+
+//! Define a module function.
+/*! A module function is a function that can be accessed either as a
+ *  singleton method or as an instance method. It wrap a plain
+ *  function, static member function or lambda.
+ *  Rice will automatically convert method method from Ruby to C++ and
+ *  then convert the return value from C++ to Ruby.
+ *  \param name the name of the method
+ *  \param func the implementation of the function, either a function
+ *  pointer or a member function pointer.
+ *  \param args a list of Arg instance used to define default parameters (optional)
+ *  \return *this
+ */
+template<typename Function_T, typename...Arg_Ts>
+inline auto& define_module_function(std::string name, Function_T&& func, const Arg_Ts& ...args)
+{
+  if (this->rb_type() != T_MODULE)
+  {
+    throw std::runtime_error("can only define module functions for modules");
+  }
+
+  define_function(name, std::forward<Function_T>(func), args...);
+  define_singleton_function(name, std::forward<Function_T>(func), args...);
+  return *this;
+}
+
+//! Define a constant
+template<typename Constant_T>
+inline auto& define_constant(std::string name, Constant_T value)
+{
+  using Base_T = detail::remove_cv_recursive_t<Constant_T>;
+  detail::protect(rb_define_const, this->value(), name.c_str(), detail::To_Ruby<Base_T>().convert(value));
+  return *this;
+}

data/rice/detail/MethodInfo.hpp

@@ -13,12 +13,6 @@ namespace Rice
     template <typename...Arg_Ts>
     MethodInfo(size_t argCount, const Arg_Ts&...args);
 
-    /**
-      * Get the rb_scan_args format string for this
-      * list of arguments.
-      */
-    std::string formatString();
-
     /**
       * Add a defined Arg to this list of Arguments
       */
@@ -34,9 +28,7 @@ namespace Rice
       */
     Arg* arg(std::string name);
 
-    int requiredArgCount();
-    int optionalArgCount();
-    void verifyArgCount(int argc);
+    int argCount();
 
     // Iterator support
     std::vector<Arg>::iterator begin();

data/rice/detail/MethodInfo.ipp

@@ -25,11 +25,13 @@ 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;
     }
-    else
+    else if constexpr (std::is_same_v<Arg_T, Arg>)
     {
       this->addArg(arg);
     }
@@ -40,78 +42,9 @@ namespace Rice
     this->args_.push_back(arg);
   }
 
-  inline int MethodInfo::requiredArgCount()
-  {
-    int result = 0;
-
-    for (const Arg& arg : this->args_)
-    {
-      if (!arg.hasDefaultValue())
-      {
-        result++;
-      }
-    }
-
-    return result;
-  }
-
-  inline int MethodInfo::optionalArgCount()
-  {
-    int result = 0;
-
-    for (const Arg& arg : this->args_)
-    {
-      if (arg.hasDefaultValue())
-      {
-        result++;
-      }
-    }
-
-    return result;
-  }
-
-  inline void MethodInfo::verifyArgCount(int argc)
+  inline int MethodInfo::argCount()
   {
-    int requiredArgCount = this->requiredArgCount();
-    int optionalArgCount = this->optionalArgCount();
-
-    if (argc < requiredArgCount || argc > requiredArgCount + optionalArgCount)
-    {
-      std::string message;
-
-      if (optionalArgCount > 0)
-      {
-        message = "wrong number of arguments (given " +
-          std::to_string(argc) + ", expected " +
-          std::to_string(requiredArgCount) + ".." + std::to_string(requiredArgCount + optionalArgCount) + ")";
-      }
-      else
-      {
-        message = "wrong number of arguments (given " +
-          std::to_string(argc) + ", expected " + std::to_string(requiredArgCount) + ")";
-      }
-      throw std::invalid_argument(message);
-    }
-  }
-
-  inline std::string MethodInfo::formatString()
-  {
-    size_t required = 0;
-    size_t optional = 0;
-
-    for (const Arg& arg : this->args_)
-    {
-      if (arg.hasDefaultValue())
-      {
-        optional++;
-      }
-      else
-      {
-        required++;
-      }
-    }
-
-    return std::to_string(required) + std::to_string(optional);
+    return this->args_.size();
   }
 
   inline Arg* MethodInfo::arg(size_t pos)

data/rice/detail/Native.hpp

@@ -24,8 +24,9 @@ namespace Rice::detail
     virtual ~Native() = default;
     VALUE call(int argc, VALUE* argv, VALUE self);
 
-    virtual Resolved matches(int argc, const VALUE* argv, VALUE self) = 0;
-    virtual VALUE operator()(int argc, const VALUE* argv, VALUE self) = 0;
+    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;
   };
 }
 

data/rice/detail/Native.ipp

@@ -83,6 +83,8 @@ namespace Rice::detail
       }
       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(), 
@@ -95,9 +97,30 @@ namespace Rice::detail
         // Now sort from best to worst
         std::sort(resolves.begin(), resolves.end(), std::greater{});
 
-        // Get the best one
+        // 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)
         {
@@ -107,7 +130,6 @@ namespace Rice::detail
         {
           // Special case == to make the RubyMine debugger work. It calls == with a Module as
           // the other argument, thus breaking if C++ operator== is implemented.
-          Identifier identifier(methodId);
           if (identifier.str() == "==")
           {
             return detail::protect(rb_call_super, argc, argv);
@@ -116,8 +138,14 @@ namespace Rice::detail
           {
             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.";
-              rb_raise(rb_eArgError, message.str().c_str(), rb_class2name(klass), identifier.c_str(), natives.size());
+                    << "  %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());
           }
         }
       }

data/rice/detail/NativeAttributeGet.hpp

@@ -34,8 +34,9 @@ namespace Rice
       void operator=(const NativeAttribute_T&) = delete;
       void operator=(NativeAttribute_T&&) = delete;
 
-      Resolved matches(int argc, const VALUE* argv, VALUE self) override;
-      VALUE operator()(int argc, const VALUE* argv, VALUE self) override;
+      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);