rice 4.2.1 → 4.3.0

data/rice/Data_Type.ipp

@@ -11,6 +11,7 @@
 #include "detail/NativeIterator.hpp"
 #include "cpp_api/Class.hpp"
 #include "cpp_api/String.hpp"
+#include "ruby_mark.hpp"
 
 #include <stdexcept>
 

data/rice/Identifier.hpp

@@ -1,50 +1,50 @@
-#ifndef Rice__Identifier__hpp_
-#define Rice__Identifier__hpp_
-
-#include <string>
-
-namespace Rice
-{
-  class Symbol;
-
-  //! A wrapper for the ID type
-  /*! An ID is ruby's internal representation of a Symbol object.
-   */
-  class Identifier
-  {
-  public:
-    //! Construct a new Identifier from an ID.
-    Identifier(ID id);
-
-    //! Construct a new Identifier from a Symbol.
-    Identifier(Symbol const& symbol);
-
-    //! Construct a new Identifier from a c string.
-    Identifier(char const* s);
-
-    //! Construct a new Identifier from a string.
-    Identifier(std::string const string);
-
-    //! Return a string representation of the Identifier.
-    char const* c_str() const;
-
-    //! Return a string representation of the Identifier.
-    std::string str() const;
-
-    //! Return the underlying ID
-    ID id() const { return id_; }
-
-    //! Return the underlying ID
-    operator ID() const { return id_; }
-
-    //! Return the ID as a Symbol
-    VALUE to_sym() const;
-
-  private:
-    ID id_;
-  };
-} // namespace Rice
-
-#include "Identifier.ipp"
-
-#endif // Rice__Identifier__hpp_
+#ifndef Rice__Identifier__hpp_
+#define Rice__Identifier__hpp_
+
+#include <string>
+
+namespace Rice
+{
+  class Symbol;
+
+  //! A wrapper for the ID type
+  /*! An ID is ruby's internal representation of a Symbol object.
+   */
+  class Identifier
+  {
+  public:
+    //! Construct a new Identifier from an ID.
+    Identifier(ID id);
+
+    //! Construct a new Identifier from a Symbol.
+    Identifier(Symbol const& symbol);
+
+    //! Construct a new Identifier from a c string.
+    Identifier(char const* s);
+
+    //! Construct a new Identifier from a string.
+    Identifier(std::string const& string);
+
+    //! Return a string representation of the Identifier.
+    char const* c_str() const;
+
+    //! Return a string representation of the Identifier.
+    std::string str() const;
+
+    //! Return the underlying ID
+    ID id() const { return id_; }
+
+    //! Return the underlying ID
+    operator ID() const { return id_; }
+
+    //! Return the ID as a Symbol
+    VALUE to_sym() const;
+
+  private:
+    ID id_;
+  };
+} // namespace Rice
+
+#include "Identifier.ipp"
+
+#endif // Rice__Identifier__hpp_

data/rice/Identifier.ipp

@@ -1,29 +1,29 @@
-namespace Rice
-{
-  inline Identifier::Identifier(ID id) : id_(id)
-  {
-  }
-
-  inline Identifier::Identifier(char const* s) : id_(rb_intern(s))
-  {
-  }
-
-  inline Identifier::Identifier(std::string const s) : id_(rb_intern(s.c_str()))
-  {
-  }
-
-  inline char const* Identifier::c_str() const
-  {
-    return detail::protect(rb_id2name, id_);
-  }
-
-  inline std::string Identifier::str() const
-  {
-    return c_str();
-  }
-
-  inline VALUE Identifier::to_sym() const
-  {
-    return ID2SYM(id_);
-  }
+namespace Rice
+{
+  inline Identifier::Identifier(ID id) : id_(id)
+  {
+  }
+
+  inline Identifier::Identifier(char const* s) : id_(rb_intern(s))
+  {
+  }
+
+  inline Identifier::Identifier(std::string const& s) : id_(rb_intern2(s.c_str(), s.size()))
+  {
+  }
+
+  inline char const* Identifier::c_str() const
+  {
+    return detail::protect(rb_id2name, id_);
+  }
+
+  inline std::string Identifier::str() const
+  {
+    return c_str();
+  }
+
+  inline VALUE Identifier::to_sym() const
+  {
+    return ID2SYM(id_);
+  }
 }

data/rice/detail/NativeFunction.hpp

@@ -1,119 +1,119 @@
-#ifndef Rice__detail__Native_Function__hpp_
-#define Rice__detail__Native_Function__hpp_
-
-#include "ruby.hpp"
-#include "ExceptionHandler_defn.hpp"
-#include "MethodInfo.hpp"
-#include "../traits/function_traits.hpp"
-#include "../traits/method_traits.hpp"
-#include "from_ruby.hpp"
-
-namespace Rice::detail
-{
-  //! The NativeFunction class calls C++ functions/methods/lambdas on behalf of Ruby
-  /*! The NativeFunction class is an intermediate between Ruby and C++. Every method
-   *  defined in Rice is associated with a NativeFuntion instance that is stored in
-   *  a unordered_map maintained by the MethodData class. The key is the Ruby class
-   *  and method.
-   * 
-   *  When Ruby calls into C++ it invokes the static NativeFunction.call method. This
-   *  method then looks up the NativeFunction instance and calls its ->() operator.
-   *
-   *  The instance then converts each of the arguments passed from Ruby into their
-   *  C++ equivalents. It then retrieves the C++ object (if there is one, Ruby could
-   *  be calling a free standing method or lambda). Then it calls the C++ method
-   *  and gets back the result. If there is a result (so not void), it is converted
-   *  from a C++ object to a Ruby object and returned back to Ruby.
-   * 
-   *  This class make heavy use of C++ Template metaprogramming to determine
-   *  the types and parameters a method takes. It then uses that information
-   *  to perform type conversion Ruby to C++.
-   *   
-   *  @tparam From_Ruby_T - The type of C++ class wrapped by Ruby. Note
-   *    this may be different than the Class of Function_T. For example, 
-   *    std::map has a size() method but that is actually implemented on 
-   *    an ancestor class _Tree. Thus From_Ruby_T is std::map but 
-   *    Function_T::Class_T is _Tree. This typename must be specified
-   *    by the calling code.
-   *  @tparam Function_T - A template that represents the C++ function
-   *    to call. This typename is automatically deduced by the compiler.
-   *  @tparam IsMethod - A boolean specifying whether the function has
-   *    a self parameter or not. Rice differentiates these two cases by
-   *    calling them methods (self) or functions (no self).
-   */
-
-  template<typename From_Ruby_T, typename Function_T, bool IsMethod>
-  class NativeFunction
-  {
-  public:
-    using NativeFunction_T = NativeFunction<From_Ruby_T, Function_T, IsMethod>;
-
-    // We remove const to avoid an explosion of To_Ruby specializations and Ruby doesn't
-    // have the concept of constants anyways
-    using Return_T = remove_cv_recursive_t<typename function_traits<Function_T>::return_type>;
-    using Class_T = typename method_traits<Function_T, IsMethod>::Class_T;
-    using Arg_Ts = typename method_traits<Function_T, IsMethod>::Arg_Ts;
-    using From_Ruby_Args_Ts = typename tuple_map<From_Ruby, Arg_Ts>::type;
-
-    // Register function with Ruby
-    static void define(VALUE klass, std::string method_name, Function_T function, MethodInfo* methodInfo);
-
-    // Static member function that Ruby calls
-    static VALUE call(int argc, VALUE* argv, VALUE self);
-
-  public:
-    // Disallow creating/copying/moving
-    NativeFunction() = delete;
-    NativeFunction(const NativeFunction_T&) = delete;
-    NativeFunction(NativeFunction_T&&) = delete;
-    void operator=(const NativeFunction_T&) = delete;
-    void operator=(NativeFunction_T&&) = delete;
-
-    // Invokes the wrapped function
-    VALUE operator()(int argc, VALUE* argv, VALUE self);
-
-  protected:
-    NativeFunction(VALUE klass, std::string method_name, Function_T function, MethodInfo* methodInfo);
-
-  private:
-    template<typename T, std::size_t I>
-    From_Ruby<T> createFromRuby();
-      
-    // Create NativeArgs which are used to convert values from Ruby to C++
-    template<std::size_t...I>
-    From_Ruby_Args_Ts createFromRuby(std::index_sequence<I...>& indices);
-
-    To_Ruby<Return_T> createToRuby();
-      
-    // Convert Ruby argv pointer to Ruby values
-    std::vector<VALUE> getRubyValues(int argc, VALUE* argv);
-
-    // Convert Ruby values to C++ values
-    template<typename std::size_t...I>
-    Arg_Ts getNativeValues(std::vector<VALUE>& values, std::index_sequence<I...>& indices);
-
-    // Figure out what self is
-    Class_T getReceiver(VALUE self);
-
-    // Throw an exception when wrapper cannot be extracted
-    [[noreturn]] void noWrapper(const VALUE klass, const std::string& wrapper);
-
-    // Do we need to keep alive any arguments?
-    void checkKeepAlive(VALUE self, VALUE returnValue, std::vector<VALUE>& rubyValues);
-
-    // Call the underlying C++ function
-    VALUE invokeNativeFunction(const Arg_Ts& nativeArgs);
-    VALUE invokeNativeMethod(VALUE self, const Arg_Ts& nativeArgs);
-
-  private:
-    VALUE klass_;
-    std::string method_name_;
-    Function_T function_;
-    From_Ruby_Args_Ts fromRubys_;
-    To_Ruby<Return_T> toRuby_;
-    std::unique_ptr<MethodInfo> methodInfo_;
-  };
-}
-#include "NativeFunction.ipp"
-
-#endif // Rice__detail__Native_Function__hpp_
+#ifndef Rice__detail__Native_Function__hpp_
+#define Rice__detail__Native_Function__hpp_
+
+#include "ruby.hpp"
+#include "ExceptionHandler_defn.hpp"
+#include "MethodInfo.hpp"
+#include "../traits/function_traits.hpp"
+#include "../traits/method_traits.hpp"
+#include "from_ruby.hpp"
+
+namespace Rice::detail
+{
+  //! The NativeFunction class calls C++ functions/methods/lambdas on behalf of Ruby
+  /*! The NativeFunction class is an intermediate between Ruby and C++. Every method
+   *  defined in Rice is associated with a NativeFuntion instance that is stored in
+   *  a unordered_map maintained by the MethodData class. The key is the Ruby class
+   *  and method.
+   * 
+   *  When Ruby calls into C++ it invokes the static NativeFunction.call method. This
+   *  method then looks up the NativeFunction instance and calls its ->() operator.
+   *
+   *  The instance then converts each of the arguments passed from Ruby into their
+   *  C++ equivalents. It then retrieves the C++ object (if there is one, Ruby could
+   *  be calling a free standing method or lambda). Then it calls the C++ method
+   *  and gets back the result. If there is a result (so not void), it is converted
+   *  from a C++ object to a Ruby object and returned back to Ruby.
+   * 
+   *  This class make heavy use of C++ Template metaprogramming to determine
+   *  the types and parameters a method takes. It then uses that information
+   *  to perform type conversion Ruby to C++.
+   *   
+   *  @tparam Receiver_T - The type of C++ class wrapped by Ruby. Althought NativeFunction
+   *    can derive the C++ class (Receiver_T), it can differ per member function. For example,
+   *    std::map has a size() method but that is actually implemented on an ancestor class _Tree.
+   *    Thus Receiver_T is std::map but Function_T::Receiver_T is _Tree. This breaks Rice in two ways. 
+   *    First, _Tree is not a registered type. Second, Rice would return a _Tree instance back to
+   *    C++ and not a std::map.
+   *  @tparam Function_T - A template that represents the C++ function
+   *    to call. This typename is automatically deduced by the compiler.
+   *  @tparam IsMethod - A boolean specifying whether the function has
+   *    a self parameter or not. Rice differentiates these two cases by
+   *    calling them methods (self) or functions (no self).
+   */
+
+  template<typename Class_T, typename Function_T, bool IsMethod>
+  class NativeFunction
+  {
+  public:
+    using NativeFunction_T = NativeFunction<Class_T, Function_T, IsMethod>;
+
+    // We remove const to avoid an explosion of To_Ruby specializations and Ruby doesn't
+    // have the concept of constants anyways
+    using Return_T = remove_cv_recursive_t<typename function_traits<Function_T>::return_type>;
+    using Receiver_T = typename method_traits<Function_T, IsMethod>::Class_T;
+    using Arg_Ts = typename method_traits<Function_T, IsMethod>::Arg_Ts;
+    using From_Ruby_Args_Ts = typename tuple_map<From_Ruby, Arg_Ts>::type;
+
+    // Register function with Ruby
+    static void define(VALUE klass, std::string method_name, Function_T function, MethodInfo* methodInfo);
+
+    // Static member function that Ruby calls
+    static VALUE call(int argc, VALUE* argv, VALUE self);
+
+  public:
+    // Disallow creating/copying/moving
+    NativeFunction() = delete;
+    NativeFunction(const NativeFunction_T&) = delete;
+    NativeFunction(NativeFunction_T&&) = delete;
+    void operator=(const NativeFunction_T&) = delete;
+    void operator=(NativeFunction_T&&) = delete;
+
+    // Invokes the wrapped function
+    VALUE operator()(int argc, VALUE* argv, VALUE self);
+
+  protected:
+    NativeFunction(VALUE klass, std::string method_name, Function_T function, MethodInfo* methodInfo);
+
+  private:
+    template<typename T, std::size_t I>
+    From_Ruby<T> createFromRuby();
+      
+    // Create NativeArgs which are used to convert values from Ruby to C++
+    template<std::size_t...I>
+    From_Ruby_Args_Ts createFromRuby(std::index_sequence<I...>& indices);
+
+    To_Ruby<Return_T> createToRuby();
+      
+    // Convert Ruby argv pointer to Ruby values
+    std::vector<VALUE> getRubyValues(int argc, VALUE* argv);
+
+    // Convert Ruby values to C++ values
+    template<typename std::size_t...I>
+    Arg_Ts getNativeValues(std::vector<VALUE>& values, std::index_sequence<I...>& indices);
+
+    // Figure out what self is
+    Receiver_T getReceiver(VALUE self);
+
+    // Throw an exception when wrapper cannot be extracted
+    [[noreturn]] void noWrapper(const VALUE klass, const std::string& wrapper);
+
+    // Do we need to keep alive any arguments?
+    void checkKeepAlive(VALUE self, VALUE returnValue, std::vector<VALUE>& rubyValues);
+
+    // Call the underlying C++ function
+    VALUE invokeNativeFunction(const Arg_Ts& nativeArgs);
+    VALUE invokeNativeMethod(VALUE self, const Arg_Ts& nativeArgs);
+
+  private:
+    VALUE klass_;
+    std::string method_name_;
+    Function_T function_;
+    From_Ruby_Args_Ts fromRubys_;
+    To_Ruby<Return_T> toRuby_;
+    std::unique_ptr<MethodInfo> methodInfo_;
+  };
+}
+#include "NativeFunction.ipp"
+
+#endif // Rice__detail__Native_Function__hpp_