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