DeepIterator.h

Go to the documentation of this file.

#ifndef MADARA_DEEPITERATOR_H
#define MADARA_DEEPITERATOR_H

template<class T>
struct TypeHelper {
  typedef void type;
};

template<class T, class U = void, class V = void>
struct IteratorTraits;/* If error here: invalid type passed to deep_iterate() */

template<class T, class V>
struct IteratorTraits<T,
    typename TypeHelper<typename T::value_type>::type, V > {
  enum { is_pair = 0 };

  typedef typename T::value_type value_type;

  static value_type get_deep_copy(const T& i) {
    return value_type(i->deep_copy());
  }
};

template<class T>
struct IteratorTraits<T,
    typename TypeHelper<typename T::value_type>::type,
    typename TypeHelper<typename T::value_type::second_type>::type
  > {
  enum { is_pair = 1 };

  typedef std::pair<const typename T::value_type::first_type &,
                  typename T::value_type::second_type>
        value_type;

  static value_type get_deep_copy(const T& i) {
    return value_type(i->first, i->second.deep_copy());
  }
};

template<class Iterator>
class DeepIterator :
  public std::iterator<std::input_iterator_tag,
                       typename IteratorTraits<Iterator>::value_type>
{
private:
  typedef IteratorTraits<Iterator> traits;

public:
  typedef typename DeepIterator::value_type value_type;
  typedef typename Iterator::value_type underlying_value_type;

  value_type operator*() const
  {
    return traits::get_deep_copy(i_);
  }

  underlying_value_type *operator->() const
  {
    return i_.operator->();
  }

  DeepIterator &operator++()
  {
    ++i_;
    return *this;
  }

  DeepIterator operator++(int)
  {
    DeepIterator<Iterator> ret(*this);
    ++i_;
    return *this;
  }

  bool operator==(const DeepIterator &o) const
  {
    return i_ == o.i_;
  }

  bool operator!=(const DeepIterator &o) const
  {
    return i_ != o.i_;
  }

private:
  DeepIterator(const Iterator &i) : i_(i) {}

  Iterator i_;

  template<class I>
  friend DeepIterator<I> deep_iterate(const I &i);
};

template<class Iterator>
DeepIterator<Iterator> deep_iterate(const Iterator &i)
{
  return DeepIterator<Iterator>(i);
}

#endif