ruby_hash.hpp

#ifndef Exc_Ruby__ruby_hash__hpp_
#define Exc_Ruby__ruby_hash__hpp_

#ident "$Id$"

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

namespace Exc_Ruby
{

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

  Ruby_Hash(VALUE v);

  void freeze();

  size_t size() const;

private:
  class Proxy
  {
  public:
    Proxy(VALUE hash, VALUE key);
    operator VALUE() const;
    VALUE operator=(VALUE value);

  private:
    VALUE hash_;
    VALUE key_;
  };

public:
  Proxy const operator[](VALUE key) const;

  Proxy operator[](VALUE key);

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 hash, size_t index, st_table_entry * ptr);
    Iterator operator++();
    Ref_To_Value operator*();
    bool operator==(Iterator const & rhs);
    bool operator!=(Iterator const & rhs);

  private:
    T hash_;
    int i_;
    st_table_entry * ptr_;
  };

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

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

  iterator begin();

  const_iterator begin() const;

  iterator end();

  const_iterator end() const;
};

} // namespace Exc_Ruby

#include "ruby_hash.ipp"

#endif // Exc_Ruby__ruby_hash__hpp_

---