rice2 2.2.0

data/rice/Arg_operators.cpp

@@ -0,0 +1,21 @@
+#include "Arg_impl.hpp"
+#include "detail/Arguments.hpp"
+#include "Arg_operators.hpp"
+
+namespace Rice {
+
+  Arguments* operator,(Arg arg1, Arg arg2)
+  {
+    Arguments* a = new Arguments();
+    a->add(arg1);
+    a->add(arg2);
+    return a;
+  }
+
+  Arguments* operator,(Arguments* arguments, Arg arg)
+  {
+    arguments->add(arg);
+    return arguments;
+  }
+
+}

data/rice/Arg_operators.hpp

@@ -0,0 +1,19 @@
+#ifndef Rice__Arg_Operators_hpp_
+#define Rice__Arg_Operators_hpp_
+
+namespace Rice
+{
+
+  //! Build the list of Arg objects into an Arguments object
+  /*! Take a list of Arg objects and build up a single Argument
+   *  object used later in method dispatch
+   */
+  Arguments* operator,(Arg arg1, Arg arg2);
+
+  /*! @see operator,(Arg, Arg)
+   */
+  Arguments* operator,(Arguments* arguments, Arg arg);
+
+}
+
+#endif // Rice__Arg_Operators_hpp_

data/rice/Array.hpp

@@ -0,0 +1,214 @@
+#ifndef Rice__Array__hpp_
+#define Rice__Array__hpp_
+
+#include "Builtin_Object.hpp"
+#include "to_from_ruby_defn.hpp"
+#include "detail/ruby.hpp"
+#include <iterator>
+
+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();
+
+  //! 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, size_t n>
+  Array(T const (& a)[n]);
+
+public:
+  //! Return the size of the array.
+  size_t 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[](ptrdiff_t index) const;
+
+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[](ptrdiff_t 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 const & 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_Ref_T, typename Value_T>
+  class Iterator;
+
+  size_t position_of(ptrdiff_t 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;
+};
+
+//! A helper class so array[index]=value can work.
+class Array::Proxy
+{
+public:
+  //! Construct a new Proxy
+  Proxy(Array array, size_t index);
+
+  //! Implicit conversion to Object.
+  operator Object() const;
+
+  //! Explicit conversion to VALUE.
+  VALUE value() const;
+
+  //! Assignment operator.
+  template<typename T>
+  Object operator=(T const & value);
+
+private:
+  Array array_;
+  size_t index_;
+};
+
+//! A helper class for implementing iterators for a Array.
+// TODO: This really should be a random-access iterator.
+template<typename Array_Ref_T, typename Value_T>
+class Array::Iterator
+  : public std::iterator<
+      std::forward_iterator_tag,
+      Value_T,            // Type
+      ptrdiff_t,          // Distance type
+      Object *,           // Pointer type
+      Value_T &>          // Reference type
+{
+public:
+  Iterator(Array_Ref_T array, size_t index);
+
+  template<typename Array_Ref_T_, typename Value_T_>
+  Iterator(Iterator<Array_Ref_T_, Value_T_> const & rhs);
+
+  template<typename Array_Ref_T_, typename Value_T_>
+  Iterator & operator=(Iterator<Array_Ref_T_, Value_T_> const & rhs);
+
+  Iterator & operator++();
+  Iterator operator++(int);
+  Value_T operator*();
+  Object * operator->();
+
+  template<typename Array_Ref_T_, typename Value_T_>
+  bool operator==(Iterator<Array_Ref_T_, Value_T_> const & rhs) const;
+
+  template<typename Array_Ref_T_, typename Value_T_>
+  bool operator!=(Iterator<Array_Ref_T_, Value_T_> const & rhs) const;
+
+  // Causes ICE on g++ 3.3.3
+  // template<typename Array_Ref_T_, typename Value_T_>
+  // friend class Iterator;
+
+  Array_Ref_T array() const;
+  size_t index() const;
+
+private:
+  Array_Ref_T array_;
+  size_t index_;
+
+  Object tmp_;
+};
+
+} // namespace Rice
+
+template<>
+inline
+Rice::Array from_ruby<Rice::Array>(Rice::Object x)
+{
+  return Rice::Array(x);
+}
+
+template<>
+inline
+Rice::Object to_ruby<Rice::Array>(Rice::Array const & x)
+{
+  return x;
+}
+
+#include "Array.ipp"
+
+#endif // Rice__Array__hpp_
+

data/rice/Array.ipp

@@ -0,0 +1,256 @@
+#ifndef Rice__Array__ipp_
+#define Rice__Array__ipp_
+
+#include "protect.hpp"
+
+inline Rice::Array::
+Array()
+  : Builtin_Object<T_ARRAY>(protect(rb_ary_new))
+{
+}
+
+inline Rice::Array::
+Array(Object v)
+  : Builtin_Object<T_ARRAY>(v)
+{
+}
+
+inline Rice::Array::
+Array(VALUE v)
+  : Builtin_Object<T_ARRAY>(v)
+{
+}
+
+template<typename Iter_T>
+inline Rice::Array::
+Array(Iter_T it, Iter_T end)
+  : Builtin_Object<T_ARRAY>(protect(rb_ary_new))
+{
+  for(; it != end; ++it)
+  {
+    push(*it);
+  }
+}
+
+template<typename T, size_t n>
+inline Rice::Array::
+Array(T const (& a)[n])
+  : Builtin_Object<T_ARRAY>(protect(rb_ary_new))
+{
+  for(size_t j = 0; j < n; ++j)
+  {
+    push(a[j]);
+  }
+}
+
+inline size_t Rice::Array::
+size() const
+{
+  return RARRAY_LEN(this->value());
+}
+
+inline Rice::Object Rice::Array::
+operator[](ptrdiff_t index) const
+{
+  return protect(rb_ary_entry, value(), position_of(index));
+}
+
+inline Rice::Array::Proxy Rice::Array::
+operator[](ptrdiff_t index)
+{
+  return Proxy(*this, position_of(index));
+}
+
+template<typename T>
+inline Rice::Object Rice::Array::
+push(T const & obj)
+{
+  return protect(rb_ary_push, value(), to_ruby(obj));
+}
+
+inline Rice::Object Rice::Array::
+pop()
+{
+  return protect(rb_ary_pop, value());
+}
+
+template<typename T>
+inline Rice::Object Rice::Array::
+unshift(T const & obj)
+{
+  return protect(rb_ary_unshift, value(), to_ruby(obj));
+}
+
+inline Rice::Object Rice::Array::
+shift()
+{
+  return protect(rb_ary_shift, value());
+}
+
+inline size_t Rice::Array::
+position_of(ptrdiff_t index) const
+{
+  if(index < 0)
+  {
+    return size() + index;
+  }
+  else
+  {
+    return static_cast<size_t>(index);
+  }
+}
+
+inline Rice::Array::Proxy::
+Proxy(Array array, size_t index)
+  : array_(array)
+  , index_(index)
+{
+}
+
+inline Rice::Array::Proxy::
+operator Rice::Object() const
+{
+  return protect(rb_ary_entry, array_.value(), index_);
+}
+
+inline VALUE Rice::Array::Proxy::
+value() const
+{
+  return protect(rb_ary_entry, array_.value(), index_);
+}
+
+template<typename T>
+Rice::Object Rice::Array::Proxy::
+operator=(T const & value)
+{
+  Object o = to_ruby(value);
+  rb_ary_store(array_.value(), index_, o.value());
+  return o;
+}
+
+template<typename Array_Ref_T, typename Value_T>
+inline Rice::Array::Iterator<Array_Ref_T, Value_T>::
+Iterator(Array_Ref_T array, size_t index)
+  : array_(array)
+  , index_(index)
+{
+}
+
+template<typename Array_Ref_T, typename Value_T>
+template<typename Array_Ref_T_, typename Value_T_>
+inline
+Rice::Array::Iterator<Array_Ref_T, Value_T>::
+Iterator(Iterator<Array_Ref_T_, Value_T_> const & rhs)
+  : array_(rhs.array())
+  , index_(rhs.index())
+  , tmp_()
+{
+}
+
+template<typename Array_Ref_T, typename Value_T>
+template<typename Array_Ref_T_, typename Value_T_>
+inline Rice::Array::Iterator<Array_Ref_T, Value_T> &
+Rice::Array::Iterator<Array_Ref_T, Value_T>::
+operator=(Iterator<Array_Ref_T_, Value_T_> const & rhs)
+{
+  array_ = rhs.array_;
+  index_ = rhs.index_;
+  return *this;
+}
+
+template<typename Array_Ref_T, typename Value_T>
+inline Rice::Array::Iterator<Array_Ref_T, Value_T> &
+Rice::Array::Iterator<Array_Ref_T, Value_T>::
+operator++()
+{
+  ++index_;
+  return *this;
+}
+
+template<typename Array_Ref_T, typename Value_T>
+inline Rice::Array::Iterator<Array_Ref_T, Value_T>
+Rice::Array::Iterator<Array_Ref_T, Value_T>::
+operator++(int)
+{
+  Array copy(*this);
+  ++(*this);
+  return *this;
+}
+
+template<typename Array_Ref_T, typename Value_T>
+inline Value_T
+Rice::Array::Iterator<Array_Ref_T, Value_T>::
+operator*()
+{
+  return array_[index_];
+}
+
+template<typename Array_Ref_T, typename Value_T>
+inline Rice::Object *
+Rice::Array::Iterator<Array_Ref_T, Value_T>::
+operator->()
+{
+  tmp_ = array_[index_];
+  return &tmp_;
+}
+
+template<typename Array_Ref_T, typename Value_T>
+template<typename Array_Ref_T_, typename Value_T_>
+inline bool
+Rice::Array::Iterator<Array_Ref_T, Value_T>::
+operator==(Iterator<Array_Ref_T_, Value_T_> const & rhs) const
+{
+  return array_.value() == rhs.array_.value() && index_ == rhs.index_;
+}
+
+template<typename Array_Ref_T, typename Value_T>
+template<typename Array_Ref_T_, typename Value_T_>
+inline bool
+Rice::Array::Iterator<Array_Ref_T, Value_T>::
+operator!=(Iterator<Array_Ref_T_, Value_T_> const & rhs) const
+{
+  return !(*this == rhs);
+}
+
+template<typename Array_Ref_T, typename Value_T>
+Array_Ref_T
+Rice::Array::Iterator<Array_Ref_T, Value_T>::
+array() const
+{
+  return array_;
+}
+
+template<typename Array_Ref_T, typename Value_T>
+size_t
+Rice::Array::Iterator<Array_Ref_T, Value_T>::
+index() const
+{
+  return index_;
+}
+
+inline Rice::Array::iterator Rice::Array::
+begin()
+{
+  return iterator(*this, 0);
+}
+
+inline Rice::Array::const_iterator Rice::Array::
+begin() const
+{
+  return const_iterator(*this, 0);
+}
+
+inline Rice::Array::iterator Rice::Array::
+end()
+{
+  return iterator(*this, size());
+}
+
+inline Rice::Array::const_iterator Rice::Array::
+end() const
+{
+  return const_iterator(*this, size());
+}
+
+#endif // Rice__Array__ipp_
+