rice 4.0.4 → 4.1.0

data/rice/Director.hpp

@@ -40,5 +40,4 @@ namespace Rice
 
   };
 }
-
 #endif // Rice__Director__hpp_

data/rice/Enum.ipp

@@ -54,21 +54,6 @@ namespace Rice
           // been included by the user
           return String(result.str());
         })
-      .define_method("<=>", [](Enum_T& self, Enum_T& other)
-        {
-          if (self == other)
-          {
-            return 0;
-          }
-          else if (self < other)
-          {
-            return -1;
-          }
-          else
-          {
-            return 1;
-          }
-        })
       .define_method("hash", [](Enum_T& self) ->  Underlying_T
         {
           return (Underlying_T)self;
@@ -82,19 +67,43 @@ namespace Rice
     rb_define_alias(klass, "===", "eql?");
 
     // Add comparable support
-    klass.include_module(rb_mComparable);
+    klass.include_module(rb_mComparable)
+      .define_method("<=>", [](Enum_T& self, Enum_T& other)
+    {
+      if (self == other)
+      {
+        return 0;
+      }
+      else if (self < other)
+      {
+        return -1;
+      }
+      else
+      {
+        return 1;
+      }
+    });
 
-    // Singleton methods
-    klass.define_singleton_method("each", [](VALUE klass)
+    // Add enumerable support
+    klass.include_module(rb_mEnumerable)
+      .define_singleton_method("each", [](VALUE ruby_klass) -> VALUE
         {
+          if (!rb_block_given_p())
+          {
+            return rb_enumeratorize_with_size(ruby_klass, Identifier("each").to_sym(),
+                                      0, nullptr, 0);
+          }
+
           for (auto& pair : valuesToNames_)
           {
             Enum_T enumValue = pair.first;
             VALUE value = detail::To_Ruby<Enum_T>().convert(enumValue);
             detail::protect(rb_yield, value);
           }
-      })
-      .define_singleton_method("from_int", [](VALUE klass, int32_t value)
+
+          return ruby_klass;
+      }, Return().setValue())
+      .define_singleton_method("from_int", [](VALUE ruby_klass, int32_t value) -> Object
       {
           auto iter = Enum<Enum_T>::valuesToNames_.find((Enum_T)value);
           if (iter == Enum<Enum_T>::valuesToNames_.end())
@@ -103,14 +112,14 @@ namespace Rice
           }
 
           std::string name = iter->second;
-          return Class(klass).const_get(name);
+          return Object(ruby_klass).const_get(name);
       });
   }
 
   template<typename Enum_T>
   Enum<Enum_T> define_enum(char const* name, Module module)
   {
-    if (detail::TypeRegistry::isDefined<Enum_T>())
+    if (detail::Registries::instance.types.isDefined<Enum_T>())
     {
       return Enum<Enum_T>();
     }

data/rice/Exception.ipp

@@ -43,10 +43,9 @@ namespace Rice
   {
     if (this->message_.empty())
     {
-      // Cache the message - this allows the returned pointer to be valid for the
-      // lifetime of this exception instance.
+      // This isn't protected because if it fails then either we could eat the exception
+      // (not good) or crash the program (better)
       VALUE rubyMessage = rb_funcall(this->exception_, rb_intern("message"), 0);
-      //this->message_ = detail::From_Ruby<std::string>::convert(rubyMessage);
       this->message_ = std::string(RSTRING_PTR(rubyMessage), RSTRING_LEN(rubyMessage));
     }
     return this->message_.c_str();

data/rice/Exception_defn.hpp

@@ -33,11 +33,11 @@ namespace Rice
     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.
-   */
+    /*! \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);
 

data/rice/HandlerRegistration.hpp

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

@@ -17,18 +17,19 @@ namespace Rice
     bool isOwner();
 
     //! Specifies the returned value is a Ruby value
-    Return& isValue();
+    Return& setValue();
 
     //! Is the returned value a Ruby value?
-    bool getIsValue();
+    bool isValue() const;
 
     //! Tell the returned object to keep alive the receving object
     Return& keepAlive();
 
-  public:
-    bool isKeepAlive = false;
+    //! Is the returned value being kept alive?
+    bool isKeepAlive() const;
 
   private:
+    bool isKeepAlive_ = false;
     bool isOwner_ = false;
     bool isValue_ = false;
   };

data/rice/Return.ipp

@@ -14,20 +14,25 @@ namespace Rice
     return this->isOwner_;
   }
 
-  inline Return& Return::isValue()
+  inline Return& Return::setValue()
   {
     this->isValue_ = true;
     return *this;
   }
 
-  inline bool Return::getIsValue()
+  inline bool Return::isValue() const
   {
     return this->isValue_;
   }
 
   inline Return& Return::keepAlive()
   {
-    this->isKeepAlive = true;
+    this->isKeepAlive_ = true;
     return *this;
   }
+
+  inline bool Return::isKeepAlive() const
+  {
+    return this->isKeepAlive_;
+  }
 }  // Rice

data/rice/detail/ExceptionHandler.hpp

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

@@ -0,0 +1,28 @@
+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/{Exception_Handler_defn.hpp → ExceptionHandler_defn.hpp}

@@ -1,5 +1,5 @@
-#ifndef Rice__detail__Exception_Handler_defn__hpp_
-#define Rice__detail__Exception_Handler_defn__hpp_
+#ifndef Rice__detail__ExceptionHandler_defn__hpp_
+#define Rice__detail__ExceptionHandler_defn__hpp_
 
 #include <memory>
 #include "ruby.hpp"
@@ -14,7 +14,7 @@ namespace Rice::detail
      }
      catch(...)
      {
-       handler->handle_exception();
+       handler->handle();
      }
 
    If an exception is thrown the handler will pass the exception up the
@@ -23,7 +23,7 @@ namespace Rice::detail
 
    try
    {
-     return call_next_exception_handler();
+     return call_next_ExceptionHandler();
    }
    catch(MyException const & ex)
    {
@@ -36,27 +36,26 @@ namespace Rice::detail
     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
+  class ExceptionHandler
   {
   public:
-    Exception_Handler() = default;
-    virtual ~Exception_Handler() = default;
+    ExceptionHandler() = default;
+    virtual ~ExceptionHandler() = default;
 
     // Don't allow copying or assignment
-    Exception_Handler(const Exception_Handler& other) = delete;
-    Exception_Handler& operator=(const Exception_Handler& other) = delete;
+    ExceptionHandler(const ExceptionHandler& other) = delete;
+    ExceptionHandler& operator=(const ExceptionHandler& other) = delete;
 
-    virtual VALUE handle_exception() const = 0;
+    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 Default_Exception_Handler
-    : public Exception_Handler
+  class DefaultExceptionHandler : public ExceptionHandler
   {
   public:
-    virtual VALUE handle_exception() const override;
+    virtual VALUE handle() const override;
   };
 
   // An exception handler that takes a functor as an argument.  The
@@ -64,18 +63,15 @@ namespace Rice::detail
   // 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
+  class CustomExceptionHandler : public ExceptionHandler
   {
   public:
-    Functor_Exception_Handler(Functor_T handler,
-      std::shared_ptr<Exception_Handler> next_exception_handler);
-
-    virtual VALUE handle_exception() const override;
+    CustomExceptionHandler(Functor_T handler, std::shared_ptr<ExceptionHandler> nextHandler);
+    virtual VALUE handle() const override;
 
   private:
     Functor_T handler_;
-    std::shared_ptr<Exception_Handler> next_exception_handler_;
+    std::shared_ptr<ExceptionHandler> nextHandler_;
   };
 }
-#endif // Rice__detail__Exception_Handler_defn__hpp_
+#endif // Rice__detail__ExceptionHandler_defn__hpp_

data/rice/detail/HandlerRegistry.hpp

@@ -0,0 +1,51 @@
+#ifndef Rice__detail__HandlerRegistry__hpp_
+#define Rice__detail__HandlerRegistry__hpp_
+
+#include "ExceptionHandler.hpp"
+
+namespace Rice::detail
+{
+  class HandlerRegistry
+  {
+  public:
+    //! Define an exception handler.
+    /*! Whenever an exception of type Exception_T is thrown from a
+     *  function defined on this class, the supplied functor will be called to
+     *  translate the exception into a ruby exception.
+     *  \param Exception_T a template parameter indicating the type of
+     *  exception to be translated.
+     *  \param functor a functor to be called to translate the exception
+     *  into a ruby exception.  This functor should re-throw the exception
+     *  as an Exception.
+     *  Example:
+     *  \code
+     *    Class rb_cFoo;
+     *
+     *    void translate_my_exception(MyException const& ex)
+     *    {
+     *       throw Rice::Exception(rb_eRuntimeError, ex.what_without_backtrace());
+     *    }
+     *
+     *    extern "C"
+     *    void Init_MyExtension()
+     *    {
+     *      rb_cFoo = define_class("Foo");
+     *      register_handler<MyException>(translate_my_exception);
+     *    }
+     *  \endcode
+     */
+    template<typename Exception_T, typename Functor_T>
+    HandlerRegistry& add(Functor_T functor);
+
+    std::shared_ptr<detail::ExceptionHandler> handler() const;
+
+  private:
+    mutable std::shared_ptr<detail::ExceptionHandler> handler_ = std::make_shared<Rice::detail::DefaultExceptionHandler>();
+
+  };
+} // namespace Rice::detail
+
+#include "HandlerRegistry.ipp"
+
+#endif // Rice__detail__HandlerRegistry__hpp_
+

data/rice/detail/HandlerRegistry.ipp

@@ -0,0 +1,20 @@
+#include <memory>
+
+namespace Rice::detail
+{
+  template<typename Exception_T, typename Functor_T>
+  inline HandlerRegistry& HandlerRegistry::add(Functor_T functor)
+  {
+    // Create a new exception handler and pass ownership of the current handler to it (they
+    // get chained together). Then take ownership of the new handler.
+    this->handler_ = std::make_shared<detail::CustomExceptionHandler<Exception_T, Functor_T>>(
+      functor, std::move(this->handler_));
+
+    return *this;
+  }
+
+  inline std::shared_ptr<detail::ExceptionHandler> HandlerRegistry::handler() const
+  {
+    return this->handler_;
+  }
+} // namespace

data/rice/detail/InstanceRegistry.hpp

@@ -0,0 +1,34 @@
+#ifndef Rice__detail__InstanceRegistry__hpp_
+#define Rice__detail__InstanceRegistry__hpp_
+
+#include <map>
+#include "ruby.hpp"
+
+namespace Rice::detail
+{
+  class InstanceRegistry
+  {
+  public:
+    template <typename T>
+    VALUE lookup(T& cppInstance);
+
+    template <typename T>
+    VALUE lookup(T* cppInstance);
+
+    void add(void* cppInstance, VALUE rubyInstance);
+    void remove(void* cppInstance);
+    void clear();
+
+  public:
+    bool isEnabled = false;
+
+  private:
+    VALUE lookup(void* cppInstance);
+    std::map<void*, VALUE> objectMap_;
+  };
+} // namespace Rice::detail
+
+#include "InstanceRegistry.ipp"
+
+#endif // Rice__detail__InstanceRegistry__hpp_
+

data/rice/detail/InstanceRegistry.ipp

@@ -0,0 +1,50 @@
+#include <memory>
+
+namespace Rice::detail
+{
+  template <typename T>
+  inline VALUE InstanceRegistry::lookup(T& cppInstance)
+  {
+    return this->lookup((void*)&cppInstance);
+  }
+
+  template <typename T>
+  inline VALUE InstanceRegistry::lookup(T* cppInstance)
+  {
+    return this->lookup((void*)cppInstance);
+  }
+
+  inline VALUE InstanceRegistry::lookup(void* cppInstance)
+  {
+    if (!this->isEnabled)
+      return Qnil;
+
+    auto it = this->objectMap_.find(cppInstance);
+    if (it != this->objectMap_.end())
+    {
+      return it->second;
+    }
+    else
+    {
+      return Qnil;
+    }
+  }
+
+  inline void InstanceRegistry::add(void* cppInstance, VALUE rubyInstance)
+  {
+    if (this->isEnabled)
+    {
+      this->objectMap_[cppInstance] = rubyInstance;
+    }
+  }
+
+  inline void InstanceRegistry::remove(void* cppInstance)
+  {
+    this->objectMap_.erase(cppInstance);
+  }
+
+  inline void InstanceRegistry::clear()
+  {
+    this->objectMap_.clear();
+  }
+} // namespace

data/rice/detail/MethodInfo.ipp

@@ -13,7 +13,7 @@ namespace Rice
     for (size_t i = this->args_.size(); i < argCount; i++)
     {
       Arg arg("arg_" + std::to_string(i));
-      this->args_.emplace_back(arg);
+      this->addArg(arg);
     }
 
     // TODO - so hacky but update the Arg positions

data/rice/detail/NativeAttribute.hpp

@@ -2,8 +2,7 @@
 #define Rice__detail__Native_Attribute__hpp_
 
 #include "ruby.hpp"
-#include "Exception_Handler_defn.hpp"
-#include "MethodInfo.hpp"
+#include "../traits/attribute_traits.hpp"
 
 namespace Rice
 {
@@ -16,35 +15,47 @@ namespace Rice
 
   namespace detail
   {
-    template<typename Return_T, typename Attr_T, typename Self_T = void>
+    template<typename Attribute_T>
     class NativeAttribute
     {
     public:
-      using Native_Return_T = Return_T;
+      using NativeAttribute_T = NativeAttribute<Attribute_T>;
 
-      // Static member functions that Ruby calls
+      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:
-      NativeAttribute(Attr_T attr, AttrAccess access = AttrAccess::ReadWrite);
+      // 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:
-      Attr_T attr_;
+      VALUE klass_;
+      std::string name_;
+      Attribute_T attribute_;
       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