rice 4.3.2 → 4.5.0

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/Identifier.hpp

@@ -1,50 +0,0 @@
-#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 +0,0 @@
-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/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

data/rice/detail/from_ruby_defn.hpp

@@ -1,38 +0,0 @@
-#ifndef Rice__detail__from_ruby_defn__hpp_
-#define Rice__detail__from_ruby_defn__hpp_
-
-#include <type_traits>
-
-#include "ruby.hpp"
-
-namespace Rice::detail
-{
-  //! Convert a Ruby object to C++.
-  /*! If the Ruby object can be converted to an immediate value, returns a
-   *  copy of the Ruby object.  If the Ruby object is holding a C++
-   *  object and the type specified is a pointer to that type, returns a
-   *  pointer to that object.
-   *
-   *  Conversions from ruby to a pointer type are automatically generated
-   *  when a type is bound using Data_Type.  If no conversion exists an
-   *  exception is thrown.
-   *
-   *  \param T the C++ type to which to convert.
-   *  \param x the Ruby object to convert.
-   *  \return a C++ representation of the Ruby object.
-   *
-   *  Example:
-   *  \code
-   *    Object x = INT2NUM(42);
-   *    std::cout << From_Ruby<int>::convert(x);
-   *
-   *    Data_Object<Foo> foo(new Foo);
-   *    std::cout << *From_Ruby<Foo *>(foo) << std::endl;
-   *  \endcode
-   */
-
-  template <typename T>
-  class From_Ruby;
-}
-
-#endif // Rice__detail__From_Ruby2_defn__hpp_

data/rice/detail/to_ruby_defn.hpp

@@ -1,48 +0,0 @@
-#ifndef Rice__detail__to_ruby_defn__hpp_
-#define Rice__detail__to_ruby_defn__hpp_
-
-#include "../traits/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/test/test_Jump_Tag.cpp

@@ -1,17 +0,0 @@
-#include "unittest.hpp"
-#include <rice/rice.hpp>
-
-using namespace Rice;
-
-TESTSUITE(Jump_Tag);
-
-SETUP(Jump_Tag)
-{
-}
-
-TESTCASE(construct)
-{
-  Jump_Tag jump_tag(42);
-  ASSERT_EQUAL(42, jump_tag.tag);
-}
-