Hash.hpp

#ifndef Rice__Hash__hpp_
#define Rice__Hash__hpp_
 
#include "Builtin_Object_defn.hpp"
#include "Array.hpp"
#include "to_from_ruby_defn.hpp"
#include "detail/ruby.hpp"
#include <iterator>
#include <type_traits>
 
namespace Rice
{
 
class Hash
  : public Builtin_Object<T_HASH>
{
public:
  Hash();
 
 
  Hash(Object v);
 
  size_t size() const;
 
private:
  class Proxy;
 
public:
 
  template<typename Key_T>
  Proxy const operator[](Key_T const & key) const;
 
 
  template<typename Key_T>
  Proxy operator[](Key_T const & key);
 
 
  template<typename Value_T, typename Key_T>
  Value_T get(Key_T const & key);
 
  class Entry;
 
  template<typename Hash_Ref_T, typename Value_T>
  class Iterator;
 
public:
  typedef Iterator<Hash &, Entry> iterator;
 
  typedef Iterator<Hash const &, Entry const> const_iterator;
 
public:
  iterator begin();
 
  const_iterator begin() const;
 
  iterator end();
 
  const_iterator end() const;
};
 
class Hash::Proxy
{
public:
  Proxy(Hash hash, Object key);
 
  operator Object() const;
 
  VALUE value() const;
 
  template<typename T>
  Object operator=(T const & value);
 
  void swap(Proxy & proxy);
 
private:
  Hash hash_;
  Object key_;
};
 
 
class Hash::Entry
{
public:
  Entry(Hash hash, Object key);
 
  Entry(Entry const & entry);
 
  Object const key;          
  Object const & first;      
 
  Proxy value;              
  Proxy & second;           
 
  Entry & operator=(Entry const & rhs);
 
  void swap(Entry & entry);
 
  friend bool operator<(Entry const & lhs, Entry const & rhs);
};
 
bool operator<(Hash::Entry const & lhs, Hash::Entry const & rhs);
 
template<typename Hash_Ref_T, typename Value_T>
class Hash::Iterator
{
public:
  using iterator_category = std::input_iterator_tag;
  using value_type = Value_T;
  using difference_type = long;
  using pointer = Object*;
  using reference = Value_T&;
 
  Iterator(Hash_Ref_T hash);
 
  Iterator(Hash_Ref_T hash, int start_at);
 
  Iterator(Iterator const & iterator);
 
  template<typename Iterator_T>
  Iterator(Iterator_T const & iterator);
 
  Iterator & operator=(Iterator const & rhs);
 
  Iterator & operator++();
 
  Iterator operator++(int);
 
  Value_T operator*();
 
  Value_T * operator->();
 
  bool operator==(Iterator const & rhs) const;
 
  bool operator!=(Iterator const & rhs) const;
 
  template<typename Hash_Ref_T_, typename Value_T_>
  friend class Hash::Iterator;
 
  void swap(Iterator & iterator);
 
protected:
  Object current_key();
 
  Array hash_keys();
 
private:
  Hash hash_;
  size_t current_index_;
  VALUE keys_;
 
  mutable typename std::remove_const<Value_T>::type tmp_;
};
 
} // namespace Rice
 
template<>
inline
Rice::Hash from_ruby<Rice::Hash>(Rice::Object x)
{
  return Rice::Hash(x);
}
 
template<>
inline
Rice::Object to_ruby<Rice::Hash>(Rice::Hash const & x)
{
  return x;
}
 
#include "Hash.ipp"
 
#endif // Rice__Hash__hpp_