rice 3.0.0 → 4.0.3

data/rice/Return.hpp

@@ -0,0 +1,39 @@
+#ifndef Rice__Return__hpp_
+#define Rice__Return__hpp_
+
+#include <any>
+
+namespace Rice
+{
+  //! Helper for defining Return argument of a method
+
+  class Return
+  {
+  public:
+    //! Specifies Ruby should take ownership of the returned value
+    Return& takeOwnership();
+
+    //! Does Ruby own the returned value?
+    bool isOwner();
+
+    //! Specifies the returned value is a Ruby value
+    Return& isValue();
+
+    //! Is the returned value a Ruby value?
+    bool getIsValue();
+
+    //! Tell the returned object to keep alive the receving object
+    Return& keepAlive();
+
+  public:
+    bool isKeepAlive = false;
+
+  private:
+    bool isOwner_ = false;
+    bool isValue_ = false;
+  };
+} // Rice
+
+#include "Return.ipp"
+
+#endif // Rice__Return__hpp_

data/rice/Return.ipp

@@ -0,0 +1,33 @@
+#include <any>
+#include <string>
+
+namespace Rice
+{
+  inline Return& Return::takeOwnership()
+  {
+    this->isOwner_ = true;
+    return *this;
+  }
+
+  inline bool Return::isOwner()
+  {
+    return this->isOwner_;
+  }
+
+  inline Return& Return::isValue()
+  {
+    this->isValue_ = true;
+    return *this;
+  }
+
+  inline bool Return::getIsValue()
+  {
+    return this->isValue_;
+  }
+
+  inline Return& Return::keepAlive()
+  {
+    this->isKeepAlive = true;
+    return *this;
+  }
+}  // Rice

data/rice/detail/Exception_Handler.ipp

@@ -1,68 +1,28 @@
-#include "../Data_Type_defn.hpp"
-
-inline
-Rice::detail::Exception_Handler::
-Exception_Handler(
-    Data_Object<Exception_Handler> next_exception_handler)
-  : next_exception_handler_(next_exception_handler)
-  , next_exception_handler_guard_(&next_exception_handler_)
-{
-}
-
-inline
-Rice::detail::Exception_Handler::
-~Exception_Handler()
-{
-}
-
-inline
-VALUE
-Rice::detail::Exception_Handler::
-call_next_exception_handler() const
-{
-  return next_exception_handler_->handle_exception();
-}
-
-inline Rice::detail::Default_Exception_Handler::
-Default_Exception_Handler()
-  : Exception_Handler(
-      Data_Object<Exception_Handler>(0, rb_cObject))
-{
-}
-
-inline
-VALUE
-Rice::detail::Default_Exception_Handler::
-handle_exception() const
+namespace Rice::detail
 {
-  throw;
-}
-
-template <typename Exception_T, typename Functor_T>
-inline
-Rice::detail::Functor_Exception_Handler<Exception_T, Functor_T>::
-Functor_Exception_Handler(
-    Functor_T handler,
-    Data_Object<Exception_Handler> next_exception_handler)
-  : Exception_Handler(next_exception_handler)
-  , handler_(handler)
-{
-}
-
-template <typename Exception_T, typename Functor_T>
-inline
-VALUE
-Rice::detail::Functor_Exception_Handler<Exception_T, Functor_T>::
-handle_exception() const
-{
-  try
+  inline VALUE Rice::detail::Default_Exception_Handler::handle_exception() const
   {
-    return call_next_exception_handler();
+    throw;
   }
-  catch(Exception_T const & ex)
+
+  template <typename Exception_T, typename Functor_T>
+  inline Rice::detail::Functor_Exception_Handler<Exception_T, Functor_T>::
+    Functor_Exception_Handler(Functor_T handler, std::shared_ptr<Exception_Handler> next_exception_handler)
+    : handler_(handler), next_exception_handler_(next_exception_handler)
   {
-    handler_(ex);
-    throw;
   }
-}
 
+  template <typename Exception_T, typename Functor_T>
+  inline VALUE Rice::detail::Functor_Exception_Handler<Exception_T, Functor_T>::handle_exception() const
+  {
+    try
+    {
+      return this->next_exception_handler_->handle_exception();
+    }
+    catch (Exception_T const& ex)
+    {
+      handler_(ex);
+      throw;
+    }
+  }
+}

data/rice/detail/Exception_Handler_defn.hpp

@@ -1,96 +1,81 @@
 #ifndef Rice__detail__Exception_Handler_defn__hpp_
 #define Rice__detail__Exception_Handler_defn__hpp_
 
-#include "ruby.h"
-#undef TYPE
+#include <memory>
+#include "ruby.hpp"
 
-#include "Not_Copyable.hpp"
-#include "../Address_Registration_Guard_defn.hpp"
-#include "../Data_Object_defn.hpp"
-
-namespace Rice
-{
-
-namespace detail
-{
-
-// A class for converting C++ exceptions to ruby exceptions.  It's used
-// like this:
-//
-//   try
-//   {
-//   }
-//   catch(...)
-//   {
-//     handler->handle_exception();
-//   }
-//
-// If an exception is thrown the handler will pass the exception up the
-// chain, then the last handler in the chain will throw the exception
-// down the chain until a lower handler can handle it, e.g.:
-//
-//   try
-//   {
-//     return call_next_exception_handler();
-//   }
-//   catch(MyException const & ex)
-//   {
-//     throw Rice::Exception(rb_cMyException, "%s", ex.what());
-//   }
-//
-class Exception_Handler
-  : public Rice::detail::Not_Copyable
-{
-public:
-  Exception_Handler(
-      Data_Object<Exception_Handler> next_exception_handler);
-
-  virtual ~Exception_Handler();
-
-  virtual VALUE handle_exception() const = 0;
-
-  VALUE call_next_exception_handler() const;
-
-private:
-  Data_Object<Exception_Handler> next_exception_handler_;
-  Address_Registration_Guard next_exception_handler_guard_;
-};
-
-// The default exception handler just rethrows the exception.  If there
-// are other handlers in the chain, they will try to handle the rethrown
-// exception.
-class Default_Exception_Handler
-  : public Exception_Handler
+namespace Rice::detail
 {
-public:
-  Default_Exception_Handler();
-
-  virtual VALUE handle_exception() const;
-};
-
-// An exception handler that takes a functor as an argument.  The
-// functor should throw a Rice::Exception to handle the exception.  If
-// the functor does not handle the exception, the exception will be
-// re-thrown.
-template <typename Exception_T, typename Functor_T>
-class Functor_Exception_Handler
-  : public Exception_Handler
-{
-public:
-  Functor_Exception_Handler(
-      Functor_T handler,
-      Data_Object<Exception_Handler> next_exception_handler);
-
-private:
-  virtual VALUE handle_exception() const;
-
-private:
-  Functor_T handler_;
-};
-
-} // namespace detail
-
-} // namespace Rice
-
-#endif // Rice__detail__Exception_Handler_defn__hpp_
-
+  /* An abstract class for converting C++ exceptions to ruby exceptions.  It's used
+     like this:
+
+     try
+     {
+     }
+     catch(...)
+     {
+       handler->handle_exception();
+     }
+
+   If an exception is thrown the handler will pass the exception up the
+   chain, then the last handler in the chain will throw the exception
+   down the chain until a lower handler can handle it, e.g.:
+
+   try
+   {
+     return call_next_exception_handler();
+   }
+   catch(MyException const & ex)
+   {
+     throw Rice::Exception(rb_cMyException, "%s", ex.what());
+    }
+
+    Memory management. Handlers are created by the ModuleBase constructor. When the
+    module defines a new Ruby method, metadata  is stored on the Ruby klass including
+    the exception handler. Since the metadata outlives the module, handlers are stored
+    using std::shared_ptr. Thus the Module (or its inherited children) can be destroyed
+    without corrupting the metadata references to the shared exception handler. */
+
+  class Exception_Handler
+  {
+  public:
+    Exception_Handler() = default;
+    virtual ~Exception_Handler() = default;
+
+    // Don't allow copying or assignment
+    Exception_Handler(const Exception_Handler& other) = delete;
+    Exception_Handler& operator=(const Exception_Handler& other) = delete;
+
+    virtual VALUE handle_exception() const = 0;
+  };
+
+  // The default exception handler just rethrows the exception.  If there
+  // are other handlers in the chain, they will try to handle the rethrown
+  // exception.
+  class Default_Exception_Handler
+    : public Exception_Handler
+  {
+  public:
+    virtual VALUE handle_exception() const override;
+  };
+
+  // An exception handler that takes a functor as an argument.  The
+  // functor should throw a Rice::Exception to handle the exception.  If
+  // the functor does not handle the exception, the exception will be
+  // re-thrown.
+  template <typename Exception_T, typename Functor_T>
+  class Functor_Exception_Handler
+    : public Exception_Handler
+  {
+  public:
+    Functor_Exception_Handler(Functor_T handler,
+      std::shared_ptr<Exception_Handler> next_exception_handler);
+
+    virtual VALUE handle_exception() const override;
+
+  private:
+    Functor_T handler_;
+    std::shared_ptr<Exception_Handler> next_exception_handler_;
+  };
+}
+#endif // Rice__detail__Exception_Handler_defn__hpp_

data/rice/detail/Iterator.hpp

@@ -1,93 +1,23 @@
-#ifndef Rice__detail__Iterator__hpp_
-#define Rice__detail__Iterator__hpp_
+#ifndef Rice_Iterator__hpp_
+#define Rice_Iterator__hpp_
 
-#include "method_data.hpp"
-#include "ruby.hpp"
-#include "../protect.hpp"
-#include "../Data_Object.hpp"
-#include "../Identifier.hpp"
-
-namespace Rice
-{
-
-namespace detail
-{
-
-class Iterator
-{
-public:
-  virtual ~Iterator() { }
-
-  virtual VALUE call_impl(VALUE self) = 0;
-
-  static VALUE call(VALUE self)
-  {
-    VALUE data = (VALUE)method_data();
-    Data_Object<Iterator> iterator(
-        data,
-        Data_Type<Iterator>());
-    return iterator->call_impl(self);
-  }
-};
-
-template<typename T, typename Iterator_T>
-class Iterator_Impl
-  : public Iterator
+namespace Rice::detail
 {
-public:
-  Iterator_Impl(
-      Iterator_T (T::*begin)(),
-      Iterator_T (T::*end)(),
-      Data_Type<T> data_type)
-    : begin_(begin)
-    , end_(end)
-    , data_type_(data_type)
-  {
-  }
-
-  virtual VALUE call_impl(VALUE self)
+  template<typename T, typename Iterator_T>
+  class Iterator
   {
-    Data_Object<T> obj(self, data_type_);
-    Iterator_T it = (*obj.*begin_)();
-    Iterator_T end = (*obj.*end_)();
-    for(; it != end; ++it)
-    {
-      Rice::protect(rb_yield, to_ruby(*it));
-    }
-    return self;
-  }
-
-private:
-  Iterator_T (T::*begin_)();
-  Iterator_T (T::*end_)();
-  Data_Type<T> data_type_;
-};
-
-template<typename T, typename Iterator_T>
-void define_iterator(
-    Module klass,
-    Identifier name,
-    Iterator_T (T::*begin)(),
-    Iterator_T (T::*end)())
-{
-  Data_Type<Iterator> iterator_klass;
-  Data_Object<Iterator> iterator(
-      new Iterator_Impl<T, Iterator_T>(
-          begin,
-          end,
-          Data_Type<T>(klass)),
-      iterator_klass);
-  define_method_with_data(
-      klass,
-      name,
-      (RUBY_METHOD_FUNC)iterator->call,
-      0,
-      iterator);
+  public:
+    static VALUE call(VALUE self);
+
+  public:
+    Iterator(Iterator_T(T::* begin)(), Iterator_T(T::* end)());
+    virtual ~Iterator() = default;
+    VALUE operator()(VALUE self);
+
+  private:
+    Iterator_T(T::* begin_)();
+    Iterator_T(T::* end_)();
+  };
 }
 
-} // namespace detail
-
-} // namespace Rice
-
-#endif // Rice__detail__Iterator__hpp_
-
+#endif // Rice_Iterator__hpp_

data/rice/detail/Iterator.ipp

@@ -0,0 +1,47 @@
+#ifndef Rice_Iterator__ipp_
+#define Rice_Iterator__ipp_
+
+#include <iterator>
+#include <functional>
+
+#include "../Data_Object_defn.hpp"
+#include "method_data.hpp"
+
+namespace Rice::detail
+{
+  template <typename T, typename Iterator_T>
+  inline Iterator<T, Iterator_T>::
+    Iterator(Iterator_T(T::* begin)(), Iterator_T(T::* end)()) :
+    begin_(begin), end_(end)
+  {
+  }
+
+  template<typename T, typename Iterator_T>
+  inline VALUE Iterator<T, Iterator_T>::
+  call(VALUE self)
+  {
+    using Iter_T = Iterator<T, Iterator_T>;
+    Iter_T* iterator = detail::MethodData::data<Iter_T*>();
+    return iterator->operator()(self);
+  }
+
+  template<typename T, typename Iterator_T>
+  inline VALUE Iterator<T, Iterator_T>::
+  operator()(VALUE self)
+  {
+    using Value_T = typename std::iterator_traits<Iterator_T>::value_type;
+
+    Data_Object<T> obj(self);
+    Iterator_T it = std::invoke(this->begin_, *obj);
+    Iterator_T end = std::invoke(this->end_, *obj);
+
+    for (; it != end; ++it)
+    {
+      protect(rb_yield, detail::To_Ruby<Value_T>().convert(*it));
+    }
+
+    return self;
+  }
+}
+
+#endif // Rice_Iterator__ipp_

data/rice/detail/Jump_Tag.hpp

@@ -0,0 +1,21 @@
+#ifndef Rice__detail__Jump_Tag__hpp_
+#define Rice__detail__Jump_Tag__hpp_
+
+namespace Rice
+{
+  //! A placeholder for Ruby longjmp data.
+  /*! When a Ruby exception is caught, the tag used for the longjmp is stored in
+   *  a Jump_Tag, then later passed to rb_jump_tag() when there is no more
+   *  C++ code to pass over.
+   */
+  struct Jump_Tag
+  {
+    //! Construct a Jump_Tag with tag t.
+    Jump_Tag(int t) : tag(t) {}
+
+    //! The tag being held.
+    int tag;
+  };
+} // namespace Rice
+
+#endif // Rice__detail__Jump_Tag__hpp_

data/rice/detail/MethodInfo.hpp

@@ -0,0 +1,44 @@
+#ifndef Rice__MethodInfo__hpp_
+#define Rice__MethodInfo__hpp_
+
+#include <vector>
+#include "../Arg.hpp"
+#include "../Return.hpp"
+
+namespace Rice
+{
+  class MethodInfo
+  {
+  public:
+    template <typename...Arg_Ts>
+    MethodInfo(size_t argCount, const Arg_Ts&...args);
+
+    /**
+      * Get the rb_scan_args format string for this
+      * list of arguments.
+      */
+    std::string formatString();
+
+    /**
+      * Add a defined Arg to this list of Arguments
+      */
+    void addArg(const Arg& arg);
+
+    Arg& arg(size_t pos);
+
+    // Iterator support
+    std::vector<Arg>::iterator begin();
+    std::vector<Arg>::iterator end();
+
+    Return returnInfo;
+
+  private:
+    template <typename Arg_T>
+    void processArg(const Arg_T& arg);
+
+    std::vector<Arg> args_;
+  };
+}
+#include "MethodInfo.ipp"
+
+#endif // Rice__MethodInfo__hpp_

data/rice/detail/MethodInfo.ipp

@@ -0,0 +1,78 @@
+#include <sstream>
+#include "from_ruby_defn.hpp"
+
+namespace Rice
+{
+  template <typename...Arg_Ts>
+  inline MethodInfo::MethodInfo(size_t argCount, const Arg_Ts&...args)
+  {
+    // Process the passed in arguments
+    (this->processArg(args), ...);
+
+    // Fill in any missing arguments
+    for (size_t i = this->args_.size(); i < argCount; i++)
+    {
+      Arg arg("arg_" + std::to_string(i));
+      this->args_.emplace_back(arg);
+    }
+
+    // TODO - so hacky but update the Arg positions
+    for (uint32_t i = 0; i < this->args_.size(); i++)
+    {
+      this->args_[i].position = i;
+    }
+  }
+
+  template <typename Arg_T>
+  inline void MethodInfo::processArg(const Arg_T& arg)
+  {
+    if constexpr (std::is_same_v<Arg_T, Arg>)
+    {
+      this->addArg(arg);
+    }
+    else
+    {
+      this->returnInfo = arg;
+    }
+  }
+
+  inline void MethodInfo::addArg(const Arg& arg)
+  {
+    this->args_.push_back(arg);
+  }
+
+  inline std::string MethodInfo::formatString()
+  {
+    size_t required = 0;
+    size_t optional = 0;
+
+    for (const Arg& arg : this->args_)
+    {
+      if (arg.hasDefaultValue())
+      {
+        optional++;
+      }
+      else
+      {
+        required++;
+      }
+    }
+
+    return std::to_string(required) + std::to_string(optional);
+  }
+
+  inline Arg& MethodInfo::arg(size_t pos)
+  {
+    return args_[pos];
+  }
+
+  inline std::vector<Arg>::iterator MethodInfo::begin()
+  {
+    return this->args_.begin();
+  }
+
+  inline std::vector<Arg>::iterator MethodInfo::end()
+  {
+    return this->args_.end();
+  }
+}

data/rice/detail/NativeAttribute.hpp

@@ -0,0 +1,53 @@
+#ifndef Rice__detail__Native_Attribute__hpp_
+#define Rice__detail__Native_Attribute__hpp_
+
+#include "ruby.hpp"
+#include "Exception_Handler_defn.hpp"
+#include "MethodInfo.hpp"
+
+namespace Rice
+{
+  enum class AttrAccess
+  {
+    ReadWrite,
+    Read,
+    Write
+  };
+
+  namespace detail
+  {
+    template<typename Return_T, typename Attr_T, typename Self_T = void>
+    class NativeAttribute
+    {
+    public:
+      using Native_Return_T = Return_T;
+
+      // Static member functions that Ruby calls
+      static VALUE get(VALUE self);
+      static VALUE set(VALUE self, VALUE value);
+
+    public:
+      NativeAttribute(Attr_T attr, AttrAccess access = AttrAccess::ReadWrite);
+
+      // Invokes the wrapped function
+      VALUE read(VALUE self);
+      VALUE write(VALUE self, VALUE value);
+
+    private:
+      Attr_T attr_;
+      AttrAccess access_;
+    };
+
+    // A plain function or static member call
+    template<typename T>
+    auto* Make_Native_Attribute(T* attr, AttrAccess access);
+
+    // Lambda function that does not take Self as first parameter
+    template<typename Class_T, typename T>
+    auto* Make_Native_Attribute(T Class_T::* attr, AttrAccess access);
+  } // detail
+} // Rice
+
+#include "NativeAttribute.ipp"
+
+#endif // Rice__detail__Native_Attribute__hpp_