rice 4.3.3 → 4.6.0

data/rice/Data_Object_defn.hpp

@@ -1,84 +0,0 @@
-#ifndef Rice__Data_Object_defn__hpp_
-#define Rice__Data_Object_defn__hpp_
-
-#include <optional>
-
-#include "detail/to_ruby.hpp"
-#include "detail/ruby.hpp"
-#include "cpp_api/Object_defn.hpp"
-
-/*! \file
- *  \brief Provides a helper class for wrapping and unwrapping C++
- *  objects as Ruby objects.
- */
-
-namespace Rice
-{
-  //! A smartpointer-like wrapper for Ruby data objects.
-  /*! A data object is a ruby object of type T_DATA, which is usually
-   *  created by using the Data_Wrap_Struct or Data_Make_Struct macro.
-   *  This class wraps creation of the data structure, providing a
-   *  type-safe object-oriented interface to the underlying C interface.
-   *  This class works in conjunction with the Data_Type class to ensure
-   *  type safety.
-   *
-   *  Example:
-   *  \code
-   *    class Foo { };
-   *    ...
-   *    Data_Type<Foo> rb_cFoo = define_class("Foo");
-   *    ...
-   *    // Wrap:
-   *    Data_Object<Foo> foo1(new Foo);
-   *
-   *    // Get value to return:
-   *    VALUE v = foo1.value()
-   *
-   *    // Unwrap:
-   *    Data_Object<Foo> foo2(v, rb_cFoo);
-   *  \endcode
-   */
-  template<typename T>
-  class Data_Object : public Object
-  {
-    static_assert(!std::is_pointer_v<T>);
-    static_assert(!std::is_reference_v<T>);
-    static_assert(!std::is_const_v<T>);
-    static_assert(!std::is_volatile_v<T>);
-
-  public:
-    static T* from_ruby(VALUE value);
-
-  public:
-    //! Wrap a C++ object.
-    /*! This constructor is analogous to calling Data_Wrap_Struct.  Be
-     *  careful not to call this function more than once for the same
-     *  pointer (in general, it should only be called for newly
-     *  constructed objects that need to be managed by Ruby's garbage
-     *  collector).
-     *  \param obj the object to wrap.
-     *  \param isOwner Should the Data_Object take ownership of the object?
-     *  \param klass the Ruby class to use for the newly created Ruby
-     *  object.
-     */
-    Data_Object(T* obj, bool isOwner = false, Class klass = Data_Type<T>::klass());
-    Data_Object(T& obj, bool isOwner = false, Class klass = Data_Type<T>::klass());
-
-    //! Unwrap a Ruby object.
-    /*! This constructor is analogous to calling Data_Get_Struct.  Uses
-     *  Data_Type<T>::klass as the class of the object.
-     *  \param value the Ruby object to unwrap.
-     */
-    Data_Object(Object value);
-
-    T& operator*() const; //!< Return a reference to obj_
-    T* operator->() const; //!< Return a pointer to obj_
-    T* get() const;        //!< Return a pointer to obj_
-
-  private:
-    static void check_ruby_type(VALUE value);
-  };
-} // namespace Rice
-
-#endif // Rice__Data_Object_defn__hpp_
-

data/rice/Data_Type_defn.hpp

@@ -1,190 +0,0 @@
-#ifndef Rice__Data_Type_defn__hpp_
-#define Rice__Data_Type_defn__hpp_
-
-#include "cpp_api/Class_defn.hpp"
-#include "detail/ruby.hpp"
-#include <set>
-
-namespace Rice
-{
-  //! A mechanism for binding ruby types to C++ types.
-  /*! This class binds run-time types (Ruby VALUEs) to compile-time types
-   *  (C++ types).  The binding can occur only once.
-   */
-  template<typename T>
-  class Data_Type : public Class
-  {
-    static_assert(std::is_same_v<detail::intrinsic_type<T>, T>);
-
-  public:
-    //! Default constructor which does not bind.
-    /*! No member functions must be called on this Data_Type except bind,
-     *  until the type is bound.
-     */
-    Data_Type();
-
-    //! Constructor which takes a Module.
-    /*! Binds the type to the given VALUE according to the rules given
-     *  above.
-     *  \param klass the module to which to bind.
-     */
-    Data_Type(Module const & v);
-
-    //! Destructor.
-    virtual ~Data_Type();
- 
-    //! Return the Ruby class.
-    /*! \return the ruby class to which the type is bound.
-     */
-    static Class klass();
-
-    //! Return the Ruby data type.
-    static rb_data_type_t* ruby_data_type();
-
-    //! Assignment operator which takes a Module
-    /*! \param klass must be the class to which this data type is already
-     *  bound.
-     *  \return *this
-     */
-    virtual Data_Type & operator=(Module const & klass);
-
-    /*! Creates a singleton method allocate and an instance method called
-     *  initialize which together create a new instance of the class.  The
-     *  allocate method allocates memory for the object reference and the
-     *  initialize method constructs the object.
-     *  \param constructor an object that has a static member function
-     *  construct() that constructs a new instance of T and sets the object's data
-     *  member to point to the new instance.  A helper class Constructor
-     *  is provided that does precisely this.
-     *  \param args a list of Arg instance used to define default parameters (optional)
-     *
-     *  For example:
-     *  \code
-     *    define_class<Foo>("Foo")
-     *      .define_constructor(Constructor<Foo>());
-     *  \endcode
-     */
-    template<typename Constructor_T, typename...Arg_Ts>
-    Data_Type<T> & define_constructor(Constructor_T constructor, Arg_Ts const& ...args);
-
-    //! Register a Director class for this class.
-    /*! For any class that uses Rice::Director to enable polymorphism
-     *  across the languages, you need to register that director proxy
-     *  class with this method. Not doing so will cause the resulting 
-     *  library to die at run time when it tries to convert the base
-     *  type into the Director proxy type.
-     *
-     *  This method takes no methodInfo, just needs the type of the
-     *  Director proxy class.
-     *
-     *  For example:
-     *  \code
-     *    class FooDirector : public Foo, public Rice::Director {
-     *      ...
-     *    };
-     *
-     *    define_class<Foo>("Foo")
-     *      .define_director<FooDirector>()
-     *      .define_constructor(Constructor<FooDirector, Rice::Object>());
-     *  \endcode
-     */
-    template<typename Director_T>
-    Data_Type<T>& define_director();
-
-    //! Determine if the type is bound.
-    /*! \return true if the object is bound, false otherwise.
-     */
-    static bool is_bound();
-    static void check_is_bound();
-
-    // This is only for testing - DO NOT USE!!!
-    static void unbind();
-
-    static bool is_descendant(VALUE value);
-  
-    //! Define an iterator.
-    /*! Essentially this is a conversion from a C++-style begin/end
-     *  iterator to a Ruby-style \#each iterator.
-     *  \param begin a member function pointer to a function that returns
-     *  an iterator to the beginning of the sequence.
-     *  \param end a member function pointer to a function that returns an
-     *  iterator to the end of the sequence.
-     *  \param name the name of the iterator.
-     *  \return *this
-     */
-
-    template<typename Iterator_Func_T>
-    Data_Type<T>& define_iterator(Iterator_Func_T begin, Iterator_Func_T end, std::string name = "each");
-
-    template <typename Attribute_T>
-    Data_Type<T>& define_attr(std::string name, Attribute_T attribute, AttrAccess access = AttrAccess::ReadWrite);
-  
-    template <typename Attribute_T>
-    Data_Type<T>& define_singleton_attr(std::string name, Attribute_T attribute, AttrAccess access = AttrAccess::ReadWrite);
-
-  #include "cpp_api/shared_methods.hpp"
-
-  protected:
-    //! Bind a Data_Type to a VALUE.
-    /*! Throws an exception if the Data_Type is already bound to a
-     *  different class.  Any existing instances of the Data_Type will be
-     *  bound after this function returns.
-     *  \param klass the ruby type to which to bind.
-     *  \return *this
-     */
-    template <typename Base_T = void>
-    static Data_Type bind(const Module& klass);
-
-    template<typename T_, typename Base_T_>
-    friend Rice::Data_Type<T_> define_class_under(Object module, char const * name);
-
-    template<typename T_, typename Base_T_>
-    friend Rice::Data_Type<T_> define_class(char const * name);
-
-    template<bool IsMethod, typename Function_T>
-    void wrap_native_call(VALUE klass, std::string name, Function_T&& function, MethodInfo* methodInfo);
-
-  private:
-    template<typename T_>
-    friend class Data_Type;
-
-    static inline VALUE klass_ = Qnil;
-
-    // Typed Data support
-    static inline rb_data_type_t* rb_data_type_ = nullptr;
-
-    typedef std::set<Data_Type<T> *> Instances;
-
-    static Instances & unbound_instances()
-    {
-      static Instances unbound_instances;
-      return unbound_instances;
-    }
-  };
-
-  //! Define a new data class in the namespace given by module.
-  /*! By default the class will inherit from Ruby's rb_cObject. This
-   *  can be overriden via the Base_T template parameter. Note that
-   *  Base_T must already have been registered.
-   *  \param T the C++ type of the wrapped class.
-   *  \param module the the Module in which to define the class.
-   *  \return the new class.
-   */
-  template<typename T, typename Base_T = void>
-  Data_Type<T> define_class_under(Object module, char const* name);
-
-  //! Define a new data class in the default namespace.
-  /*! By default the class will inherit from Ruby's rb_cObject. This
-   *  can be overriden via the Base_T template parameter. Note that
-   *  Base_T must already have been registered.
-   *  \param T the C++ type of the wrapped class.
-   *  \param module the the Module in which to define the class.
-   *  \return the new class.
-   */
-  template<typename T, typename Base_T = void>
-  Data_Type<T> define_class(char const* name);
-} // namespace Rice
-
-#include "Data_Type.ipp"
-
-#endif // Rice__Data_Type_defn__hpp_

data/rice/Exception_defn.hpp

@@ -1,68 +0,0 @@
-#ifndef Rice__Exception_defn__hpp_
-#define Rice__Exception_defn__hpp_
-
-#include <stdexcept>
-#include "detail/ruby.hpp"
-
-namespace Rice
-{
-  //! A placeholder for Ruby exceptions.
-  /*! You can use this to safely throw a Ruby exception using C++ syntax:
-   *  \code
-   *    VALUE foo(VALUE self) {
-   *      RUBY_TRY {
-   *        throw Rice::Exception(rb_eMyException, "uh oh!");
-   *      RUBY_CATCH
-   *    }
-   *  \endcode
-   */
-  class Exception
-    : public std::exception
-  {
-  public:
-    //! Construct a Exception with a Ruby exception instance
-    explicit Exception(VALUE exception);
-
-    //! Construct a Exception with printf-style formatting.
-    /*! \param exc either an exception object or a class that inherits
-     *  from Exception.
-     *  \param fmt a printf-style format string
-     *  \param ... the arguments to the format string.
-     */
-    template <typename... Arg_Ts>
-    Exception(const Exception& other, char const* fmt, Arg_Ts&&...args);
-
-    //! Construct a Exception with printf-style formatting.
-    /*! \param exc either an exception object or a class that inherits
-     *  from Exception.
-     *  \param fmt a printf-style format string
-     *  \param ... the arguments to the format string.
-     */
-    template <typename... Arg_Ts>
-    Exception(const VALUE exceptionType, char const* fmt, Arg_Ts&&...args);
-
-    //! Destructor
-    virtual ~Exception() noexcept = default;
-
-    //! Get message as a char const *.
-    /*! If message is a non-string object, then this function will attempt
-     *  to throw an exception (which it can't do because of the no-throw
-     *  specification).
-     *  \return the underlying C pointer of the underlying message object.
-     */
-    virtual char const* what() const noexcept override;
-
-    //! Returns the Ruby exception class
-    VALUE class_of() const;
-
-    //! Returns an instance of a Ruby exception
-    VALUE value() const;
-
-  private:
-    // TODO: Do we need to tell the Ruby gc about an exception instance?
-    mutable VALUE exception_ = Qnil;
-    mutable std::string message_;
-  };
-} // namespace Rice
-
-#endif // Rice__Exception_defn__hpp_

data/rice/HandlerRegistration.hpp

@@ -1,15 +0,0 @@
-#ifndef Rice__HandlerRegistration__hpp_
-#define Rice__HandlerRegistration__hpp_
-
-#include "detail/HandlerRegistry.hpp"
-
-namespace Rice
-{
-  // Register exception handler
-  template<typename Exception_T, typename Functor_T>
-  detail::HandlerRegistry register_handler(Functor_T functor)
-  {
-    return detail::Registries::instance.handlers.add<Exception_T, Functor_T>(std::forward<Functor_T>(functor));
-  }
-}
-#endif // Rice__HandlerRegistration__hpp_

data/rice/detail/ExceptionHandler.hpp

@@ -1,8 +0,0 @@
-#ifndef Rice__detail__ExceptionHandler__hpp_
-#define Rice__detail__ExceptionHandler__hpp_
-
-#include "ExceptionHandler_defn.hpp"
-#include "ExceptionHandler.ipp"
-
-#endif // Rice__detail__ExceptionHandler__hpp_
-

data/rice/detail/ExceptionHandler.ipp

@@ -1,28 +0,0 @@
-namespace Rice::detail
-{
-  inline VALUE Rice::detail::DefaultExceptionHandler::handle() const
-  {
-    throw;
-  }
-
-  template <typename Exception_T, typename Functor_T>
-  inline Rice::detail::CustomExceptionHandler<Exception_T, Functor_T>::
-    CustomExceptionHandler(Functor_T handler, std::shared_ptr<ExceptionHandler> nextHandler)
-    : handler_(handler), nextHandler_(nextHandler)
-  {
-  }
-
-  template <typename Exception_T, typename Functor_T>
-  inline VALUE Rice::detail::CustomExceptionHandler<Exception_T, Functor_T>::handle() const
-  {
-    try
-    {
-      return this->nextHandler_->handle();
-    }
-    catch (Exception_T const& ex)
-    {
-      handler_(ex);
-      throw;
-    }
-  }
-}

data/rice/detail/ExceptionHandler_defn.hpp

@@ -1,77 +0,0 @@
-#ifndef Rice__detail__ExceptionHandler_defn__hpp_
-#define Rice__detail__ExceptionHandler_defn__hpp_
-
-#include <memory>
-#include "ruby.hpp"
-
-namespace Rice::detail
-{
-  /* An abstract class for converting C++ exceptions to ruby exceptions.  It's used
-     like this:
-
-     try
-     {
-     }
-     catch(...)
-     {
-       handler->handle();
-     }
-
-   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_ExceptionHandler();
-   }
-   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 ExceptionHandler
-  {
-  public:
-    ExceptionHandler() = default;
-    virtual ~ExceptionHandler() = default;
-
-    // Don't allow copying or assignment
-    ExceptionHandler(const ExceptionHandler& other) = delete;
-    ExceptionHandler& operator=(const ExceptionHandler& other) = delete;
-
-    virtual VALUE handle() 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 DefaultExceptionHandler : public ExceptionHandler
-  {
-  public:
-    virtual VALUE handle() 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 CustomExceptionHandler : public ExceptionHandler
-  {
-  public:
-    CustomExceptionHandler(Functor_T handler, std::shared_ptr<ExceptionHandler> nextHandler);
-    virtual VALUE handle() const override;
-
-  private:
-    Functor_T handler_;
-    std::shared_ptr<ExceptionHandler> nextHandler_;
-  };
-}
-#endif // Rice__detail__ExceptionHandler_defn__hpp_

data/rice/detail/Jump_Tag.hpp

@@ -1,21 +0,0 @@
-#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/NativeAttribute.hpp

@@ -1,64 +0,0 @@
-#ifndef Rice__detail__Native_Attribute__hpp_
-#define Rice__detail__Native_Attribute__hpp_
-
-#include "ruby.hpp"
-#include "../traits/attribute_traits.hpp"
-
-namespace Rice
-{
-  enum class AttrAccess
-  {
-    ReadWrite,
-    Read,
-    Write
-  };
-
-  namespace detail
-  {
-    template<typename Attribute_T>
-    class NativeAttribute
-    {
-    public:
-      using NativeAttribute_T = NativeAttribute<Attribute_T>;
-
-      using T = typename attribute_traits<Attribute_T>::attr_type;
-      using T_Unqualified = remove_cv_recursive_t<T>;
-      using Receiver_T = typename attribute_traits<Attribute_T>::class_type;
-    
-    public:
-      // Register attribute getter/setter with Ruby
-      static void define(VALUE klass, std::string name, Attribute_T attribute, AttrAccess access = AttrAccess::ReadWrite);
-
-      // Static member functions that Ruby calls to read an attribute value
-      static VALUE get(VALUE self);
-
-      // Static member functions that Ruby calls to write an attribute value
-      static VALUE set(VALUE self, VALUE value);
-
-    public:
-      // Disallow creating/copying/moving
-      NativeAttribute() = delete;
-      NativeAttribute(const NativeAttribute_T&) = delete;
-      NativeAttribute(NativeAttribute_T&&) = delete;
-      void operator=(const NativeAttribute_T&) = delete;
-      void operator=(NativeAttribute_T&&) = delete;
-
-    protected:
-      NativeAttribute(VALUE klass, std::string name, Attribute_T attr, AttrAccess access = AttrAccess::ReadWrite);
-
-      // Invokes the wrapped function
-      VALUE read(VALUE self);
-      VALUE write(VALUE self, VALUE value);
-
-    private:
-      VALUE klass_;
-      std::string name_;
-      Attribute_T attribute_;
-      AttrAccess access_;
-    };
-  } // detail
-} // Rice
-
-#include "NativeAttribute.ipp"
-
-#endif // Rice__detail__Native_Attribute__hpp_

data/rice/detail/NativeAttribute.ipp

@@ -1,112 +0,0 @@
-#include <array>
-#include <algorithm>
-
-#include "../traits/rice_traits.hpp"
-#include "NativeRegistry.hpp"
-#include "to_ruby_defn.hpp"
-#include "cpp_protect.hpp"
-
-namespace Rice::detail
-{
-  template<typename Attribute_T>
-  void NativeAttribute<Attribute_T>::define(VALUE klass, std::string name, Attribute_T attribute, AttrAccess access)
-  {
-    // Create a NativeAttribute that Ruby will call to read/write C++ variables
-    NativeAttribute_T* native = new NativeAttribute_T(klass, name, std::forward<Attribute_T>(attribute), access);
-
-    if (access == AttrAccess::ReadWrite || access == AttrAccess::Read)
-    {
-      // Tell Ruby to invoke the static method read to get the attribute value
-      detail::protect(rb_define_method, klass, name.c_str(), (RUBY_METHOD_FUNC)&NativeAttribute_T::get, 0);
-
-      // Add to native registry
-      detail::Registries::instance.natives.add(klass, Identifier(name).id(), native);
-    }
-
-    if (access == AttrAccess::ReadWrite || access == AttrAccess::Write)
-    {
-      if (std::is_const_v<std::remove_pointer_t<T>>)
-      {
-        throw std::runtime_error(name + " is readonly");
-      }
-
-      // Define the write method name
-      std::string setter = name + "=";
-
-      // Tell Ruby to invoke the static method write to get the attribute value
-      detail::protect(rb_define_method, klass, setter.c_str(), (RUBY_METHOD_FUNC)&NativeAttribute_T::set, 1);
-
-      // Add to native registry
-      detail::Registries::instance.natives.add(klass, Identifier(setter).id(), native);
-    }
-  }
-
-  template<typename Attribute_T>
-  inline VALUE NativeAttribute<Attribute_T>::get(VALUE self)
-  {
-    return cpp_protect([&]
-    {
-      using Native_Attr_T = NativeAttribute<Attribute_T>;
-      Native_Attr_T* attr = detail::Registries::instance.natives.lookup<Native_Attr_T*>();
-      return attr->read(self);
-    });
-  }
-
-  template<typename Attribute_T>
-  inline VALUE NativeAttribute<Attribute_T>::set(VALUE self, VALUE value)
-  {
-    return cpp_protect([&]
-    {
-      using Native_Attr_T = NativeAttribute<Attribute_T>;
-      Native_Attr_T* attr = detail::Registries::instance.natives.lookup<Native_Attr_T*>();
-      return attr->write(self, value);
-    });
-  }
-
-  template<typename Attribute_T>
-  NativeAttribute<Attribute_T>::NativeAttribute(VALUE klass, std::string name,
-                                                             Attribute_T attribute, AttrAccess access)
-    : klass_(klass), name_(name), attribute_(attribute), access_(access)
-  {
-  }
-
-  template<typename Attribute_T>
-  inline VALUE NativeAttribute<Attribute_T>::read(VALUE self)
-  {
-    using T_Unqualified = remove_cv_recursive_t<T>;
-    if constexpr (std::is_member_object_pointer_v<Attribute_T>)
-    {
-      Receiver_T* nativeSelf = From_Ruby<Receiver_T*>().convert(self);
-      return To_Ruby<T_Unqualified>().convert(nativeSelf->*attribute_);
-    }
-    else
-    {
-      return To_Ruby<T_Unqualified>().convert(*attribute_);
-    }
-  }
-
-  template<typename Attribute_T>
-  inline VALUE NativeAttribute<Attribute_T>::write(VALUE self, VALUE value)
-  {
-    if constexpr (std::is_fundamental_v<intrinsic_type<T>> && std::is_pointer_v<T>)
-    {
-      static_assert(true, "An fundamental value, such as an integer, cannot be assigned to an attribute that is a pointer");
-    }
-    else if constexpr (std::is_same_v<intrinsic_type<T>, std::string> && std::is_pointer_v<T>)
-    {
-      static_assert(true, "An string cannot be assigned to an attribute that is a pointer");
-    }
-    
-    if constexpr (!std::is_null_pointer_v<Receiver_T>)
-    {
-      Receiver_T* nativeSelf = From_Ruby<Receiver_T*>().convert(self);
-      nativeSelf->*attribute_ = From_Ruby<T_Unqualified>().convert(value);
-    }
-    else if constexpr (!std::is_const_v<std::remove_pointer_t<T>>)
-    {
-      *attribute_ = From_Ruby<T_Unqualified>().convert(value);
-    }
-
-    return value;
-  }
-} // Rice