rice 4.5.0 → 4.6.0

data/rice/global_function.ipp

@@ -2,5 +2,5 @@
 template<typename Function_T, typename...Arg_Ts>
 void Rice::define_global_function(char const * name, Function_T&& func, Arg_Ts const& ...args)
 {
-    Module(rb_mKernel).define_module_function(name, std::forward<Function_T>(func), args...);
+  Module(rb_mKernel).define_module_function(name, std::forward<Function_T>(func), 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

@@ -21,15 +21,19 @@
 #include "traits/method_traits.hpp"
 #include "traits/attribute_traits.hpp"
 
-// Helpers
-#include "detail/TupleIterator.hpp"
-
 // Code for C++ to call Ruby
 #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 "Arg.hpp"
+#include "Return.hpp"
+#include "detail/MethodInfo.hpp"
+#include "detail/from_ruby.hpp"
 
 // C++ API declarations
 #include "detail/Type.hpp"
@@ -43,13 +47,19 @@
 #include "cpp_api/Array.hpp"
 #include "cpp_api/Hash.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"
-#include "detail/to_ruby.hpp"
-#include "detail/from_ruby.hpp"
-#include "detail/Native.hpp"
 
 // Registries
 #include "detail/TypeRegistry.hpp"
@@ -60,10 +70,11 @@
 #include "detail/Registries.hpp"
 
 // To / From Ruby
-#include "Arg.hpp"
 #include "Arg.ipp"
-#include "Return.hpp"
 #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"
@@ -82,12 +93,9 @@
 #include "Exception.ipp"
 #include "detail/cpp_protect.hpp"
 #include "detail/Wrapper.ipp"
-#include "detail/MethodInfo.hpp"
 #include "detail/MethodInfo.ipp"
 #include "detail/Native.ipp"
-#include "detail/NativeAttributeGet.hpp"
 #include "detail/NativeAttributeGet.ipp"
-#include "detail/NativeAttributeSet.hpp"
 #include "detail/NativeAttributeSet.ipp"
 #include "detail/NativeFunction.hpp"
 #include "detail/NativeFunction.ipp"
@@ -108,9 +116,7 @@
 #include "cpp_api/Hash.ipp"
 #include "cpp_api/Symbol.ipp"
 
-#include "cpp_api/Module.hpp"
 #include "cpp_api/Module.ipp"
-#include "cpp_api/Class.hpp"
 #include "cpp_api/Class.ipp"
 #include "cpp_api/Struct.hpp"
 #include "cpp_api/Struct.ipp"
@@ -124,14 +130,11 @@
 #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 "Constructor.ipp"
 #include "Callback.hpp"
 #include "Callback.ipp"
-#include "Data_Object.hpp"
 #include "Data_Object.ipp"
 #include "Enum.hpp"
 #include "Enum.ipp"
@@ -144,4 +147,8 @@
 // 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/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_