rice 4.5.0 → 4.6.0

data/rice/Data_Type.ipp

@@ -3,7 +3,7 @@
 namespace Rice
 {
   template<typename T>
-  inline void ruby_mark_internal(detail::Wrapper* wrapper)
+  inline void ruby_mark_internal(detail::WrapperBase* wrapper)
   {
     // Tell the wrapper to mark the objects its keeping alive
     wrapper->ruby_mark();
@@ -14,7 +14,7 @@ namespace Rice
   }
 
   template<typename T>
-  inline void ruby_free_internal(detail::Wrapper* wrapper)
+  inline void ruby_free_internal(detail::WrapperBase* wrapper)
   {
     delete wrapper;
   }
@@ -59,12 +59,12 @@ namespace Rice
     // Now register with the type registry
     detail::Registries::instance.types.add<T>(klass_, rb_data_type_);
 
-    auto iter = Data_Type<T>::unbound_instances_.begin();
-    while (iter != Data_Type<T>::unbound_instances_.end())
+    auto instances = unbound_instances();
+    for (auto instance: instances)
     { 
-      (*iter)->set_value(klass);
-      iter = Data_Type<T>::unbound_instances_.erase(iter);
+      instance->set_value(klass);
     }
+    instances.clear();
 
     return Data_Type<T>();
   }
@@ -84,12 +84,26 @@ namespace Rice
     rb_data_type_ = nullptr;
   }
 
+  // Track unbound instances (ie, declared variables of type Data_Type<T>
+  // before define_class is called). We can't simply use a static inline
+  // member because it sometimes crashes clang and gcc (msvc seems fine)
   template<typename T>
-  inline Data_Type<T>::Data_Type() : Class(klass_ == Qnil ? rb_cObject : klass_)
+  inline std::set<Data_Type<T>*>& Data_Type<T>::unbound_instances()
   {
-    if (!is_bound())
+    static std::set<Data_Type<T>*> unbound_instances;
+    return unbound_instances;
+  }
+
+  template<typename T>
+  inline Data_Type<T>::Data_Type()
+  {
+    if (is_bound())
     {
-      this->unbound_instances_.insert(this);
+      this->set_value(klass_);
+    }
+    else
+    {
+      unbound_instances().insert(this);
     }
   }
 
@@ -172,7 +186,7 @@ namespace Rice
   template<typename Director_T>
   inline Data_Type<T>& Data_Type<T>::define_director()
   {
-    if (!detail::Registries::instance.types.isDefined<Director_T>())
+    if (!Data_Type<Director_T>::is_defined())
     {
       Data_Type<Director_T>::bind(*this);
     }
@@ -207,24 +221,26 @@ namespace Rice
   }
 
   template<typename T>
-  inline bool Data_Type<T>::is_defined(Object parent, const std::string& name)
+  inline bool Data_Type<T>::is_defined()
   {
-    // Is the class already defined?
-    if (detail::Registries::instance.types.isDefined<T>())
-    {
-      Data_Type<T> result = Data_Type<T>();
-
-      // If this redefinition is a different name then create a new constant
-      if (result.name() != name)
-      {
-        detail::protect(rb_define_const, parent, name.c_str(), result.klass());
-      }
+    return detail::Registries::instance.types.isDefined<T>();
+  }
 
+  template<typename T>
+  inline bool Data_Type<T>::check_defined(const std::string& name, Object parent)
+  {
+    if (Data_Type<T>::is_defined())
+    {
+      Data_Type<T> dataType;
+      parent.const_set_maybe(name, dataType.klass());
       return true;
     }
-    return false;
+    else
+    {
+      return false;
+    }
   }
-  
+   
   template<typename Base_T>
   inline Class get_superklass()
   {
@@ -247,7 +263,7 @@ namespace Rice
   template<typename T, typename Base_T>
   inline Data_Type<T> define_class_under(Object parent, Identifier id, Class superKlass)
   {
-    if (Rice::Data_Type<T>::is_defined(parent, id.str()))
+    if (Rice::Data_Type<T>::check_defined(id.str(), parent))
     {
       return Data_Type<T>();
     }
@@ -270,7 +286,7 @@ namespace Rice
   {
     std::string klassName(name);
 
-    if (Rice::Data_Type<T>::is_defined(rb_cObject, klassName))
+    if (Rice::Data_Type<T>::check_defined(klassName))
     {
       return Data_Type<T>();
     }
@@ -308,7 +324,7 @@ namespace Rice
     using Attr_T = typename detail::NativeAttributeSet<Attribute_T>::Attr_T;
     if constexpr (!std::is_const_v<Attr_T> &&
                   (std::is_fundamental_v<Attr_T> || std::is_assignable_v<Attr_T, Attr_T>))
-        {
+    {
       // Define native attribute setter
       if (access == AttrAccess::ReadWrite || access == AttrAccess::Write)
         detail::NativeAttributeSet<Attribute_T>::define(klass_, name, std::forward<Attribute_T>(attribute));

data/rice/Enum.hpp

@@ -30,7 +30,6 @@ namespace Rice
     using Underlying_T = std::underlying_type_t<Enum_T>;
 
   public:
-
     Enum() = default;
 
     //! Construct and initialize.

data/rice/Enum.ipp

@@ -1,4 +1,3 @@
-
 #include <stdexcept>
 
 namespace Rice
@@ -29,44 +28,48 @@ namespace Rice
     // First we need a constructor
     klass.define_constructor(Constructor<Enum_T>());
 
-    // Instance methods. The self parameter is confusing because it is really a Data_Object<Enum_T>.
-    // However, if we make that the type then the From_Ruby code will consider it a 
-    // Data_Type<Data_Object<Enum_T>>>. But in define class above it was actually bound as 
-    // Data_Type<Enum_T>. Thus the static_casts in the methods below.
-    klass.define_method("to_s", [](Enum_T& notSelf)
+    klass.define_method("to_s", [](Enum_T& self) -> String
       {
-        // We have to return string because we don't know if std::string support has
-        // been included by the user
-        Data_Object<Enum_T> self = static_cast<Data_Object<Enum_T>>(notSelf);
-        return String(valuesToNames_[*self]);
+        return String(valuesToNames_[self]);
       })
-      .define_method("to_int", [](Enum_T& notSelf) ->  Underlying_T
+      .define_method("to_int", [](Enum_T& self) ->  Underlying_T
       {
-        Data_Object<Enum_T> self = static_cast<Data_Object<Enum_T>>(notSelf);
-        return static_cast<Underlying_T>(*self);
+        return (Underlying_T)(self);
       })
-      .define_method("inspect", [](Enum_T& notSelf)
+      .define_method("coerce", [](Enum_T& self, Underlying_T& other) -> Array
+      {
+        /* Other will be a numeric value that matches the underlying type of the enum, for example an int.
+           Convert that to the enum type and then create new Ruby object to wrap it. This then enables code
+           like this:
+        
+           Colors::Red | Colors:Blue | Colors:Green
+
+        Colors::Red | Colors:Blue returns an integer. Then this method converts the integer back into an Enum
+        instance so that Colors:Blue | Colors:Green works. */
+        Enum_T otherEnum = (Enum_T)other;
+
+        Array result;
+        result.push(self);
+        result.push(otherEnum);
+        return result;
+      })
+      .define_method("inspect", [](Enum_T& self)
       {
-        Data_Object<Enum_T> self = static_cast<Data_Object<Enum_T>>(notSelf);
-
         std::stringstream result;
         VALUE rubyKlass = Enum<Enum_T>::klass().value();
         result << "#<" << detail::protect(rb_class2name, rubyKlass)
-          << "::" << Enum<Enum_T>::valuesToNames_[*self] << ">";
+          << "::" << 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("hash", [](Enum_T& notSelf) ->  Underlying_T
+      .define_method("hash", [](Enum_T& self) ->  Underlying_T
       {
-        Data_Object<Enum_T> self = static_cast<Data_Object<Enum_T>>(notSelf);
-        return (Underlying_T)*self;
+        return (Underlying_T)self;
       })
-      .define_method("eql?", [](Enum_T& notSelf, Enum_T& notOther)
+      .define_method("eql?", [](Enum_T& self, Enum_T& other)
       {
-        Data_Object<Enum_T> self = static_cast<Data_Object<Enum_T>>(notSelf);
-        Data_Object<Enum_T> other = static_cast<Data_Object<Enum_T>>(notOther);
         return self == other;
     });
 

data/rice/Init.hpp

@@ -0,0 +1,8 @@
+#ifndef Rice__Init__hpp_
+#define Rice__Init__hpp_
+
+namespace Rice
+{
+  void init();
+}
+#endif // Rice__Init__hpp_

data/rice/Init.ipp

@@ -0,0 +1,8 @@
+namespace Rice
+{
+  inline void init()
+  {
+    detail::define_ruby_types();
+    define_fundamental_buffer_types();
+  };
+}

data/rice/MemoryView.ipp

@@ -1,43 +1,3 @@
 namespace Rice
 {
-}
-
-namespace Rice::detail
-{
-  template<>
-  class To_Ruby<unsigned char**>
-  {
-  public:
-    VALUE convert(unsigned char** x)
-    {
-      std::runtime_error("To_Ruby unsigned char** is not implemented yet");
-      return Qnil;
-    }
-  };
-
-  template<>
-  class From_Ruby<unsigned char**>
-  {
-  public:
-    From_Ruby() = default;
-
-    explicit From_Ruby(Arg* arg) : arg_(arg)
-    {
-    }
-
-    Convertible is_convertible(VALUE value)
-    {
-      std::runtime_error("From_Ruby unsigned char** is not implemented yet");
-      return Convertible::None;
-    }
-
-    unsigned char** convert(VALUE value)
-    {
-      std::runtime_error("From_Ruby unsigned char** is not implemented yet");
-      return nullptr;
-    }
-
-  private:
-    Arg* arg_ = nullptr;
-  };
-}
+}

data/rice/Return.hpp

@@ -13,7 +13,7 @@ namespace Rice
     Return& setValue() override;
     Return& setOpaque() override;
     Return& takeOwnership() override;
-
+    Return& setArray() override;
   };
 } // Rice
 

data/rice/Return.ipp

@@ -29,4 +29,10 @@ namespace Rice
     Arg::takeOwnership();
     return *this;
   }
+
+  inline Return& Return::setArray()
+  {
+    Arg::setArray();
+    return *this;
+  }
 }  // Rice

data/rice/cpp_api/Array.hpp

@@ -0,0 +1,209 @@
+#ifndef Rice__Array__hpp_
+#define Rice__Array__hpp_
+
+#include <iterator>
+#include <memory>
+
+namespace Rice
+{
+  //! A wrapper for the ruby Array class.
+  /*! This class provides a C++-style interface to ruby's Array class and
+   *  its associated rb_ary_* functions.
+   *  Example:
+   *  \code
+   *    Array a;
+   *    a.push(String("some string"));
+   *    a.push(42);
+   *  \endcode
+   */
+  class Array
+    : public Builtin_Object<T_ARRAY>
+  {
+  public:
+    //! Construct a new array
+    Array();
+
+    //! Construct a new array with specified size
+    Array(long capacity);
+
+    //! Wrap an existing array
+    /*! \param v a ruby object, which must be of type T_ARRAY.
+     */
+    Array(Object v);
+
+    //! Wrap an existing array
+    /*! \param v a ruby object, which must be of type T_ARRAY.
+     */
+    Array(VALUE v);
+
+    //! Construct an array from a sequence.
+    /*! \param begin an iterator to the beginning of the sequence.
+     *  \param end an iterator to the end of the sequence.
+     */
+    template<typename Iter_T>
+    Array(Iter_T begin, Iter_T end);
+
+    //! Construct an Array from a C array.
+    /*! \param a a C array of type T and size n.
+     */
+    template<typename T, long n>
+    Array(T const (&a)[n]);
+
+  public:
+    //! Return the size of the array.
+    long size() const;
+
+    //! Return the element at the given index.
+    /*! \param index The index of the desired element.  The index may be
+     *  negative, to indicate an offset from the end of the array.  If the
+     *  index is out of bounds, this function has undefined behavior.
+     *  \return the element at the given index.
+     */
+    Object operator[](long index) const;
+
+    //! Converts a Ruby Array into a C++ array where the elements are
+    //! contiguous. This is similar to a std::vector, but instead a
+    //! std::unique_ptr<T> is returned. This allows the calling code to
+    //! pass ownership to its callers if needed (for exmaple, From_Ruby<T>#convert)
+    //! Note this method is designed convenience, not for speed or efficieny.
+    //! C++ APIs that take large chunks of memory should not be passed Ruby Arrrays.
+    //! \return std::unique_ptr that is owned by the caller.
+    template<typename T>
+    String pack();
+
+    // Join elements together
+    String join(const char* separator);
+
+  private:
+    //! A helper class so array[index]=value can work.
+    class Proxy;
+
+  public:
+    //! Return a reference to the element at the given index.
+    /*! \param index The index of the desired element.  The index may be
+     *  negative, to indicate an offset from the end of the array.  If the
+     *  index is out of bounds, this function has undefined behavior.
+     *  \return the element at the given index.
+     */
+    Proxy operator[](long index);
+
+    //! Push an element onto the end of the array
+    /*! \param v an object to push onto the array.
+     *  \return the object which was pushed onto the array.
+     */
+    template<typename T>
+    Object push(T obj);
+
+    //! Pop an element from the end of the array
+    /*! \return the object which was popped from the array, or Qnil if
+     *  the array was empty.
+     */
+    Object pop();
+
+    //! Unshift an element onto the beginning of the array
+    /*! \param v an object to unshift onto the array.
+     *  \return the object which was unshifted onto the array.
+     */
+    template<typename T>
+    Object unshift(T const& obj);
+
+    //! Shift an element from the beginning of the array
+    /*! \return the object which was shifted from the array.
+     */
+    Object shift();
+
+  private:
+    template<typename Array_Ptr_T, typename Value_T>
+    class Iterator;
+
+    long position_of(long index) const;
+
+  public:
+    //! An iterator.
+    typedef Iterator<Array*, Proxy> iterator;
+
+    //! A const iterator.
+    typedef Iterator<Array const*, Object> const_iterator;
+
+    //! Return an iterator to the beginning of the array.
+    iterator begin();
+
+    //! Return a const iterator to the beginning of the array.
+    const_iterator begin() const;
+
+    //! Return an iterator to the end of the array.
+    iterator end();
+
+    //! Return a const iterator to the end of the array.
+    const_iterator end() const;
+
+    //! Return the content of the array as a std::vector
+    template<typename T>
+    std::vector<T> to_vector();
+  };
+
+  //! A helper class so array[index]=value can work.
+  class Array::Proxy
+  {
+  public:
+    //! Construct a new Proxy
+    Proxy(Array array, long index);
+
+    //! Implicit conversions
+    operator Object() const;
+
+    //! Explicit conversion to VALUE.
+    VALUE value() const;
+
+    //! Assignment operator.
+    template<typename T>
+    Object operator=(T const& value);
+
+  private:
+    Array array_;
+    long index_;
+  };
+
+  //! A helper class for implementing iterators for a Array.
+  // TODO: This really should be a random-access iterator.
+  template<typename Array_Ptr_T, typename Value_T>
+  class Array::Iterator
+  {
+  public:
+    using iterator_category = std::forward_iterator_tag;
+    using value_type = Value_T;
+    using difference_type = long;
+    using pointer = Object*;
+    using reference = Value_T&;
+
+    Iterator(Array_Ptr_T array, long index);
+
+    template<typename Array_Ptr_T_, typename Value_T_>
+    Iterator(Iterator<Array_Ptr_T_, Value_T_> const& rhs);
+
+    template<typename Array_Ptr_T_, typename Value_T_>
+    Iterator& operator=(Iterator<Array_Ptr_T_, Value_T_> const& rhs);
+
+    Iterator& operator++();
+    Iterator operator++(int);
+    Value_T operator*();
+    Object* operator->();
+
+    template<typename Array_Ptr_T_, typename Value_T_>
+    bool operator==(Iterator<Array_Ptr_T_, Value_T_> const& rhs) const;
+
+    template<typename Array_Ptr_T_, typename Value_T_>
+    bool operator!=(Iterator<Array_Ptr_T_, Value_T_> const& rhs) const;
+
+    Array_Ptr_T array() const;
+    long index() const;
+
+  private:
+    Array_Ptr_T array_;
+    long index_;
+
+    Object tmp_;
+  };
+} // namespace Rice
+
+#endif // Rice__Array__hpp_