rice 3.0.0 → 4.0.3

data/rice/Enum.ipp

@@ -1,246 +1,120 @@
-#ifndef Rice__Enum__ipp_
-#define Rice__Enum__ipp_
-
+#include "detail/TypeRegistry.hpp"
 #include "Data_Object.hpp"
-#include "Class.hpp"
-#include "String.hpp"
-#include "protect.hpp"
-#include <memory>
-
-template<typename Enum_T>
-long Rice::Default_Enum_Traits<Enum_T>::as_long(Enum_T value)
-{
-  return static_cast<long>(value);
-}
-
-template<typename Enum_T, typename Enum_Traits>
-Rice::Enum<Enum_T, Enum_Traits>::
-Enum()
-  : Module_impl<Data_Type<Enum_T>, Enum<Enum_T, Enum_Traits> >()
-  , enums_()
-  , enums_guard_(&enums_)
-  , names_()
-  , names_guard_(&names_)
-{
-}
-
-template<typename Enum_T, typename Enum_Traits>
-Rice::Enum<Enum_T, Enum_Traits>::
-Enum(
-    char const * name,
-    Module module)
-  : Module_impl<Data_Type<Enum_T>, Enum<Enum_T, Enum_Traits> >()
-  , enums_()
-  , enums_guard_(&enums_)
-  , names_()
-  , names_guard_(&names_)
-{
-  this->template bind<void>(initialize(name, module));
-}
-
-template<typename Enum_T, typename Enum_Traits>
-Rice::Enum<Enum_T, Enum_Traits>::
-Enum(Enum<Enum_T, Enum_Traits> const & other)
-  : Module_impl<Data_Type<Enum_T>, Enum<Enum_T, Enum_Traits> >(other)
-  , enums_(other.enums_)
-  , enums_guard_(&enums_)
-  , names_(other.names_)
-  , names_guard_(&names_)
-{
-}
-
-template<typename Enum_T, typename Enum_Traits>
-Rice::Enum<Enum_T, Enum_Traits> & Rice::Enum<Enum_T, Enum_Traits>::
-operator=(Rice::Enum<Enum_T, Enum_Traits> const & other)
-{
-  Rice::Enum<Enum_T, Enum_Traits> tmp(other);
-  this->swap(tmp);
-  return *this;
-}
-
-template<typename Enum_T, typename Enum_Traits>
-Rice::Enum<Enum_T, Enum_Traits>::
-~Enum()
-{
-}
-
-template<typename Enum_T, typename Enum_Traits>
-Rice::Enum<Enum_T, Enum_Traits> & Rice::Enum<Enum_T, Enum_Traits>::
-initialize(
-    char const * name,
-    Module module)
-{
-  Class c = Rice::define_class_under<Enum_T>(module, name)
-    .define_method("to_s", to_s)
-    .define_method("to_i", to_i)
-    .define_method("inspect", inspect)
-    .define_method("<=>", compare)
-    .define_method("hash", hash)
-    .define_method("eql?", eql)
-    .define_method("==", eql)
-    .define_method("===", eql)
-    .define_singleton_method("each", each)
-    .define_singleton_method("from_int", from_int)
-    .include_module(rb_mComparable);
-
-  // TODO: This should be unnecessary (it should be taken care of when
-  // define_class_under binds the C++ and ruby types)
-  this->set_value(c);
-
-  protect(rb_iv_set, c, "enums", enums_);
-  protect(rb_iv_set, c, "names", names_);
-
-  return *this;
-}
-
-template<typename Enum_T, typename Enum_Traits>
-Rice::Enum<Enum_T, Enum_Traits> & Rice::Enum<Enum_T, Enum_Traits>::
-define_value(
-    char const * name,
-    Enum_T value)
-{
-  std_unique_ptr<Enum_T> copy(new Enum_T(value));
-  Rice::Data_Object<Enum_T> m(copy.get(), *this);
-  copy.release();
-  names_[m] = String(name);
-  this->const_set(name, m);
-  enums_.push(m);
-
-  return *this;
-}
+#include "cpp_api/String.hpp"
 
+#include <stdexcept>
 
-template<typename Enum_T, typename Enum_Traits>
-void Rice::Enum<Enum_T, Enum_Traits>::
-swap(Enum<Enum_T, Enum_Traits> & other)
+namespace Rice
 {
-  Data_Type<Enum_T>::swap(other);
-  enums_.swap(other.enums_);
-  names_.swap(other.names_);
-}
-
-template<typename Enum_T, typename Enum_Traits>
-Rice::Object Rice::Enum<Enum_T, Enum_Traits>::
-each(Object self)
-{
-  VALUE enums_v = rb_iv_get(self, "enums");
-  Check_Type(enums_v, T_ARRAY);
-  Array enums(enums_v);
-  for(size_t j = 0; j < enums.size(); ++j)
+  template<typename Enum_T>
+  Enum<Enum_T>::Enum(char const* name, Module module) : Data_Type<Enum_T>()
   {
-    rb_yield(enums[j].value());
+    Data_Type<Enum_T> klass = define_class_under<Enum_T>(module, name);
+    define_methods(klass);
   }
-  return Qnil;
-}
 
-template<typename Enum_T, typename Enum_Traits>
-Rice::Object Rice::Enum<Enum_T, Enum_Traits>::
-to_s(Object self)
-{
-  Data_Type<Enum_T> klass;
-  Rice::Data_Object<Enum_T> m(self, klass);
-  Object enum_class = rb_class_of(m);
-  Hash names(rb_iv_get(enum_class, "names"));
-  Object name = names[m];
-  if(name.is_nil())
+  template<typename Enum_T>
+  inline Enum<Enum_T>& Enum<Enum_T>::define_value(std::string name, Enum_T value)
   {
-    return String::format("INVALID(%d)", Enum_Traits::as_long(*m));
-  }
-  else
-  {
-    return String(name);
-  }
-}
+    // Save mapping from value to name
+    valuesToNames_[value] = name;
 
-template<typename Enum_T, typename Enum_Traits>
-Rice::Object Rice::Enum<Enum_T, Enum_Traits>::
-inspect(Object self)
-{
-  return String::format(
-      "#<%s::%s>",
-      String(self.class_of().name()).c_str(),
-      String(to_s(self)).c_str());
-}
+    // Store value as class constant available to Ruby
+    Data_Object<Enum_T> object(value, true, Enum<Enum_T>::klass());
+    this->const_set(name, object);
 
-template<typename Enum_T, typename Enum_Traits>
-Rice::Object Rice::Enum<Enum_T, Enum_Traits>::
-compare(Object lhs, Object rhs)
-{
-  if(lhs.class_of() != rhs.class_of())
-  {
-    String lhs_name(lhs.class_of().name());
-    String rhs_name(rhs.class_of().name());
-    rb_raise(
-        rb_eTypeError,
-        "Cannot compare %s to %s",
-        lhs_name.c_str(),
-        rhs_name.c_str());
+    return *this;
   }
 
-  Data_Type<Enum_T> klass;
-  Rice::Data_Object<Enum_T> l(lhs, klass);
-  Rice::Data_Object<Enum_T> r(rhs, klass);
-
-  Enum_T left(*l);
-  Enum_T right(*r);  
-
-  if(left == right)
-  {
-    return INT2NUM(0);
-  }
-  else if(Enum_Traits::as_long(left) < Enum_Traits::as_long(right))
-  {
-    return INT2NUM(-1);
-  }
-  else
+  template<typename Enum_T>
+  inline void Enum<Enum_T>::define_methods(Data_Type<Enum_T> klass)
   {
-    return INT2NUM(1);
+    // First we need a constructor
+    klass.define_constructor(Constructor<Enum_T>());
+
+    // Instance methods
+    klass.define_method("to_s", [](Enum_T& self)
+        {
+          // We have to return string because we don't know if std::string support has
+          // been included by the user
+          return String(valuesToNames_[self]);
+        })
+      .define_method("to_i", [](Enum_T& self) ->  Underlying_T
+        {
+          return (Underlying_T)self;
+        })
+      .define_method("inspect", [](Enum_T& self)
+        {
+          std::stringstream result;
+          VALUE rubyKlass = Enum<Enum_T>::klass().value();
+          result << "#<" << detail::protect(rb_class2name, rubyKlass)
+            << "::" << Enum<Enum_T>::valuesToNames_[self] << ">";
+
+          // We have to return string because we don't know if std::string support has
+          // 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;
+        })
+      .define_method("eql?", [](Enum_T& self, Enum_T& other)
+        {
+          return self == other;
+        });
+
+    // Add aliases
+    rb_define_alias(klass, "===", "eql?");
+
+    // Add comparable support
+    klass.include_module(rb_mComparable);
+
+    // Singleton methods
+    klass.define_singleton_method("each", [](VALUE klass)
+        {
+          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)
+      {
+          auto iter = Enum<Enum_T>::valuesToNames_.find((Enum_T)value);
+          if (iter == Enum<Enum_T>::valuesToNames_.end())
+          {
+            throw std::runtime_error("Unknown enum value: " + std::to_string(value));
+          }
+
+          std::string name = iter->second;
+          return Class(klass).const_get(name);
+      });
   }
-}
 
-template<typename Enum_T, typename Enum_Traits>
-Rice::Object Rice::Enum<Enum_T, Enum_Traits>::
-eql(Object lhs, Object rhs)
-{
-  using ::from_ruby; // Workaround for g++ 3.3.3
-  bool is_equal = from_ruby<int>(compare(lhs, rhs)) == 0; 
-  return to_ruby(is_equal);
-}
-
-template<typename Enum_T, typename Enum_Traits>
-Rice::Object Rice::Enum<Enum_T, Enum_Traits>::
-to_i(Object self)
-{
-  Data_Type<Enum_T> klass;
-  Rice::Data_Object<Enum_T> m(self, klass);
-  return LONG2NUM(Enum_Traits::as_long(*m));
-}
-
-template<typename Enum_T, typename Enum_Traits>
-Rice::Object Rice::Enum<Enum_T, Enum_Traits>::
-hash(Object self)
-{
-  return to_i(self);
-}
-
-template<typename Enum_T, typename Enum_Traits>
-Rice::Object Rice::Enum<Enum_T, Enum_Traits>::
-from_int(Class klass, Object i)
-{
-  using ::from_ruby; // Workaround for g++ 3.3.3
-  Rice::Data_Object<Enum_T> m(
-      new Enum_T(static_cast<Enum_T>(from_ruby<long>(i))),
-      klass);
-  return m.value();
-}
-
-template<typename T>
-Rice::Enum<T> Rice::
-define_enum(
-    char const * name,
-    Module module)
-{
-  return Enum<T>(name, module);
-}
-#endif // Rice__Enum__ipp_
+  template<typename Enum_T>
+  Enum<Enum_T> define_enum(char const* name, Module module)
+  {
+    if (detail::TypeRegistry::isDefined<Enum_T>())
+    {
+      return Enum<Enum_T>();
+    }
 
+    return Enum<Enum_T>(name, module);
+  }
+}

data/rice/Exception.hpp

@@ -1,13 +1,7 @@
 #ifndef Rice__Exception__hpp_
 #define Rice__Exception__hpp_
 
-namespace Rice {
-  class Exception;
-}
-
 #include "Exception_defn.hpp"
-#include "Exception_Base.hpp"
-#include "Address_Registration_Guard.hpp"
-
-#endif // Rice__Exception__hpp_
+#include "Exception.ipp"
 
+#endif // Rice__Exception__hpp_

data/rice/Exception.ipp

@@ -0,0 +1,65 @@
+#ifndef Rice__Exception__ipp_
+#define Rice__Exception__ipp_
+
+#include "detail/from_ruby.hpp"
+
+namespace Rice
+{
+  inline Exception::Exception(VALUE exception) : exception_(exception)
+  {
+  }
+
+  template <typename... Arg_Ts>
+  inline Exception::Exception(const Exception& other, char const* fmt, Arg_Ts&&...args)
+    : Exception(other.class_of(), fmt, std::forward<Arg_Ts>(args)...)
+  {
+  }
+
+  template <typename... Arg_Ts>
+  inline Exception::Exception(const VALUE exceptionClass, char const* fmt, Arg_Ts&&...args)
+  {
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wformat-security"
+#endif
+
+    size_t size = std::snprintf(nullptr, 0, fmt, std::forward<Arg_Ts>(args)...);
+    this->message_ = std::string(size, '\0');
+
+    // size+1 avoids truncating the string. Otherwise snprintf writes n - 1 characters
+    // to allow space for null character but we don't need that since std::string
+    // will add a null character internally at n + 1
+    std::snprintf(&this->message_[0], size + 1, fmt, std::forward<Arg_Ts>(args)...);
+
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+
+    // Now create the Ruby exception
+    this->exception_ = detail::protect(rb_exc_new2, exceptionClass, this->message_.c_str());
+  }
+
+  inline char const* Exception::what() const noexcept
+  {
+    if (this->message_.empty())
+    {
+      // Cache the message - this allows the returned pointer to be valid for the
+      // lifetime of this exception instance.
+      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();
+  }
+
+  inline VALUE Exception::class_of() const
+  {
+    return detail::protect(rb_class_of, this->exception_);
+  }
+
+  inline VALUE Exception::value() const
+  {
+    return this->exception_;
+  }
+}
+#endif // Rice__Exception__ipp_

data/rice/Exception_defn.hpp

@@ -1,69 +1,68 @@
 #ifndef Rice__Exception_defn__hpp_
 #define Rice__Exception_defn__hpp_
 
-#include "Exception_Base_defn.hpp"
-#include "String.hpp"
-#include "Address_Registration_Guard_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);
 
-//! 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 Exception_Base
-{
-public:
-  //! Construct a Exception with the exception e.
-  explicit Exception(VALUE e);
-
-  //! Copy constructor.
-  Exception(Exception const & other);
+    //! 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.
+    //! 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.
    */
-  Exception(Object exc, char const * fmt, ...);
+    template <typename... Arg_Ts>
+    Exception(const VALUE exceptionType, char const* fmt, Arg_Ts&&...args);
 
-  //! Destructor
-  virtual ~Exception() throw() { }
+    //! Destructor
+    virtual ~Exception() noexcept = default;
 
-  //! Get the message the exception holds
-  /*! \return the result of calling message() on the underlying
-   *  exception object.
-   */
-  String message() const;
+    //! 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;
 
-  //! 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 throw();
+    //! Returns the Ruby exception class
+    VALUE class_of() const;
 
-private:
-  // Keep message around in case someone calls what() and then the GC
-  // gets invoked.
-  mutable VALUE message_;
-  Address_Registration_Guard message_guard_;
-};
+    //! 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_
-
+#endif // Rice__Exception_defn__hpp_

data/rice/Identifier.hpp

@@ -1,48 +1,48 @@
 #ifndef Rice__Identifier__hpp_
 #define Rice__Identifier__hpp_
 
-#include "detail/ruby.hpp"
 #include <string>
 
 namespace Rice
 {
+  class Symbol;
 
-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);
 
-//! 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 Symbol.
+    Identifier(Symbol const& symbol);
 
-  //! Construct a new Identifier from a string.
-  Identifier(char const * s = "");
+    //! Construct a new Identifier from a c string.
+    Identifier(char const* s);
 
-  //! Return a string representation of the Identifier.
-  char const * c_str() const;
+    //! Construct a new Identifier from a string.
+    Identifier(std::string const string);
 
-  //! Return a string representation of the Identifier.
-  std::string str() const;
+    //! Return a string representation of the Identifier.
+    char const* c_str() const;
 
-  //! Return the underlying ID
-  ID id() const { return id_; }
+    //! Return a string representation of the Identifier.
+    std::string str() const;
 
-  //! Return the underlying ID
-  operator ID() const { return id_; }
+    //! Return the underlying ID
+    ID id() const { return id_; }
 
-  //! Return the ID as a Symbol
-  VALUE to_sym() const;
+    //! Return the underlying ID
+    operator ID() const { return id_; }
 
-private:
-  ID id_;
-};
+    //! Return the ID as a Symbol
+    VALUE to_sym() const;
 
+  private:
+    ID id_;
+  };
 } // namespace Rice
 
 #include "Identifier.ipp"

data/rice/Identifier.ipp

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