rice 4.5.0 → 4.6.0

data/rice/cpp_api/Array.ipp

@@ -0,0 +1,304 @@
+#ifndef Rice__Array__ipp_
+#define Rice__Array__ipp_
+
+namespace Rice
+{
+  inline Array::Array() : Builtin_Object<T_ARRAY>(detail::protect(rb_ary_new))
+  {
+  }
+
+  inline Array::Array(long capacity) : Builtin_Object<T_ARRAY>(detail::protect(rb_ary_new_capa, capacity))
+  {
+  }
+
+  inline Array::Array(Object v) : Builtin_Object<T_ARRAY>(v)
+  {
+  }
+
+  inline Array::Array(VALUE v) : Builtin_Object<T_ARRAY>(v)
+  {
+  }
+
+  template<typename Iter_T>
+  inline Array::Array(Iter_T it, Iter_T end) : Builtin_Object<T_ARRAY>(detail::protect(rb_ary_new))
+  {
+    for (; it != end; ++it)
+    {
+      push(*it);
+    }
+  }
+
+  template<typename T, long n>
+  inline Array::Array(T const (&a)[n]) : Builtin_Object<T_ARRAY>(detail::protect(rb_ary_new))
+  {
+    for (long j = 0; j < n; ++j)
+    {
+      push(a[j]);
+    }
+  }
+
+  inline long Array::size() const
+  {
+    return RARRAY_LEN(this->value());
+  }
+
+  inline String Array::join(const char* separator)
+  {
+    return this->call("join", separator);
+  }
+
+  template<typename T>
+  String Array::pack()
+  {
+    // Use .c_str so that the stl.hpp header is not required
+    return this->call("pack", detail::RubyType<T>::packTemplate.c_str());
+  }
+
+  inline Object Array::operator[](long index) const
+  {
+    return detail::protect(rb_ary_entry, value(), position_of(index));
+  }
+
+  inline Array::Proxy Array::operator[](long index)
+  {
+    return Proxy(*this, position_of(index));
+  }
+
+  template<typename T>
+  inline Object Array::push(T obj)
+  {
+    return detail::protect(rb_ary_push, value(), detail::To_Ruby<T>().convert(std::forward<T>(obj)));
+  }
+
+  inline Object Array::pop()
+  {
+    return detail::protect(rb_ary_pop, value());
+  }
+
+  template<typename T>
+  inline Object Array::unshift(T const& obj)
+  {
+    return detail::protect(rb_ary_unshift, value(), detail::To_Ruby<T>().convert(obj));
+  }
+
+  inline Object Array::shift()
+  {
+    return detail::protect(rb_ary_shift, value());
+  }
+
+  inline long Array::position_of(long index) const
+  {
+    if (index < 0)
+    {
+      return size() + index;
+    }
+    else
+    {
+      return static_cast<long>(index);
+    }
+  }
+
+  template<typename T>
+  std::vector<T> Array::to_vector()
+  {
+    std::vector<T> result;
+
+    long size = this->size();
+    result.reserve(size);
+
+    detail::From_Ruby<T> fromRuby;
+    for (long i = 0; i < size; i++)
+    {
+      VALUE element = detail::protect(rb_ary_entry, this->value(), i);
+      result.push_back(fromRuby.convert(element));
+    }
+
+    return result;
+  }
+
+  inline Array::Proxy::Proxy(Array array, long index)
+    : array_(array)
+    , index_(index)
+  {
+  }
+
+  inline VALUE Array::Proxy::value() const
+  {
+    return detail::protect(rb_ary_entry, array_.value(), index_);
+  }
+
+  inline Array::Proxy::operator Object() const
+  {
+    return Object(this->value());
+  }
+
+  template<typename T>
+  Object Array::Proxy::operator=(T const& value)
+  {
+    Object o = detail::To_Ruby<T>().convert(value);
+    detail::protect(rb_ary_store, array_.value(), index_, o.value());
+    return o;
+  }
+
+  template<typename Array_Ptr_T, typename Value_T>
+  inline Array::Iterator<Array_Ptr_T, Value_T>::Iterator(Array_Ptr_T array, long index) :
+    array_(array), index_(index)
+  {
+  }
+
+  template<typename Array_Ptr_T, typename Value_T>
+  template<typename Array_Ptr_T_, typename Value_T_>
+  inline
+    Array::Iterator<Array_Ptr_T, Value_T>::Iterator(Iterator<Array_Ptr_T_, Value_T_> const& rhs) :
+      array_(rhs.array()) , index_(rhs.index()), tmp_()
+  {
+  }
+
+  template<typename Array_Ptr_T, typename Value_T>
+  template<typename Array_Ptr_T_, typename Value_T_>
+  inline Array::Iterator<Array_Ptr_T, Value_T>& Array::Iterator<Array_Ptr_T, Value_T>::operator=(Iterator<Array_Ptr_T_, Value_T_> const& rhs)
+  {
+    array_ = rhs.array_;
+    index_ = rhs.index_;
+    return *this;
+  }
+
+  template<typename Array_Ptr_T, typename Value_T>
+  inline Array::Iterator<Array_Ptr_T, Value_T>& Array::Iterator<Array_Ptr_T, Value_T>::operator++()
+  {
+    ++index_;
+    return *this;
+  }
+
+  template<typename Array_Ptr_T, typename Value_T>
+  inline Array::Iterator<Array_Ptr_T, Value_T> Array::Iterator<Array_Ptr_T, Value_T>::operator++(int)
+  {
+    Array copy(*this);
+    ++(*this);
+    return *this;
+  }
+
+  template<typename Array_Ptr_T, typename Value_T>
+  inline Value_T Array::Iterator<Array_Ptr_T, Value_T>::operator*()
+  {
+    return (*array_)[index_];
+  }
+
+  template<typename Array_Ptr_T, typename Value_T>
+  inline Object* Array::Iterator<Array_Ptr_T, Value_T>::operator->()
+  {
+    tmp_ = (*array_)[index_];
+    return &tmp_;
+  }
+
+  template<typename Array_Ptr_T, typename Value_T>
+  template<typename Array_Ptr_T_, typename Value_T_>
+  inline bool Array::Iterator<Array_Ptr_T, Value_T>::operator==(Iterator<Array_Ptr_T_, Value_T_> const& rhs) const
+  {
+    return array_->value() == rhs.array_->value() && index_ == rhs.index_;
+  }
+
+  template<typename Array_Ptr_T, typename Value_T>
+  template<typename Array_Ptr_T_, typename Value_T_>
+  inline bool Array::Iterator<Array_Ptr_T, Value_T>::operator!=(Iterator<Array_Ptr_T_, Value_T_> const& rhs) const
+  {
+    return !(*this == rhs);
+  }
+
+  template<typename Array_Ptr_T, typename Value_T>
+  Array_Ptr_T Array::Iterator<Array_Ptr_T, Value_T>::array() const
+  {
+    return array_;
+  }
+
+  template<typename Array_Ptr_T, typename Value_T>
+  long Array::Iterator<Array_Ptr_T, Value_T>::index() const
+  {
+    return index_;
+  }
+
+  inline Array::iterator Array::begin()
+  {
+    return iterator(this, 0);
+  }
+
+  inline Array::const_iterator Array::begin() const
+  {
+    return const_iterator(this, 0);
+  }
+
+  inline Array::iterator Array::end()
+  {
+    return iterator(this, size());
+  }
+
+  inline Array::const_iterator Array::end() const
+  {
+    return const_iterator(this, size());
+  }
+}
+
+namespace Rice::detail
+{
+  template<>
+  struct Type<Array>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+  };
+
+  template<>
+  class To_Ruby<Array>
+  {
+  public:
+    VALUE convert(Array const& x)
+    {
+      return x.value();
+    }
+  };
+
+  template<>
+  class To_Ruby<Array&>
+  {
+  public:
+    VALUE convert(Array const& x)
+    {
+      return x.value();
+    }
+  };
+
+  template<>
+  class To_Ruby<Array*>
+  {
+  public:
+    VALUE convert(Array const* x)
+    {
+      return x->value();
+    }
+  };
+
+  template<>
+  class From_Ruby<Array>
+  {
+  public:
+    Convertible is_convertible(VALUE value)
+    {
+      switch (rb_type(value))
+      {
+        case RUBY_T_ARRAY:
+          return Convertible::Exact;
+          break;
+        default:
+          return Convertible::None;
+      }
+    }
+
+    Array convert(VALUE value)
+    {
+      return Array(value);
+    }
+  };
+}
+#endif // Rice__Array__ipp_

data/rice/cpp_api/Builtin_Object.hpp

@@ -0,0 +1,31 @@
+#ifndef Rice__Builtin_Object__hpp_
+#define Rice__Builtin_Object__hpp_
+
+namespace Rice
+{
+  //! A smartpointer-like wrapper for Ruby builtin objects.
+  /*! A builtin object is one of Ruby's internal types, e.g. RArray or
+   *  RString.  Every builtin type structure has a corresponding integer
+   *  type number (e.g T_ARRAY for RArray or T_STRING for RString).  This
+   *  class is a wrapper for those types of objects, primarily useful as a
+   *  base class for other wrapper classes like Array and Hash.
+   */
+  template<int Builtin_Type>
+  class Builtin_Object
+    : public Object
+  {
+  public:
+    //! Wrap an already allocated Ruby object.
+    /*! Checks to see if the object is an object of type Builtin_Type; a
+     *  C++ exception is thrown if this is not the case.
+     *  \param value the object to be wrapped.
+     */
+    Builtin_Object(Object value);
+
+    RObject& operator*() const; //!< Return a reference to obj_
+    RObject* operator->() const; //!< Return a pointer to obj_
+    RObject* get() const;       //!< Return a pointer to obj_
+  };
+} // namespace Rice
+
+#endif // Rice__Builtin_Object__hpp_

data/rice/cpp_api/Builtin_Object.ipp

@@ -0,0 +1,37 @@
+#include <algorithm>
+
+namespace Rice
+{
+  namespace detail
+  {
+    inline VALUE check_type(Object value, int type)
+    {
+      detail::protect(rb_check_type, value.value(), type);
+      return Qnil;
+    }
+  }
+
+  template<int Builtin_Type>
+  inline Builtin_Object<Builtin_Type>::Builtin_Object(Object value) : Object(value)
+  {
+    detail::check_type(value, Builtin_Type);
+  }
+
+  template<int Builtin_Type>
+  inline RObject& Builtin_Object<Builtin_Type>::operator*() const
+  {
+    return *ROBJECT(this->value());
+  }
+
+  template<int Builtin_Type>
+  inline RObject* Builtin_Object<Builtin_Type>::operator->() const
+  {
+    return ROBJECT(this->value());
+  }
+
+  template<int Builtin_Type>
+  inline RObject* Builtin_Object<Builtin_Type>::get() const
+  {
+    return ROBJECT(this->value());
+  }
+} // namespace Rice

data/rice/cpp_api/Class.hpp

@@ -0,0 +1,70 @@
+#ifndef Rice__Class__hpp_
+#define Rice__Class__hpp_
+
+/*!
+ *  \example inheritance/animals.cpp
+ *  \example callbacks/sample_callbacks.cpp
+ */
+
+namespace Rice
+{
+  //! A helper for defining a Class and its methods.
+  /*! This class provides a C++-style interface to ruby's Class class and
+   *  for defining methods on that class.
+   */
+  class Class: public Module
+  {
+  public:
+    //! Default construct a new class wrapper and initialize it to
+    //! rb_cObject.
+    Class() = default;
+
+    //! Construct a new class wrapper from a ruby object of type T_CLASS.
+    Class(VALUE v);
+
+    //! Disallow creation of an instance from Ruby code.
+    /*! Undefines the singleton method allocate (or new, if using a
+     *  version of ruby prior to 1.7) and the instance method initialize.
+     */
+    Class & undef_creation_funcs();
+
+    // Create a new instance
+    template<typename ...Arg_Ts>
+    Object create(Arg_Ts ...args);
+
+    //! Class name
+    /*! \return std::string.
+     */
+    const std::string name() const;
+
+    //! Base class name - does not include any parent modules
+    /*! \return std::string.
+     */
+    const std::string base_name() const;
+
+#include "shared_methods.hpp"
+  };
+
+  //! Define a new class in the namespace given by module.
+  /*! \param module the Module in which to define the class.
+   *  \param name the name of the class.
+   *  \param superclass the base class to use.
+   *  \return the new class.
+   */
+  Class define_class_under(Object parent, char const * name, const Class& superclass = rb_cObject);
+  Class define_class_under(Object parent, Identifier id, const Class& superclass = rb_cObject);
+
+  //! Define a new class in the default namespace.
+  /*! \param name the name of the class.
+   *  \param superclass the base class to use.
+   *  \return the new class.
+   */
+  Class define_class(char const * name, const Class& superclass = rb_cObject);
+
+  //! Create a new anonymous class.
+  /*! \return the new class.
+   */
+  Class anonymous_class();
+} // namespace Rice
+
+#endif // Rice__Class__hpp_

data/rice/cpp_api/Class.ipp

@@ -0,0 +1,97 @@
+
+namespace Rice
+{
+  inline Class::Class(VALUE value) : Module(value)
+  {
+    detail::protect(rb_check_type, value, (int)T_CLASS);
+  }
+
+  inline Class& Class::undef_creation_funcs()
+  {
+    detail::protect(rb_undef_alloc_func, value());
+    detail::protect(rb_undef_method, value(), "initialize");
+    return *this;
+  }
+
+  template<typename ...Arg_Ts>
+  inline Object Class::create(Arg_Ts ...args)
+  {
+    return this->call("new", args...);
+  }
+
+  inline const std::string Class::name() const
+  {
+    const char* buffer = rb_class2name(this->value());
+    return std::string(buffer);
+  }
+
+  inline const std::string Class::base_name() const
+  {
+    std::string name = this->name();
+    auto regex = std::regex("^.*::");
+    std::string result = std::regex_replace(name, regex, "");
+    return result;
+  }
+
+  inline Class define_class_under(Object parent, Identifier id, const Class& superclass)
+  {
+    VALUE klass = detail::protect(rb_define_class_id_under, parent.value(), id, superclass.value());
+
+    // We MUST reset the instance registry in case the user just redefined a class which resets it
+    detail::Registries::instance.natives.reset(klass);
+
+    return klass;
+  }
+
+  inline Class define_class_under(Object parent, char const* name, const Class& superclass)
+  {
+    Identifier id(name);
+    return define_class_under(parent, id, superclass);
+  }
+
+  inline Class define_class(char const* name, const Class& superclass)
+  {
+    VALUE klass = detail::protect(rb_define_class, name, superclass.value());
+
+    // We MUST reset the instance registry in case the user just redefined a class which resets it
+    detail::Registries::instance.natives.reset(klass);
+
+    return klass;
+  }
+
+  inline Class anonymous_class()
+  {
+    VALUE klass = detail::protect(rb_class_new, rb_cObject);
+    VALUE singleton = detail::protect(rb_singleton_class, klass);
+
+    // Ruby will reuse addresses previously assigned to other modules
+    // that have subsequently been garbage collected
+    detail::Registries::instance.natives.reset(klass);
+    detail::Registries::instance.natives.reset(singleton);
+
+    return klass;
+  }
+}
+
+namespace Rice::detail
+{
+  template<>
+  class To_Ruby<Class>
+  {
+  public:
+    static VALUE convert(Class const& x)
+    {
+      return x.value();
+    }
+  };
+
+  template<>
+  class From_Ruby<Class>
+  {
+  public:
+    Class convert(VALUE value)
+    {
+      return Class(value);
+    }
+  };
+}

data/rice/cpp_api/Encoding.hpp

@@ -0,0 +1,32 @@
+#ifndef Rice__Encoding__hpp_
+#define Rice__Encoding__hpp_
+
+namespace Rice
+{
+  //! A wrapper for a Ruby encoding
+  class Encoding
+  {
+  public:
+    static Encoding utf8();
+
+    //! Wrap an existing encoding.
+    Encoding(rb_encoding* encoding);
+
+    //! Implicit conversion to VALUE.
+    operator rb_encoding* () const
+    {
+      return this->encoding_;
+    }
+
+    operator VALUE () const
+    {
+      return detail::protect(rb_enc_from_encoding, this->encoding_);
+    }
+
+  private:
+    rb_encoding* encoding_;
+  };
+} // namespace Rice
+
+#endif // Rice__Encoding__hpp_
+

data/rice/cpp_api/Encoding.ipp

@@ -0,0 +1,59 @@
+namespace Rice
+{
+  inline Encoding Encoding::utf8()
+  {
+    return Encoding(rb_utf8_encoding());
+  }
+
+  inline Encoding::Encoding(rb_encoding* encoding) : encoding_(encoding)
+  {
+  }
+}
+
+/*namespace Rice::detail
+{
+  template<>
+  struct Type<Encoding>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+  };
+  
+  template<>
+  class To_Ruby<Encoding>
+  {
+  public:
+    VALUE convert(const Encoding& encoding)
+    {
+    //  return x.value();
+    }
+  };
+
+  template<>
+  class From_Ruby<Encoding>
+  {
+  public:
+    Convertible is_convertible(VALUE value)
+    {
+      switch (rb_type(value))
+      {
+        case RUBY_T_SYMBOL:
+          return Convertible::Exact;
+          break;
+      case RUBY_T_STRING:
+          return Convertible::Cast;
+          break;
+        default:
+          return Convertible::None;
+        }
+    }
+
+    Encoding convert(VALUE value)
+    {
+     // return Symbol(value);
+    }
+  };
+}
+*/