rice 4.3.3 → 4.6.0

data/rice/global_function.hpp

@@ -1,8 +1,6 @@
 #ifndef Rice__global_function__hpp_
 #define Rice__global_function__hpp_
 
-#include "Arg.hpp"
-
 namespace Rice
 {
    //! Define an global function
@@ -20,6 +18,4 @@ namespace Rice
   void define_global_function(char const * name, Function_T&& func, Arg_Ts const& ...args);
 } // Rice
 
-#include "global_function.ipp"
-
 #endif // Rice__global_function__hpp_

data/rice/global_function.ipp

@@ -1,4 +1,3 @@
-#include "cpp_api/Module.hpp"
 
 template<typename Function_T, typename...Arg_Ts>
 void Rice::define_global_function(char const * name, Function_T&& func, Arg_Ts const& ...args)

data/rice/libc/file.hpp

@@ -0,0 +1,11 @@
+#ifndef Rice__libc__file__hpp_
+#define Rice__libc__file__hpp_
+
+namespace Rice::libc
+{
+  extern Class rb_cLibcFile;
+}
+
+#include "file.ipp"
+
+#endif // Rice__libc__file__hpp_

data/rice/libc/file.ipp

@@ -0,0 +1,32 @@
+#include <exception>
+
+// Libraries sometime inherit custom exception objects from std::exception,
+// so define it for Ruby if necessary
+namespace Rice::libc
+{
+  inline Class rb_cLibcFile;
+
+  inline void define_libc_file()
+  {
+    Module rb_mRice = define_module("Rice");
+    Module rb_mLibc = define_module_under(rb_mRice, "libc");
+    rb_cLibcFile = define_class_under<FILE>(rb_mLibc, "File");
+  }
+}
+
+namespace Rice::detail
+{
+  template<>
+  struct Type<FILE>
+  {
+    static bool verify()
+    {
+      if (!Data_Type<FILE>::is_defined())
+      {
+        libc::define_libc_file();
+      }
+
+      return true;
+    }
+  };
+}

data/rice/rice.hpp

@@ -1,64 +1,154 @@
 #ifndef Rice__hpp_
 #define Rice__hpp_
 
-// Traits
+// Ruby
 #include "detail/ruby.hpp"
+
+// C++ headers -h has to come after Ruby on MacOS for reasons I do not understand
+#include <cstdio>
+#include <string>
+#include <typeinfo>
+#include <typeindex>
+
+#ifdef _MSC_VER
+  // Prevent _strdup deprecated message on MSVC
+  #define strdup _strdup 
+#endif
+
+// Traits
 #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 "Exception.hpp"
+#include "JumpException.hpp"
+#include "JumpException.ipp"
 #include "detail/RubyFunction.hpp"
+#include "detail/RubyFunction.ipp"
+#include "detail/to_ruby.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 "Return.hpp"
 #include "Arg.hpp"
+#include "Return.hpp"
 #include "detail/MethodInfo.hpp"
 #include "detail/from_ruby.hpp"
-#include "detail/to_ruby.hpp"
-#include "Identifier.hpp"
-#include "Exception.ipp"
-#include "detail/NativeAttribute.hpp"
-#include "detail/NativeFunction.hpp"
-#include "detail/NativeIterator.hpp"
-#include "HandlerRegistration.hpp"
 
-// C++ classes for using the Ruby API
+// C++ API declarations
+#include "detail/Type.hpp"
+#include "cpp_api/Encoding.hpp"
+#include "cpp_api/Identifier.hpp"
+#include "cpp_api/Identifier.ipp"
 #include "cpp_api/Object.hpp"
 #include "cpp_api/Builtin_Object.hpp"
 #include "cpp_api/String.hpp"
+#include "cpp_api/Symbol.hpp"
 #include "cpp_api/Array.hpp"
 #include "cpp_api/Hash.hpp"
-#include "cpp_api/Symbol.hpp"
+
 #include "cpp_api/Module.hpp"
 #include "cpp_api/Class.hpp"
+
+#include "detail/Native.hpp"
+#include "detail/NativeAttributeGet.hpp"
+#include "detail/NativeAttributeSet.hpp"
+#include "Data_Type.hpp"
+#include "Data_Object.hpp"
+
+// Type Conversion declarations
+#include "detail/RubyType.hpp"
+#include "detail/RubyType.ipp"
+#include "detail/Wrapper.hpp"
+
+// Registries
+#include "detail/TypeRegistry.hpp"
+#include "detail/InstanceRegistry.hpp"
+#include "detail/DefaultHandler.hpp"
+#include "detail/HandlerRegistry.hpp"
+#include "detail/NativeRegistry.hpp"
+#include "detail/Registries.hpp"
+
+// To / From Ruby
+#include "Arg.ipp"
+#include "Return.ipp"
+#include "Constructor.hpp"
+#include "Buffer.hpp"
+#include "Buffer.ipp"
+#include "detail/to_ruby.ipp"
+#include "detail/from_ruby.ipp"
+#include "detail/Proc.hpp"
+
+// Registries
+#include "detail/TypeRegistry.ipp"
+#include "detail/InstanceRegistry.ipp"
+#include "detail/DefaultHandler.ipp"
+#include "detail/HandlerRegistry.ipp"
+#include "detail/NativeRegistry.ipp"
+#include "detail/Registries.ipp"
+
+#include "detail/Type.ipp"
+
+// Code for Ruby to call C++
+#include "Exception.ipp"
+#include "detail/cpp_protect.hpp"
+#include "detail/Wrapper.ipp"
+#include "detail/MethodInfo.ipp"
+#include "detail/Native.ipp"
+#include "detail/NativeAttributeGet.ipp"
+#include "detail/NativeAttributeSet.ipp"
+#include "detail/NativeFunction.hpp"
+#include "detail/NativeFunction.ipp"
+#include "detail/NativeIterator.hpp"
+#include "detail/NativeIterator.ipp"
+#include "detail/NativeCallbackFFI.hpp"
+#include "detail/NativeCallbackFFI.ipp"
+#include "detail/NativeCallbackSimple.hpp"
+#include "detail/NativeCallbackSimple.ipp"
+#include "detail/Proc.ipp"
+
+// C++ API definitions
+#include "cpp_api/Encoding.ipp"
+#include "cpp_api/Object.ipp"
+#include "cpp_api/Builtin_Object.ipp"
+#include "cpp_api/String.ipp"
+#include "cpp_api/Array.ipp"
+#include "cpp_api/Hash.ipp"
+#include "cpp_api/Symbol.ipp"
+
+#include "cpp_api/Module.ipp"
+#include "cpp_api/Class.ipp"
 #include "cpp_api/Struct.hpp"
+#include "cpp_api/Struct.ipp"
+
 #include "Address_Registration_Guard.hpp"
+#include "Address_Registration_Guard.ipp"
 #include "global_function.hpp"
+#include "global_function.ipp"
 
-// Code involed in creating custom DataTypes (ie, Ruby classes that wrap C++ classes)
+// Code involved 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 "Data_Type.ipp"
 #include "detail/default_allocation_func.ipp"
-#include "Constructor.hpp"
-#include "Data_Object.hpp"
+#include "Constructor.ipp"
+#include "Callback.hpp"
+#include "Callback.ipp"
+#include "Data_Object.ipp"
 #include "Enum.hpp"
+#include "Enum.ipp"
+#include "MemoryView.hpp"
+#include "MemoryView.ipp"
 
 // Dependent on Module, Class, Array and String
 #include "forward_declares.ipp"
 
+// For now include libc support - maybe should be separate header file someday
+#include "libc/file.hpp"
+
+// Initialize Rice
+#include "Init.hpp"
+#include "Init.ipp"
+
 #endif // Rice__hpp_

data/rice/ruby_mark.hpp

@@ -1,5 +1,5 @@
-#ifndef ruby_mark__hpp
-#define ruby_mark__hpp
+#ifndef Rice__ruby_mark__hpp_
+#define Rice__ruby_mark__hpp_
 
 //! Default function to call to mark a data object.
 /*! This function can be specialized for a particular type to override
@@ -12,4 +12,5 @@ namespace Rice
   {
   }
 }
-#endif // ruby_mark__hpp
+#endif // Rice__ruby_mark__hpp_
+

data/rice/stl/complex.hpp

@@ -0,0 +1,6 @@
+#ifndef Rice__stl__complex__hpp_
+#define Rice__stl__complex__hpp_
+
+#include "complex.ipp"
+
+#endif // Rice__stl__complex__hpp_

data/rice/stl/complex.ipp

@@ -0,0 +1,93 @@
+#include <complex>
+
+namespace Rice::detail
+{
+  template<typename T>
+  struct Type<std::complex<T>>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+  };
+
+  template<typename T>
+  class To_Ruby<std::complex<T>>
+  {
+  public:
+    VALUE convert(const std::complex<T>& data)
+    {
+      std::vector<VALUE> args(2);
+      args[0] = To_Ruby<T>().convert(data.real());
+      args[1] = To_Ruby<T>().convert(data.imag());
+      return protect(rb_funcallv, rb_mKernel, rb_intern("Complex"), (int)args.size(), (const VALUE*)args.data());
+    }
+  };
+
+  template<typename T>
+  class To_Ruby<std::complex<T>&>
+  {
+  public:
+    VALUE convert(const std::complex<T>& data)
+    {
+      std::vector<VALUE> args(2);
+      args[0] = To_Ruby<T>().convert(data.real());
+      args[1] = To_Ruby<T>().convert(data.imag());
+      return protect(rb_funcallv, rb_mKernel, rb_intern("Complex"), (int)args.size(), (const VALUE*)args.data());
+    }
+  };
+
+  template<typename T>
+  class From_Ruby<std::complex<T>>
+  {
+  public:
+    Convertible is_convertible(VALUE value)
+    {
+      switch (rb_type(value))
+      {
+        case RUBY_T_COMPLEX:
+          return Convertible::Exact;
+          break;
+        default:
+          return Convertible::None;
+      }
+    }
+
+    std::complex<T> convert(VALUE value)
+    {
+      VALUE real = protect(rb_funcallv, value, rb_intern("real"), 0, (const VALUE*)nullptr);
+      VALUE imaginary = protect(rb_funcallv, value, rb_intern("imaginary"), 0, (const VALUE*)nullptr);
+
+      return std::complex<T>(From_Ruby<T>().convert(real), From_Ruby<T>().convert(imaginary));
+    }
+  };
+
+  template<typename T>
+  class From_Ruby<std::complex<T>&>
+  {
+  public:
+    Convertible is_convertible(VALUE value)
+    {
+      switch (rb_type(value))
+      {
+        case RUBY_T_COMPLEX:
+          return Convertible::Exact;
+          break;
+        default:
+          return Convertible::None;
+      }
+    }
+
+    std::complex<T>& convert(VALUE value)
+    {
+      VALUE real = protect(rb_funcallv, value, rb_intern("real"), 0, (const VALUE*)nullptr);
+      VALUE imaginary = protect(rb_funcallv, value, rb_intern("imaginary"), 0, (const VALUE*)nullptr);
+      this->converted_ = std::complex<T>(From_Ruby<T>().convert(real), From_Ruby<T>().convert(imaginary));
+
+      return this->converted_;
+    }
+
+  private:
+    std::complex<T> converted_;
+  };
+}

data/rice/stl/exception.hpp

@@ -0,0 +1,11 @@
+#ifndef Rice__stl__exception__hpp_
+#define Rice__stl__exception__hpp_
+
+namespace Rice::stl
+{
+  extern Class rb_cStlException;
+}
+
+#include "exception.ipp"
+
+#endif // Rice__stl__exception__hpp_

data/rice/stl/exception.ipp

@@ -0,0 +1,29 @@
+#include <exception>
+
+// Libraries sometime inherit custom exception objects from std::exception,
+// so define it for Ruby if necessary
+namespace Rice::stl
+{
+  inline Class rb_cStlException;
+
+  inline void define_stl_exception()
+  {
+    Module rb_mStd = define_module("Std");
+    rb_cStlException = define_class_under<std::exception>(rb_mStd, "Exception", rb_eStandardError).
+                        define_constructor(Constructor<std::exception>()).
+                        define_method("message", &std::exception::what);
+  }
+}
+
+namespace Rice::detail
+{
+  template<>
+  struct Type<std::exception>
+  {
+    static bool verify()
+    {
+      Rice::stl::define_stl_exception();
+      return true;
+    }
+  };
+}

data/rice/stl/exception_ptr.hpp

@@ -0,0 +1,6 @@
+#ifndef Rice__stl__exception_ptr__hpp_
+#define Rice__stl__exception_ptr__hpp_
+
+#include "exception_ptr.ipp"
+
+#endif // Rice__stl__exception_ptr__hpp_

data/rice/stl/exception_ptr.ipp

@@ -0,0 +1,27 @@
+#include <exception>
+
+namespace Rice::stl
+{
+  inline Data_Type<std::exception_ptr> define_exception_ptr()
+  {
+    Module rb_mStd = define_module("Std");
+    return define_class_under<std::exception_ptr>(rb_mStd, "ExceptionPtr");
+  }
+}
+
+namespace Rice::detail
+{
+  template<>
+  struct Type<std::exception_ptr>
+  {
+    static bool verify()
+    {
+      if (!Data_Type<std::exception_ptr>::is_defined())
+      {
+        stl::define_exception_ptr();
+      }
+
+      return true;
+    }
+  };
+}

data/rice/stl/map.hpp

@@ -0,0 +1,12 @@
+#ifndef Rice__stl__map__hpp_
+#define Rice__stl__map__hpp_
+
+namespace Rice
+{
+  template<typename K, typename T>
+  Data_Type<std::map<K, T>> define_map(std::string name = "");
+}
+
+#include "map.ipp"
+
+#endif // Rice__stl__map__hpp_