rice 4.0.4 → 4.1.0

data/rice/detail/from_ruby.ipp

@@ -22,6 +22,11 @@ namespace Rice::detail
     {
     }
 
+    bool is_convertible(VALUE value)
+    {
+      return rb_type(value) == RUBY_T_FIXNUM;
+    }
+
     short convert(VALUE value)
     {
       if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
@@ -48,6 +53,11 @@ namespace Rice::detail
     {
     }
 
+    bool is_convertible(VALUE value)
+    {
+      return rb_type(value) == RUBY_T_FIXNUM;
+    }
+
     short& convert(VALUE value)
     {
       if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
@@ -70,6 +80,11 @@ namespace Rice::detail
   class From_Ruby<short*>
   {
   public:
+    bool is_convertible(VALUE value)
+    {
+      return rb_type(value) == RUBY_T_FIXNUM;
+    }
+
     short* convert(VALUE value)
     {
       if (value == Qnil)
@@ -98,6 +113,11 @@ namespace Rice::detail
     {
     }
 
+    bool is_convertible(VALUE value)
+    {
+      return rb_type(value) == RUBY_T_FIXNUM;
+    }
+
     int convert(VALUE value)
     {
       if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
@@ -124,6 +144,11 @@ namespace Rice::detail
     {
     }
 
+    bool is_convertible(VALUE value)
+    {
+      return rb_type(value) == RUBY_T_FIXNUM;
+    }
+
     int& convert(VALUE value)
     {
       if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
@@ -146,6 +171,11 @@ namespace Rice::detail
   class From_Ruby<int*>
   {
   public:
+    bool is_convertible(VALUE value)
+    {
+      return rb_type(value) == RUBY_T_FIXNUM;
+    }
+
     int* convert(VALUE value)
     {
       if (value == Qnil)
@@ -174,6 +204,11 @@ namespace Rice::detail
     {
     }
 
+    bool is_convertible(VALUE value)
+    {
+      return rb_type(value) == RUBY_T_FIXNUM;
+    }
+
     long convert(VALUE value)
     {
       if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
@@ -200,6 +235,11 @@ namespace Rice::detail
     {
     }
 
+    bool is_convertible(VALUE value)
+    {
+      return rb_type(value) == RUBY_T_FIXNUM;
+    }
+
     long& convert(VALUE value)
     {
       if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
@@ -222,6 +262,11 @@ namespace Rice::detail
   class From_Ruby<long*>
   {
   public:
+    bool is_convertible(VALUE value)
+    {
+      return rb_type(value) == RUBY_T_FIXNUM;
+    }
+
     long* convert(VALUE value)
     {
       if (value == Qnil)
@@ -250,6 +295,11 @@ namespace Rice::detail
     {
     }
 
+    bool is_convertible(VALUE value)
+    {
+      return rb_type(value) == RUBY_T_FIXNUM;
+    }
+
     long long convert(VALUE value)
     {
       if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
@@ -276,6 +326,11 @@ namespace Rice::detail
     {
     }
 
+    bool is_convertible(VALUE value)
+    {
+      return rb_type(value) == RUBY_T_FIXNUM;
+    }
+
     long long& convert(VALUE value)
     {
       if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
@@ -298,6 +353,11 @@ namespace Rice::detail
   class From_Ruby<long long*>
   {
   public:
+    bool is_convertible(VALUE value)
+    {
+      return rb_type(value) == RUBY_T_FIXNUM;
+    }
+
     long long* convert(VALUE value)
     {
       if (value == Qnil)
@@ -326,6 +386,11 @@ namespace Rice::detail
     {
     }
 
+    bool is_convertible(VALUE value)
+    {
+      return rb_type(value) == RUBY_T_FIXNUM;
+    }
+
     unsigned short convert(VALUE value)
     {
       if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
@@ -352,6 +417,11 @@ namespace Rice::detail
     {
     }
 
+    bool is_convertible(VALUE value)
+    {
+      return rb_type(value) == RUBY_T_FIXNUM;
+    }
+
     unsigned short& convert(VALUE value)
     {
       if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
@@ -374,6 +444,11 @@ namespace Rice::detail
   class From_Ruby<unsigned short*>
   {
   public:
+    bool is_convertible(VALUE value)
+    {
+      return rb_type(value) == RUBY_T_FIXNUM;
+    }
+
     unsigned short* convert(VALUE value)
     {
       if (value == Qnil)
@@ -402,6 +477,11 @@ namespace Rice::detail
     {
     }
 
+    bool is_convertible(VALUE value)
+    {
+      return rb_type(value) == RUBY_T_FIXNUM;
+    }
+
     unsigned int convert(VALUE value)
     {
       if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
@@ -428,6 +508,11 @@ namespace Rice::detail
     {
     }
 
+    bool is_convertible(VALUE value)
+    {
+      return rb_type(value) == RUBY_T_FIXNUM;
+    }
+
     unsigned int& convert(VALUE value)
     {
       if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
@@ -450,6 +535,11 @@ namespace Rice::detail
   class From_Ruby<unsigned int*>
   {
   public:
+    bool is_convertible(VALUE value)
+    {
+      return rb_type(value) == RUBY_T_FIXNUM;
+    }
+
     unsigned int* convert(VALUE value)
     {
       if (value == Qnil)
@@ -478,9 +568,14 @@ namespace Rice::detail
     {
     }
 
+    bool is_convertible(VALUE value)
+    {
+      return rb_type(value) == RUBY_T_FIXNUM;
+    }
+
     unsigned long convert(VALUE value)
     {
-      if (this->arg_ && this->arg_->getIsValue())
+      if (this->arg_ && this->arg_->isValue())
       {
         return (unsigned long)value;
       }
@@ -508,6 +603,11 @@ namespace Rice::detail
     {
     }
 
+    bool is_convertible(VALUE value)
+    {
+      return rb_type(value) == RUBY_T_FIXNUM;
+    }
+
     unsigned long& convert(VALUE value)
     {
       if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
@@ -530,6 +630,11 @@ namespace Rice::detail
   class From_Ruby<unsigned long*>
   {
   public:
+    bool is_convertible(VALUE value)
+    {
+      return rb_type(value) == RUBY_T_FIXNUM;
+    }
+
     unsigned long* convert(VALUE value)
     {
       if (value == Qnil)
@@ -558,9 +663,14 @@ namespace Rice::detail
     {
     }
 
+    bool is_convertible(VALUE value)
+    {
+      return rb_type(value) == RUBY_T_FIXNUM;
+    }
+
     unsigned long long convert(VALUE value)
     {
-      if (this->arg_ && this->arg_->getIsValue())
+      if (this->arg_ && this->arg_->isValue())
       {
         return value;
       }
@@ -588,6 +698,11 @@ namespace Rice::detail
     {
     }
 
+    bool is_convertible(VALUE value)
+    {
+      return rb_type(value) == RUBY_T_FIXNUM;
+    }
+
     unsigned long long& convert(VALUE value)
     {
       if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
@@ -610,6 +725,11 @@ namespace Rice::detail
   class From_Ruby<unsigned long long*>
   {
   public:
+    bool is_convertible(VALUE value)
+    {
+      return rb_type(value) == RUBY_T_FIXNUM;
+    }
+
     unsigned long long* convert(VALUE value)
     {
       if (value == Qnil)
@@ -638,6 +758,14 @@ namespace Rice::detail
     {
     }
 
+    bool is_convertible(VALUE value)
+    {
+      ruby_value_type ruby_type = (ruby_value_type)rb_type(value);
+      return ruby_type == RUBY_T_TRUE ||
+            ruby_type == RUBY_T_FALSE ||
+            ruby_type == RUBY_T_NIL;
+    }
+
     bool convert(VALUE value)
     {
       if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
@@ -664,6 +792,14 @@ namespace Rice::detail
     {
     }
 
+    bool is_convertible(VALUE value)
+    {
+      ruby_value_type ruby_type = (ruby_value_type)rb_type(value);
+      return ruby_type == RUBY_T_TRUE ||
+             ruby_type == RUBY_T_FALSE ||
+             ruby_type == RUBY_T_NIL;
+    }
+
     bool& convert(VALUE value)
     {
       if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
@@ -686,6 +822,14 @@ namespace Rice::detail
   class From_Ruby<bool*>
   {
   public:
+    bool is_convertible(VALUE value)
+    {
+      ruby_value_type ruby_type = (ruby_value_type)rb_type(value);
+      return ruby_type == RUBY_T_TRUE ||
+             ruby_type == RUBY_T_FALSE ||
+             ruby_type == RUBY_T_NIL;
+    }
+
     bool* convert(VALUE value)
     {
       if (value == Qnil)
@@ -744,6 +888,11 @@ namespace Rice::detail
     {
     }
 
+    bool is_convertible(VALUE value)
+    {
+      return rb_type(value) == RUBY_T_STRING;
+    }
+
     char convert(VALUE value)
     {
       if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
@@ -770,6 +919,11 @@ namespace Rice::detail
     {
     }
 
+    bool is_convertible(VALUE value)
+    {
+      return rb_type(value) == RUBY_T_STRING;
+    }
+
     char& convert(VALUE value)
     {
       if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
@@ -792,6 +946,11 @@ namespace Rice::detail
   class From_Ruby<char*>
   {
   public:
+    bool is_convertible(VALUE value)
+    {
+      return rb_type(value) == RUBY_T_STRING;
+    }
+
     char* convert(VALUE value)
     {
       if (value == Qnil)
@@ -811,6 +970,11 @@ namespace Rice::detail
   class From_Ruby<char const*>
   {
   public:
+    bool is_convertible(VALUE value)
+    {
+      return rb_type(value) == RUBY_T_STRING;
+    }
+
     char const* convert(VALUE value)
     {
       if (value == Qnil)
@@ -836,6 +1000,11 @@ namespace Rice::detail
     {
     }
 
+    bool is_convertible(VALUE value)
+    {
+      return rb_type(value) == RUBY_T_STRING;
+    }
+
     unsigned char convert(VALUE value)
     {
       if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
@@ -863,6 +1032,11 @@ namespace Rice::detail
     {
     }
 
+    bool is_convertible(VALUE value)
+    {
+      return rb_type(value) == RUBY_T_STRING;
+    }
+
     signed char convert(VALUE value)
     {
       if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
@@ -890,6 +1064,11 @@ namespace Rice::detail
     {
     }
 
+    bool is_convertible(VALUE value)
+    {
+      return rb_type(value) == RUBY_T_FLOAT;
+    }
+
     double convert(VALUE value)
     {
       if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
@@ -916,6 +1095,11 @@ namespace Rice::detail
     {
     }
 
+    bool is_convertible(VALUE value)
+    {
+      return rb_type(value) == RUBY_T_FLOAT;
+    }
+
     double& convert(VALUE value)
     {
       if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
@@ -938,6 +1122,11 @@ namespace Rice::detail
   class From_Ruby<double*>
   {
   public:
+    bool is_convertible(VALUE value)
+    {
+      return rb_type(value) == RUBY_T_FLOAT;
+    }
+
     double* convert(VALUE value)
     {
       if (value == Qnil)
@@ -966,6 +1155,11 @@ namespace Rice::detail
     {
     }
 
+    bool is_convertible(VALUE value)
+    {
+      return rb_type(value) == RUBY_T_FLOAT;
+    }
+
     float convert(VALUE value)
     {
       if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
@@ -992,6 +1186,11 @@ namespace Rice::detail
     {
     }
 
+    bool is_convertible(VALUE value)
+    {
+      return rb_type(value) == RUBY_T_FLOAT;
+    }
+
     float& convert(VALUE value)
     {
       if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
@@ -1014,6 +1213,11 @@ namespace Rice::detail
   class From_Ruby<float*>
   {
   public:
+    bool is_convertible(VALUE value)
+    {
+      return rb_type(value) == RUBY_T_FLOAT;
+    }
+
     float* convert(VALUE value)
     {
       if (value == Qnil)

data/rice/detail/to_ruby.ipp

@@ -189,7 +189,7 @@ namespace Rice
 
       VALUE convert(unsigned long const& x)
       {
-        if (this->returnInfo_ && this->returnInfo_->getIsValue())
+        if (this->returnInfo_ && this->returnInfo_->isValue())
         {
           return x;
         }
@@ -215,7 +215,7 @@ namespace Rice
 
       VALUE convert(unsigned long const& x)
       {
-        if (this->returnInfo_ && this->returnInfo_->getIsValue())
+        if (this->returnInfo_ && this->returnInfo_->isValue())
         {
           return x;
         }
@@ -241,7 +241,7 @@ namespace Rice
 
       VALUE convert(unsigned long long const& x)
       {
-        if (this->returnInfo_ && this->returnInfo_->getIsValue())
+        if (this->returnInfo_ && this->returnInfo_->isValue())
         {
           return x;
         }
@@ -267,7 +267,7 @@ namespace Rice
 
       VALUE convert(unsigned long long const& x)
       {
-        if (this->returnInfo_ && this->returnInfo_->getIsValue())
+        if (this->returnInfo_ && this->returnInfo_->isValue())
         {
           return x;
         }
@@ -407,7 +407,41 @@ namespace Rice
     public:
       VALUE convert(char const* x)
       {
-        return protect(rb_str_new2, x);
+        if (strlen(x) > 0 && x[0] == ':')
+        {
+          size_t symbolLength = strlen(x) - 1;
+          char* symbol = new char[symbolLength];
+          strncpy(symbol, x + 1, symbolLength);
+          ID id = protect(rb_intern2, symbol, (long)symbolLength);
+          delete[] symbol;
+          return protect(rb_id2sym, id);
+        }
+        else
+        {
+          return protect(rb_str_new2, x);
+        }
+      }
+    };
+
+    template<int N>
+    class To_Ruby<char[N]>
+    {
+    public:
+      VALUE convert(char const x[])
+      {
+        if (N > 0 && x[0] == ':')
+        {
+          // N count includes a NULL character at the end of the string
+          constexpr size_t symbolLength = N - 1;
+          char symbol[symbolLength];
+          strncpy(symbol, x + 1, symbolLength);
+          ID id = protect(rb_intern, symbol);
+          return protect(rb_id2sym, id);
+        }
+        else
+        {
+          return protect(rb_str_new2, x);
+        }
       }
     };
   }

data/rice/detail/to_ruby_defn.hpp

@@ -1,7 +1,7 @@
 #ifndef Rice__detail__to_ruby_defn__hpp_
 #define Rice__detail__to_ruby_defn__hpp_
 
-#include "rice_traits.hpp"
+#include "../traits/rice_traits.hpp"
 
 namespace Rice
 {

data/rice/forward_declares.ipp

@@ -78,5 +78,11 @@ namespace Rice
   {
     return CLASS_OF(value());
   }
+
+  inline Object Module::module_eval(String const& s)
+  {
+    const VALUE argv[] = { s.value() };
+    return detail::protect(rb_mod_module_eval, 1, &argv[0], this->value());
+  }
 }
 #endif // Rice__Forward_Declares__ipp_

data/rice/global_function.hpp

@@ -5,10 +5,6 @@
 
 namespace Rice
 {
-  template<typename Function_T>
-  [[deprecated("Please call define_global_function with Arg parameters")]]
-  void define_global_function(char const * name, Function_T&& func, MethodInfo* arguments);
-
    //! Define an global function
    /*! The method's implementation can be any function or static member
     *  function.  A wrapper will be generated which will convert the arguments

data/rice/global_function.ipp

@@ -1,11 +1,5 @@
 #include "cpp_api/Module.hpp"
 
-template<typename Function_T>
-void Rice::define_global_function(char const * name, Function_T&& func, MethodInfo* methodInfo)
-{
-  Module(rb_mKernel).define_module_function(name, std::forward<Function_T>(func), methodInfo);
-}
-
 template<typename Function_T, typename...Arg_Ts>
 void Rice::define_global_function(char const * name, Function_T&& func, Arg_Ts const& ...args)
 {

data/rice/rice.hpp

@@ -1,56 +1,61 @@
 #ifndef Rice__hpp_
 #define Rice__hpp_
 
+// Traits
 #include "detail/ruby.hpp"
-#include "detail/rice_traits.hpp"
-#include "detail/function_traits.hpp"
+#include "traits/rice_traits.hpp"
+#include "traits/function_traits.hpp"
+#include "traits/method_traits.hpp"
+#include "traits/attribute_traits.hpp"
+
+// Code for C++ to call Ruby
+#include "Exception_defn.hpp"
+#include "detail/Jump_Tag.hpp"
+#include "detail/RubyFunction.hpp"
+
+// Code for Ruby to call C++
+#include "detail/ExceptionHandler.hpp"
 #include "detail/Type.hpp"
 #include "detail/TypeRegistry.hpp"
+#include "detail/InstanceRegistry.hpp"
+#include "detail/HandlerRegistry.hpp"
+#include "detail/NativeRegistry.hpp"
+#include "detail/Registries.hpp"
+#include "detail/cpp_protect.hpp"
 #include "detail/Wrapper.hpp"
-#include "detail/default_allocation_func.hpp"
-#include "detail/Jump_Tag.hpp"
-#include "Exception_defn.hpp"
-#include "detail/RubyFunction.hpp"
 #include "Return.hpp"
 #include "Arg.hpp"
+#include "detail/MethodInfo.hpp"
 #include "detail/from_ruby.hpp"
 #include "detail/to_ruby.hpp"
-#include "detail/MethodInfo.hpp"
-#include "detail/Exception_Handler.hpp"
-#include "detail/Iterator.hpp"
+#include "Identifier.hpp"
 #include "Exception.ipp"
-#include "detail/method_data.hpp"
-#include "ruby_try_catch.hpp"
 #include "detail/NativeAttribute.hpp"
 #include "detail/NativeFunction.hpp"
+#include "detail/NativeIterator.hpp"
+#include "HandlerRegistration.hpp"
 
-#include "ruby_mark.hpp"
-
-#include "Identifier.hpp"
-
+// C++ classes for using the Ruby API
 #include "cpp_api/Object.hpp"
 #include "cpp_api/Builtin_Object.hpp"
 #include "cpp_api/String.hpp"
 #include "cpp_api/Array.hpp"
 #include "cpp_api/Hash.hpp"
 #include "cpp_api/Symbol.hpp"
-
-#include "Address_Registration_Guard.hpp"
 #include "cpp_api/Module.hpp"
-#include "global_function.hpp"
-
 #include "cpp_api/Class.hpp"
 #include "cpp_api/Struct.hpp"
+#include "Address_Registration_Guard.hpp"
+#include "global_function.hpp"
 
+// Code involed in creating custom DataTypes (ie, Ruby classes that wrap C++ classes)
+#include "ruby_mark.hpp"
+#include "detail/default_allocation_func.hpp"
 #include "Director.hpp"
 #include "Data_Type.hpp"
+#include "detail/default_allocation_func.ipp"
 #include "Constructor.hpp"
 #include "Data_Object.hpp"
-#include "detail/Iterator.ipp"
-
-// Dependent on Data_Object due to the way method metadata is stored in the Ruby class
-#include "detail/default_allocation_func.ipp"
-
 #include "Enum.hpp"
 
 // Dependent on Module, Class, Array and String

data/rice/stl.hpp

@@ -4,8 +4,13 @@
 #include "stl/string.hpp"
 #include "stl/complex.hpp"
 #include "stl/optional.hpp"
-#include "stl/pair.hpp"
+#include "stl/reference_wrapper.hpp"
 #include "stl/smart_ptr.hpp"
+#include "stl/monostate.hpp"
+#include "stl/variant.hpp"
+#include "stl/pair.hpp"
+#include "stl/map.hpp"
+#include "stl/unordered_map.hpp"
 #include "stl/vector.hpp"
 
 #endif // Rice__stl__hpp_