iter.hh

Go to the documentation of this file.

/* -*- C++ -*-
 * $Id: iter.hh 957 2005-03-07 16:01:20Z sjoyeux $
 */
#ifndef UTILMM_UTILS_HASH_ITER_HEADER
# define UTILMM_UTILS_HASH_ITER_HEADER

# include "utilmm/hash/bits/table_fwd.hh"

namespace utilmm {
  namespace hash_toolbox {
    
    template< typename Key, typename Value, class Extract,
              class Hash, class Equal >
    class iter;

    template< typename Key, typename Value, class Extract,
              class Hash, class Equal >
    class const_iter {
    public:
      typedef Value value_type;
      typedef value_type const *pointer; 
      typedef value_type const &reference;
      typedef size_t size_type;

      const_iter();
      const_iter(iter<Key, Value, Extract, Hash, Equal> const &other);

      bool operator==(const_iter const &other) const;
      bool operator!=(const_iter const &other) const;

      const_iter &operator+=(size_type delta);
      const_iter operator+ (size_type delta) const;

      const_iter &operator++();
      const_iter operator++(int);
      
      pointer operator->() const;
      reference operator* () const;

    private:
      typedef table<Key, Value, Extract, Hash, Equal> container_type;
      typedef typename container_type::node_type node_type;

      container_type const *owner;
      node_type const *current;

      const_iter(node_type const *, container_type const *);

      template<typename K, typename V, class Ex, class H, class Eq> 
      friend class table;
    }; // class utilmm::hash_toolbox::const_iter<>

    template<typename K, typename V, class Ex, class H, class Eq>
    const_iter<K, V, Ex, H, Eq> operator+ 
    (typename const_iter<K, V, Ex, H, Eq>::size_type d, 
     const_iter<K, V, Ex, H, Eq> const &i) {
      return i+d;
    }

    template< typename Key, typename Value, class Extract,
              class Hash, class Equal >
    class iter {
    public:
      typedef Value value_type;
      typedef value_type *pointer;
      typedef value_type &reference;
      typedef size_t size_type;

      iter();

      bool operator==(iter const &other) const;
      bool operator!=(iter const &other) const;

      iter &operator+=(size_type pos);
      iter operator+ (size_type pos) const;

      iter &operator++();
      iter operator++(int);
      
      pointer operator->() const;
      reference operator* () const;

    private:
      typedef table<Key, Value, Extract, Hash, Equal> container_type;
      typedef typename container_type::node_type node_type;

      container_type *owner;
      node_type *current;

      iter(node_type *, container_type *);

      template<typename K, typename V, class Ex, class H, class Eq> 
      friend class const_iter;

      template<typename K, typename V, class Ex, class H, class Eq> 
      friend class table;
    }; // class utilmm::hash_toolbox::iter<>

    template<typename K, typename V, class Ex, class H, class Eq>
    iter<K, V, Ex, H, Eq> operator+ 
    (typename iter<K, V, Ex, H, Eq>::size_type d, 
     iter<K, V, Ex, H, Eq> const &i) {
      return i+d;
    }

  } // namespace utilmm::hash_toolbox
} // namespace utilmm

# define IN_UTILMM_UTILS_HASH_ITER_HEADER
#  include "utilmm/hash/bits/iter.tcc"
# undef IN_UTILMM_UTILS_HASH_ITER_HEADER
#endif // UTILMM_UTILS_HASH_ITER_HEADER