rice 3.0.0 → 4.0.0

data/rice/Enum.hpp

@@ -1,117 +1,67 @@
 #ifndef Rice__Enum__hpp_
 #define Rice__Enum__hpp_
 
-#include "to_from_ruby_defn.hpp"
-#include "Address_Registration_Guard.hpp"
-#include "Array.hpp"
-#include "Hash.hpp"
-#include "String.hpp"
-#include "Module.hpp"
 #include "Data_Type.hpp"
+#include <map>
 
 namespace Rice
 {
-
-//! Default traits for the Enum class template.
-template<typename Enum_T>
-struct Default_Enum_Traits
-{
-  //! Converts the enum value to a long.
-  static long as_long(Enum_T value);
-};
-
-/*!
- *  \example enum/sample_enum.cpp
- */
-
-//! A wrapper for enumerated types.
-/*! Provides a simple type-safe wrapper for enumerated types.  At the
- *  ruby level, the class will have convenience methods for iterating
- *  over all the defined enum values, converting the values to strings,
- *  and more.
- *
- *  \param Enum_T the enumerated type
- *  \param Enum_Traits specifies the traits of the enumerated type.
- *
- *  Example:
- *  \code
- *    enum Color { Red, Green, Blue };
- *    Enum<Color> rb_cColor = define_enum<Color>("Color")
- *      .define_value("Red", Red)
- *      .define_value("Green", Green)
- *      .define_value("Blue", Blue);
- *  \endcode
- */
-template<typename Enum_T, typename Enum_Traits = Default_Enum_Traits<Enum_T> >
-class Enum
-  : public Module_impl<Data_Type<Enum_T>, Enum<Enum_T, Enum_Traits> >
-{
-public:
-  //! Default constructor.
-  Enum();
-
-  //! Construct and initialize.
-  Enum(
-      char const * name,
-      Module module = rb_cObject);
-
-  //! Copy constructor.
-  Enum(Enum const & other);
-
-  //! Assignment operator.
-  Enum & operator=(Enum const & other);
-
-  //! Destructor.
-  virtual ~Enum();
-
-  //! Define a new enum value.
-  /*! \param name the name of the enum value.
-   *  \param value the value to associate with name.
-   *  \return *this
+  /*!
+   *  \example enum/sample_enum.cpp
    */
-  Enum<Enum_T, Enum_Traits> & define_value(
-      char const * name,
-      Enum_T value);
-
-  void swap(Enum & other);
-
-private:
-  //! Initialize the enum type.
-  /*! Must be called only once.
-   *  \param name the name of the class to define
-   *  \param module the module in which to place the enum class.
-   *  \return *this
-   */
-  Enum<Enum_T, Enum_Traits> & initialize(
-      char const * name,
-      Module module = rb_cObject);
-
-private:
-  static Object each(Object self);
-  static Object to_s(Object self);
-  static Object to_i(Object self);
-  static Object inspect(Object self);
-  static Object compare(Object lhs, Object rhs);
-  static Object eql(Object lhs, Object rhs);
-  static Object hash(Object self);
-  static Object from_int(Class klass, Object i);
-
-private:
-  Array enums_;
-  Address_Registration_Guard enums_guard_;
-
-  Hash names_;
-  Address_Registration_Guard names_guard_;
-};
-
-template<typename T>
-Enum<T> define_enum(
-    char const * name,
-    Module module = rb_cObject);
 
+   //! A wrapper for enumerated types.
+   /*! Provides a simple type-safe wrapper for enumerated types.  At the
+    *  ruby level, the class will have convenience methods for iterating
+    *  over all the defined enum values, converting the values to strings,
+    *  and more.
+    *
+    *  \param Enum_T the enumerated type
+    *
+    *  Example:
+    *  \code
+    *    enum Color { Red, Green, Blue };
+    *    Enum<Color> rb_cColor = define_enum<Color>("Color")
+    *      .define_value("Red", Red)
+    *      .define_value("Green", Green)
+    *      .define_value("Blue", Blue);
+    *  \endcode
+    */
+  template<typename Enum_T>
+  class Enum : public Data_Type<Enum_T>
+  {
+    using Underlying_T = std::underlying_type_t<Enum_T>;
+
+  public:
+
+    Enum() = default;
+
+    //! Construct and initialize.
+    Enum(char const* name, Module module = rb_cObject);
+
+    //! Define a new enum value.
+    /*! \param name the name of the enum value.
+     *  \param value the value to associate with name.
+     *  \return *this
+     */
+    Enum<Enum_T>& define_value(std::string name, Enum_T value);
+
+    //! Maps an enum value to the correct Ruby object
+    /*! \param klass The bound Ruby class
+     *  \param enumValue The enum value
+     *  \return Object - The Ruby wrapper */
+    static Object from_enum(Class klass, Enum_T enumValue);
+
+  private:
+    void define_methods(Data_Type<Enum_T> klass);
+
+    static inline std::map<Enum_T, std::string> valuesToNames_;
+  };
+
+  template<typename T>
+  Enum<T> define_enum(char const* name, Module module = rb_cObject);
 } // namespace Rice
 
 #include "Enum.ipp"
 
-#endif // Rice__Enum__hpp_
-
+#endif // Rice__Enum__hpp_

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);
+  }
+}