rice 2.1.2 → 4.0.1

data/rice/Hash.hpp

@@ -1,227 +0,0 @@
-#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 "detail/traits.hpp"
-#include <iterator>
-
-namespace Rice
-{
-
-//! A wrapper for the ruby Hash class.
-//! This class provides a C++-style interface to ruby's Hash class and
-//! its associated rb_hash_* functions.
-//! Example:
-//! \code
-//!   Hash h;
-//!   h[42] = String("foo");
-//!   h[10] = String("bar");
-//!   std::cout << String(h[42]) << std::endl;
-//! \endcode
-class Hash
-  : public Builtin_Object<T_HASH>
-{
-public:
-  //! Construct a new hash.
-  Hash();
-
-  //! Wrap an existing hash.
-  /*! \param v the hash to wrap.
-   */
-  Hash(Object v);
-
-  //! Return the number of elements in the hash.
-  size_t size() const;
-
-private:
-  //! A helper class so hash[key]=value can work.
-  class Proxy;
-
-public:
-  //! Get the value for the given key.
-  /*! \param key the key whose value should be retrieved from the hash.
-   *  \return the value associated with the given key.
-   */
-  template<typename Key_T>
-  Proxy const operator[](Key_T const & key) const;
-
-  //! Get the value for the given key.
-  /*! \param key the key whose value should be retrieved from the hash.
-   *  \return the value associated with the given key.
-   */
-  template<typename Key_T>
-  Proxy operator[](Key_T const & key);
-
-  //! Get the value for the given key
-  /*! The returned value is converted to the type given by Value_T.
-   *  \param key the key whose value should be retrieved from the hash.
-   *  \return the value associated with the given key, converted to C++
-   *  type Value_T.
-   */
-  template<typename Value_T, typename Key_T>
-  Value_T get(Key_T const & key);
-
-  //! A helper class for dereferencing iterators
-  class Entry;
-
-  //! A helper class for implementing iterators for a Hash.
-  template<typename Hash_Ref_T, typename Value_T>
-  class Iterator;
-
-public:
-  //! An iterator.
-  typedef Iterator<Hash &, Entry> iterator;
-
-  //! A const iterator.
-  typedef Iterator<Hash const &, Entry const> const_iterator;
-
-public:
-  //! Return an iterator to the beginning of the hash.
-  iterator begin();
-
-  //! Return a const iterator to the beginning of the hash.
-  const_iterator begin() const;
-
-  //! Return an iterator to the end of the hash.
-  iterator end();
-
-  //! Return a const to the end of the hash.
-  const_iterator end() const;
-};
-
-//! A helper class so hash[key]=value can work.
-class Hash::Proxy
-{
-public:
-  //! Construct a new Proxy.
-  Proxy(Hash hash, Object key);
-
-  //! Implicit conversion to Object.
-  operator Object() const;
-
-  //! Explicit conversion to VALUE.
-  VALUE value() const;
-
-  //! Assignment operator.
-  template<typename T>
-  Object operator=(T const & value);
-
-  void swap(Proxy & proxy);
-
-private:
-  Hash hash_;
-  Object key_;
-};
-
-//! A helper class for dereferencing iterators
-/*! This class is intended to look similar to an std::pair.
- */
-class Hash::Entry
-{
-public:
-  //! Construct a new Entry.
-  Entry(Hash hash, Object key);
-
-  //! Copy constructor.
-  Entry(Entry const & entry);
-
-  Object const key;          //!< The key
-  Object const & first;      //!< An alias for the key
-
-  Proxy value;              //!< The value
-  Proxy & second;           //!< An alias for the value
-
-  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);
-
-//! A helper class for implementing iterators for a Hash.
-template<typename Hash_Ref_T, typename Value_T>
-class Hash::Iterator
-  : public std::iterator<
-      std::input_iterator_tag,
-      Value_T>
-{
-public:
-  //! Construct a new Iterator.
-  Iterator(Hash_Ref_T hash);
-
-  //! Construct a new Iterator with a given start-at index point
-  Iterator(Hash_Ref_T hash, int start_at);
-
-  //! Copy construct an Iterator.
-  Iterator(Iterator const & iterator);
-
-  //! Construct an Iterator from another Iterator of a different const
-  //! qualification.
-  template<typename Iterator_T>
-  Iterator(Iterator_T const & iterator);
-
-  //! Assignment operator.
-  Iterator & operator=(Iterator const & rhs);
-
-  //! Preincrement operator.
-  Iterator & operator++();
-
-  //! Postincrement operator.
-  Iterator operator++(int);
-
-  //! Dereference operator.
-  Value_T operator*();
-
-  //! Dereference operator.
-  Value_T * operator->();
-
-  //! Equality operator.
-  bool operator==(Iterator const & rhs) const;
-
-  //! Inequality operator.
-  bool operator!=(Iterator const & rhs) const;
-
-  template<typename Hash_Ref_T_, typename Value_T_>
-  friend class Hash::Iterator;
-
-  //! Swap with another iterator of the same type.
-  void swap(Iterator & iterator);
-
-protected:
-  Object current_key();
-
-  Array hash_keys();
-
-private:
-  Hash hash_;
-  size_t current_index_;
-  VALUE keys_;
-
-  mutable typename detail::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_
-

data/rice/Hash.ipp

@@ -1,329 +0,0 @@
-#ifndef Rice__Hash__ipp_
-#define Rice__Hash__ipp_
-
-#include "protect.hpp"
-#include "to_from_ruby.hpp"
-#include "Exception.hpp"
-#include "Builtin_Object.hpp"
-#include "detail/st.hpp"
-#include <algorithm>
-
-inline Rice::Hash::
-Hash()
-  : Builtin_Object<T_HASH>(protect(rb_hash_new))
-{
-}
-
-inline Rice::Hash::
-Hash(Object v)
-  : Builtin_Object<T_HASH>(v)
-{
-}
-
-inline size_t Rice::Hash::
-size() const
-{
-  return RHASH_SIZE(this->value());
-}
-
-inline Rice::Hash::Proxy::
-Proxy(Hash hash, Object key)
-  : hash_(hash)
-  , key_(key)
-{
-}
-
-/*
-inline Rice::Hash::Proxy::
-operator VALUE() const
-{
-  return value();
-}
-*/
-
-inline Rice::Hash::Proxy::
-operator Rice::Object() const
-{
-  return value();
-}
-
-inline VALUE Rice::Hash::Proxy::
-value() const
-{
-  return protect(rb_hash_aref, hash_, key_);
-}
-
-template<typename T>
-inline Rice::Object Rice::Hash::Proxy::
-operator=(T const & value)
-{
-  return protect(rb_hash_aset, hash_, key_, to_ruby(value));
-}
-
-inline void Rice::Hash::Proxy::
-swap(Proxy & proxy)
-{
-  hash_.swap(proxy.hash_);
-  key_.swap(proxy.key_);
-}
-
-template<typename Key_T>
-inline Rice::Hash::Proxy const Rice::Hash::
-operator[](Key_T const & key) const
-{
-  return Proxy(*this, to_ruby(key));
-}
-
-template<typename Key_T>
-inline Rice::Hash::Proxy Rice::Hash::
-operator[](Key_T const & key)
-{
-  return Proxy(*this, to_ruby(key));
-}
-
-template<typename Value_T, typename Key_T>
-inline Value_T Rice::Hash::
-get(Key_T const & key)
-{
-  Object ruby_key(to_ruby(key));
-  Object value = operator[](ruby_key);
-  try
-  {
-    return from_ruby<Value_T>(value);
-  }
-  catch(Exception const & ex)
-  {
-    String s_key(ruby_key.to_s());
-    throw Exception(
-        ex,
-        "%s while converting value for key %s",
-        ex.what(),
-        s_key.c_str());
-  }
-}
-
-inline Rice::Hash::Entry::
-Entry(Hash hash, Object key)
-  : key(key)
-  , first(Hash::Entry::key)
-  , value(hash, key)
-  , second(Hash::Entry::value)
-{
-}
-
-inline Rice::Hash::Entry::
-Entry(Entry const & entry)
-  : key(entry.key)
-  , first(Hash::Entry::key)
-  , value(entry.value)
-  , second(Hash::Entry::value)
-{
-}
-
-inline Rice::Hash::Entry & Rice::Hash::Entry::
-operator=(Rice::Hash::Entry const & rhs)
-{
-  Entry tmp(rhs);
-  swap(tmp);
-  return *this;
-}
-
-inline void Rice::Hash::Entry::
-swap(Rice::Hash::Entry & entry)
-{
-  const_cast<Object &>(key).swap(const_cast<Object &>(entry.key));
-  value.swap(entry.value);
-}
-
-template<typename Hash_Ref_T, typename Value_T>
-inline Rice::Hash::Iterator<Hash_Ref_T, Value_T>::
-Iterator(Hash_Ref_T hash)
-  : hash_(hash)
-  , current_index_(0)
-  , keys_(Qnil)
-  , tmp_(hash, Qnil)
-{
-}
-
-template<typename Hash_Ref_T, typename Value_T>
-inline Rice::Hash::Iterator<Hash_Ref_T, Value_T>::
-Iterator(Hash_Ref_T hash, int start_at)
-  : hash_(hash)
-  , current_index_(start_at)
-  , keys_(Qnil)
-  , tmp_(hash, Qnil)
-{
-}
-
-template<typename Hash_Ref_T, typename Value_T>
-inline Rice::Hash::Iterator<Hash_Ref_T, Value_T>::
-Iterator(Iterator const & iterator)
-  : hash_(iterator.hash_.value())
-  , current_index_(iterator.current_index_)
-  , keys_(Qnil)
-  , tmp_(iterator.hash_, Qnil)
-{
-}
-
-template<typename Hash_Ref_T, typename Value_T>
-template<typename Iterator_T>
-inline Rice::Hash::Iterator<Hash_Ref_T, Value_T>::
-Iterator(Iterator_T const & iterator)
-  : hash_(iterator.hash_.value())
-  , current_index_(iterator.current_index_)
-  , keys_(Qnil)
-  , tmp_(iterator.hash_, Qnil)
-{
-}
-
-template<typename Hash_Ref_T, typename Value_T>
-inline Rice::Hash::Iterator<Hash_Ref_T, Value_T> &
-Rice::Hash::Iterator<Hash_Ref_T, Value_T>::
-operator=(Iterator const & iterator)
-{
-  Iterator tmp(iterator);
-
-  this->swap(tmp);
-
-  return *this;
-}
-
-template<typename Hash_Ref_T, typename Value_T>
-inline Rice::Hash::Iterator<Hash_Ref_T, Value_T> &
-Rice::Hash::Iterator<Hash_Ref_T, Value_T>::
-operator++()
-{
-  // Ensure we're within the range
-  if(current_index_ < hash_keys().size()) {
-    current_index_++;
-  }
-
-  return *this;
-}
-
-template<typename Hash_Ref_T, typename Value_T>
-inline Rice::Hash::Iterator<Hash_Ref_T, Value_T>
-Rice::Hash::Iterator<Hash_Ref_T, Value_T>::
-operator++(int)
-{
-  Iterator copy(*this);
-  ++(*this);
-  return copy;
-}
-
-template<typename Hash_Ref_T, typename Value_T>
-inline Value_T
-Rice::Hash::Iterator<Hash_Ref_T, Value_T>::
-operator*()
-{
-  return Value_T(hash_, current_key());
-}
-
-template<typename Hash_Ref_T, typename Value_T>
-inline Value_T *
-Rice::Hash::Iterator<Hash_Ref_T, Value_T>::
-operator->()
-{
-  Entry tmp(hash_, current_key());
-  this->tmp_.swap(tmp);
-  return &tmp_;
-}
-
-template<typename Hash_Ref_T, typename Value_T>
-inline bool Rice::Hash::Iterator<Hash_Ref_T, Value_T>::
-operator==(Iterator const & rhs) const
-{
-  return hash_.value() == rhs.hash_.value()
-    && current_index_ == rhs.current_index_;
-}
-
-template<typename Hash_Ref_T, typename Value_T>
-inline bool Rice::Hash::Iterator<Hash_Ref_T, Value_T>::
-operator!=(Iterator const & rhs) const
-{
-  return !(*this == rhs);
-}
-
-template<typename Hash_Ref_T, typename Value_T>
-inline void
-Rice::Hash::Iterator<Hash_Ref_T, Value_T>::
-swap(Iterator& iterator)
-{
-  using namespace std;
-
-  hash_.swap(iterator.hash_);
-  swap(keys_, iterator.keys_);
-  swap(current_index_, iterator.current_index_);
-}
-
-template<typename Hash_Ref_T, typename Value_T>
-inline Rice::Object
-Rice::Hash::Iterator<Hash_Ref_T, Value_T>::
-current_key()
-{
-  return hash_keys()[current_index_];
-}
-
-
-template<typename Hash_Ref_T, typename Value_T>
-inline Rice::Array
-Rice::Hash::Iterator<Hash_Ref_T, Value_T>::
-hash_keys()
-{
-  if(NIL_P(keys_)) {
-    keys_ = rb_funcall(hash_, rb_intern("keys"), 0, 0);
-  }
-
-  return Rice::Array(keys_);
-}
-
-inline Rice::Hash::iterator Rice::Hash::
-begin()
-{
-  return iterator(*this);
-}
-
-inline Rice::Hash::const_iterator Rice::Hash::
-begin() const
-{
-  return const_iterator(*this);
-}
-
-inline Rice::Hash::iterator Rice::Hash::
-end()
-{
-  return iterator(*this, (int)size());
-}
-
-inline Rice::Hash::const_iterator Rice::Hash::
-end() const
-{
-  return const_iterator(*this, (int)size());
-}
-
-inline bool Rice::
-operator<(
-    Hash::Entry const & lhs, Hash::Entry const & rhs)
-{
-  Object lhs_key(lhs.key);
-  Object rhs_key(rhs.key);
-  if(lhs_key < rhs_key)
-  {
-    return true;
-  }
-  else if(lhs_key > rhs_key)
-  {
-    return false;
-  }
-  else if(Object(lhs.value.value()) < Object(rhs.value.value()))
-  {
-    return true;
-  }
-  else
-  {
-    return false;
-  }
-}
-
-#endif // Rice__Hash__ipp_
-