Array.hpp

#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
{
 
 
class Array
  : public Builtin_Object<T_ARRAY>
{
public:
  Array();
 
 
  Array(Object v);
 
 
  Array(VALUE v);
 
 
  template<typename Iter_T>
  Array(Iter_T begin, Iter_T end);
 
 
  template<typename T, long n>
  Array(T const (& a)[n]);
 
public:
  long size() const;
 
 
  Object operator[](long index) const;
 
private:
  class Proxy;
 
public:
 
  Proxy operator[](long index);
 
 
  template<typename T>
  Object push(T const & obj);
 
 
  Object pop();
 
 
  template<typename T>
  Object unshift(T const & obj);
 
 
  Object shift();
 
private:
  template<typename Array_Ref_T, typename Value_T>
  class Iterator;
 
  long position_of(long index) const;
 
public:
  typedef Iterator<Array &, Proxy> iterator;
 
  typedef Iterator<Array const &, Object> const_iterator;
 
  iterator begin();
 
  const_iterator begin() const;
 
  iterator end();
 
  const_iterator end() const;
};
 
class Array::Proxy
{
public:
  Proxy(Array array, long index);
 
  operator Object() const;
 
  VALUE value() const;
 
  template<typename T>
  Object operator=(T const & value);
 
private:
  Array array_;
  long index_;
};
 
// TODO: This really should be a random-access iterator.
template<typename Array_Ref_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_Ref_T array, long 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;
  long index() const;
 
private:
  Array_Ref_T array_;
  long 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_