rice 3.0.0 → 4.0.0

data/rice/detail/to_ruby_defn.hpp

@@ -0,0 +1,48 @@
+#ifndef Rice__detail__to_ruby_defn__hpp_
+#define Rice__detail__to_ruby_defn__hpp_
+
+#include "rice_traits.hpp"
+
+namespace Rice
+{
+  namespace detail
+  {
+    //! Convert a C++ object to Ruby.
+    /*! If x is a pointer, wraps the pointee as a Ruby object.  If x is an
+     *  Object, returns x.
+     *
+     *  If no conversion exists a compile-time error is generated.
+     *
+     *  \param x the object to convert.
+     *  \return a Ruby representation of the C++ object.
+     *
+     *  Example:
+     *  \code
+     *    rb_p(to_ruby(42));
+     *
+     *    Foo * p_foo = new Foo();
+     *    rb_p(to_ruby(p_foo));
+     *  \endcode
+     */
+    template <typename T>
+    class To_Ruby;
+   
+    // Helper template function that let's users avoid having to specify the template type - its deduced
+    template <typename T>
+    VALUE to_ruby(T&& x)
+    {
+      using Unqualified_T = remove_cv_recursive_t<T>;
+      return To_Ruby<Unqualified_T>().convert(std::forward<T>(x));
+    }
+
+    // Helper template function that let's users avoid having to specify the template type - its deduced
+    template <typename T>
+    VALUE to_ruby(T* x)
+    {
+      using Unqualified_T = remove_cv_recursive_t<T>;
+      return To_Ruby<Unqualified_T*>().convert(x);
+    }
+  } // detail
+} // Rice
+
+#endif // Rice__detail__to_ruby_defn__hpp_

data/rice/forward_declares.ipp

@@ -0,0 +1,82 @@
+#ifndef Rice__Forward_Declares__ipp_
+#define Rice__Forward_Declares__ipp_
+
+namespace Rice
+{
+  // These methods cannot be defined where they are declared due to circular dependencies
+  inline Class Object::class_of() const
+  {
+    return detail::protect(rb_class_of, value_);
+  }
+
+  inline String Object::to_s() const
+  {
+    return call("to_s");
+  }
+
+  inline String Object::class_name() const
+  {
+    return detail::protect(rb_obj_classname, this->value());
+  }
+
+  inline String Object::inspect() const
+  {
+    return call("inspect");
+  }
+
+  inline Object Object::instance_eval(String const& s)
+  {
+    const VALUE argv[] = { s.value() };
+    return detail::protect(rb_obj_instance_eval, 1, &argv[0], this->value());
+  }
+
+  inline Object Object::vcall(Identifier id, Array args)
+  {
+    std::vector<VALUE> a(args.size());
+
+    Array::const_iterator it = args.begin();
+    Array::const_iterator end = args.end();
+
+    for (int i = 0; it != end; i++, ++it)
+    {
+      a[i] = it->value();
+    }
+
+    return detail::protect(rb_funcall3, this->value(), id.id(), (int)args.size(), (const VALUE*)a.data());
+  }
+
+  inline std::ostream& operator<<(std::ostream& out, Object const& obj)
+  {
+    String s(obj.to_s());
+    out << s.c_str();
+    return out;
+  }
+
+  inline Identifier::Identifier(Symbol const& symbol) : id_(SYM2ID(symbol.value()))
+  {
+  }
+
+  inline String Module::name() const
+  {
+    VALUE name = detail::protect(rb_mod_name, this->value());
+    if (name == Qnil)
+    {
+      return String("");
+    }
+    else
+    {
+      return name;
+    }
+  }
+
+  inline Array Module::ancestors() const
+  {
+    return detail::protect(rb_mod_ancestors, this->value());
+  }
+
+  inline Class Module::singleton_class() const
+  {
+    return CLASS_OF(value());
+  }
+}
+#endif // Rice__Forward_Declares__ipp_

data/rice/global_function.hpp

@@ -5,27 +5,23 @@
 
 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);
 
-  /**
-   * Helper forwarder method to easily wrap
-   * globally available functions. This simply
-   * forwards off a call to define_module_function
-   * on rb_mKernel
-   */
-  template<typename Func_T>
-  void define_global_function(
-      char const * name,
-      Func_T func,
-      Arguments* arguments = 0);
-
-  // FIXME: See Module::define_method with Arg
-  template<typename Func_T>
-  void define_global_function(
-      char const * name,
-      Func_T func,
-      Arg const& arg);
-  
-
+   //! 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
+    *  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>
+  void define_global_function(char const * name, Function_T&& func, Arg_Ts const& ...args);
 } // Rice
 
 #include "global_function.ipp"

data/rice/global_function.ipp

@@ -1,22 +1,13 @@
-#include "detail/define_method_and_auto_wrap.hpp"
+#include "cpp_api/Module.hpp"
 
-template<typename Func_T>
-void Rice::define_global_function(
-    char const * name,
-    Func_T func,
-    Arguments* arguments)
+template<typename Function_T>
+void Rice::define_global_function(char const * name, Function_T&& func, MethodInfo* methodInfo)
 {
-  Module(rb_mKernel).define_module_function(name, func, arguments);
+  Module(rb_mKernel).define_module_function(name, std::forward<Function_T>(func), methodInfo);
 }
 
-template<typename Func_T>
-void Rice::define_global_function(
-    char const * name,
-    Func_T func,
-    Arg const& arg)
+template<typename Function_T, typename...Arg_Ts>
+void Rice::define_global_function(char const * name, Function_T&& func, Arg_Ts const& ...args)
 {
-  Arguments* args = new Arguments();
-  args->add(arg);
-  define_global_function(name, func, args);
-}
-
+  Module(rb_mKernel).define_module_function(name, std::forward<Function_T>(func), args...);
+}

data/rice/rice.hpp

@@ -0,0 +1,59 @@
+#ifndef Rice__hpp_
+#define Rice__hpp_
+
+#include "detail/ruby.hpp"
+#include "detail/rice_traits.hpp"
+#include "detail/function_traits.hpp"
+#include "detail/Type.hpp"
+#include "detail/TypeRegistry.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/from_ruby.hpp"
+#include "detail/to_ruby.hpp"
+#include "detail/MethodInfo.hpp"
+#include "detail/Exception_Handler.hpp"
+#include "detail/Iterator.hpp"
+#include "Exception.ipp"
+#include "detail/method_data.hpp"
+#include "ruby_try_catch.hpp"
+#include "detail/NativeAttribute.hpp"
+#include "detail/NativeFunction.hpp"
+
+#include "ruby_mark.hpp"
+
+#include "Identifier.hpp"
+
+#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 "Director.hpp"
+#include "Data_Type.hpp"
+#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
+#include "forward_declares.ipp"
+
+#endif // Rice__hpp_

data/rice/ruby_mark.hpp

@@ -5,9 +5,11 @@
 /*! This function can be specialized for a particular type to override
  *  the default behavior (which is to not mark any additional objects).
  */
-template<typename T>
-void ruby_mark(T * /* obj */)
+namespace Rice
 {
+  template<typename T>
+  void ruby_mark(T* data)
+  {
+  }
 }
-
 #endif // ruby_mark__hpp

data/rice/ruby_try_catch.hpp

@@ -1,11 +1,11 @@
 #ifndef Rice__ruby_try_catch__hpp_
 #define Rice__ruby_try_catch__hpp_
 
-#include "Exception_Base_defn.hpp"
-#include "Jump_Tag.hpp"
-#include "detail/ruby.hpp"
 #include <stdexcept>
 
+#include "detail/Jump_Tag.hpp"
+#include "Exception_defn.hpp"
+
 /*! \def RUBY_TRY
  *  \brief Start a block to catch Ruby exceptions and rethrow them.
  */
@@ -41,7 +41,7 @@
  *  \brief End a RUBY_TRY block.
  */
 #define RUBY_CATCH \
-  catch(::Rice::Exception_Base const & ex) \
+  catch(::Rice::Exception const & ex) \
   { \
     RUBY_RETHROW(ex.value()); \
   } \

data/rice/stl.hpp

@@ -0,0 +1,11 @@
+#ifndef Rice__stl__hpp_
+#define Rice__stl__hpp_
+
+#include "stl/string.hpp"
+#include "stl/complex.hpp"
+#include "stl/optional.hpp"
+#include "stl/pair.hpp"
+#include "stl/smart_ptr.hpp"
+#include "stl/vector.hpp"
+
+#endif // Rice__stl__hpp_

data/sample/callbacks/extconf.rb

@@ -1,3 +1,6 @@
+require 'bundler/setup'
+require 'rice'
 require 'mkmf-rice'
+
 create_makefile('sample_callbacks')
 

data/sample/callbacks/sample_callbacks.cpp

@@ -1,24 +1,25 @@
-#include "rice/Data_Type.hpp"
-#include "rice/Constructor.hpp"
-#include "rice/String.hpp"
+#include <rice/rice.hpp>
 
 using namespace Rice;
 
 namespace
 {
 
-  class CallbackHolder {
+  class CallbackHolder
+  {
     public:
 
-    void registerCallback(Rice::Object cb) {
-      callback = cb;
+    void registerCallback(Rice::Object cb)
+    {
+      callback_ = cb;
     }
 
-    Rice::Object fireCallback(Rice::String param) {
-      return callback.call("call", param);
+    Rice::Object fireCallback(Rice::String param)
+    {
+      return callback_.call("call", param);
     }
 
-    Rice::Object callback;
+    Rice::Object callback_;
   };
 
 } // namespace
@@ -26,13 +27,9 @@ namespace
 extern "C"
 void Init_sample_callbacks()
 {
-  RUBY_TRY
-  {
     define_class<CallbackHolder>("CallbackHolder")
       .define_constructor(Constructor<CallbackHolder>())
       .define_method("register_callback", &CallbackHolder::registerCallback)
       .define_method("fire_callback", &CallbackHolder::fireCallback);
-  }
-  RUBY_CATCH
 }
 

data/sample/enum/extconf.rb

@@ -1,3 +1,6 @@
+require 'bundler/setup'
+require 'rice'
 require 'mkmf-rice'
+
 create_makefile('sample_enum')
 

data/sample/enum/sample_enum.cpp

@@ -1,5 +1,4 @@
-#include "rice/Enum.hpp"
-#include "rice/ruby_try_catch.hpp"
+#include <rice/rice.hpp>
 
 using namespace Rice;
 
@@ -13,8 +12,6 @@ enum Sample_Enum
   SE_BAZ = 100,
 };
 
-Rice::Enum<Sample_Enum> sample_enum_type;
-
 char const * description(Sample_Enum e)
 {
   switch(e)
@@ -28,27 +25,16 @@ char const * description(Sample_Enum e)
 
 } // namespace
 
-template<>
-Sample_Enum from_ruby<Sample_Enum>(Object x)
-{
-  Data_Object<Sample_Enum> d(x, sample_enum_type);
-  return *d;
-}
-
 extern "C"
 void Init_sample_enum()
 {
-  RUBY_TRY
-  {
-    sample_enum_type =
+    Rice::Enum<Sample_Enum> sample_enum_type =
       define_enum<Sample_Enum>("Sample_Enum")
       .define_value("FOO", SE_FOO)
       .define_value("BAR", SE_BAR)
       .define_value("BAZ", SE_BAZ);
-     
+
     sample_enum_type
       .define_method("description", description);
-  }
-  RUBY_CATCH
 }
 

data/sample/enum/test.rb

@@ -1,8 +1,8 @@
-require 'sample_enum'
+require_relative 'sample_enum'
 
 Sample_Enum.each { |x| p x }
 s = Sample_Enum::FOO
 puts s
 puts s.inspect
 puts s < Sample_Enum::BAR
-
+s.description