ruby_array.hpp

#ifndef Exc_Ruby__ruby_array__hpp_
#define Exc_Ruby__ruby_array__hpp_

#ident "$Id$"

#include "../ruby_reference.hpp"
#include "../detail/ruby_hacks.hpp"
#include <iterator>

namespace Exc_Ruby
{

// TODO: For now, we throw only ruby exceptions, but this should be
// configurable.
class Ruby_Array
  : public Ruby_Reference<
      RArray, 
      Exception_Safe_Builtin_Wrapper<RArray, T_ARRAY> >
{
public:
  Ruby_Array();

  Ruby_Array(VALUE v);

  void freeze();

public:
  size_t size() const;

  VALUE operator[](ssize_t index) const;

  VALUE & operator[](ssize_t index);

  VALUE to_s() const;

  VALUE push(VALUE v);

  VALUE pop();

  VALUE unshift(VALUE v);

  VALUE shift();

  VALUE * to_c_array();

private:
  // TODO: This really should be a random-access iterator.
  template<typename T, typename Ptr_To_Value, typename Ref_To_Value>
  class Iterator
    : public std::iterator<
        std::forward_iterator_tag,
        VALUE,
        Ptr_To_Value,
        Ref_To_Value>
  {
  public:
    Iterator(T array, size_t index);
    Iterator operator++();
    Ref_To_Value operator*();
    bool operator==(Iterator const & rhs);
    bool operator!=(Iterator const & rhs);

  private:
    T array_;
    size_t index_;
  };

public:
  typedef Iterator<Ruby_Array &, VALUE *, VALUE &> iterator;

  typedef Iterator<Ruby_Array const &, VALUE const *, VALUE const &> const_iterator;

  iterator begin();

  const_iterator begin() const;

  iterator end();

  const_iterator end() const;
};

} // namespace Exc_Ruby

#include "ruby_array.ipp"

#endif // Exc_Ruby__ruby_array__hpp_

---