NestedIterator.h

Go to the documentation of this file.

#ifndef NESTEDITERATOR_H
#define NESTEDITERATOR_H

// interface include
#include <type_traits> // std::true_type, std::false_type, std::conditional
#include <iterator> // std::forward_iterator_tag

namespace lar {
  
  namespace details {
    namespace type_traits {
    
      //------------------------------------------------------------------------
      // declarations of helpers for has_const_iterator() function
      template <typename T, bool>
      struct has_const_iterator_struct;
      
      template <typename T>
      constexpr auto has_const_iterator_helper(T* = nullptr)
        -> decltype(typename T::const_iterator(), bool());
      
      // Used as fallback when SFINAE culls the template method
      constexpr bool has_const_iterator_helper(...);
      //------------------------------------------------------------------------
      
    } // namespace type_traits
  } // namespace details
  
  template <typename T>
  struct has_const_iterator:
    public details::type_traits::has_const_iterator_struct
      <T, details::type_traits::has_const_iterator_helper((T*)(nullptr))>
    {};
  
  
  template <typename T>
  class Identity;
  
  
  template <typename T>
  class PairSecond;
  
  template <
    typename ITER, 
    typename INNERCONTEXTRACT = Identity<typename ITER::value_type>
    >
  class deep_const_fwd_iterator_nested;
  
  
/*  template <typename CITER>
  using deep_fwd_const_iterator = std::conditional<
    has_const_iterator<typename CITER::value_type>(),
    deep_const_fwd_iterator_nested<CITER>,
    CITER
    >;
*/
  
  template <
    typename CITER,
    typename INNERCONTEXTRACT = Identity<typename CITER::value_type>
    >
  using double_fwd_const_iterator
    = deep_const_fwd_iterator_nested<CITER, INNERCONTEXTRACT>;
  
} // namespace lar


namespace std {
  template <typename CITER, typename INNERCONTEXTRACT>
  void swap(lar::deep_const_fwd_iterator_nested<CITER, INNERCONTEXTRACT>& a,
    lar::deep_const_fwd_iterator_nested<CITER, INNERCONTEXTRACT>& b);
  
} // namespace std


//------------------------------------------------------------------------------

namespace lar {
  
  namespace details {
    namespace type_traits {
      
      //------------------------------------------------------------------------
      // helpers for has_const_iterator() function
      template <typename T, bool>
      struct has_const_iterator_struct: public std::false_type {};
      
      template <typename T>
      struct has_const_iterator_struct<T, true>: public std::true_type {};
      
      // Culled by SFINAE if T::const_iterator does not exist
      // or is not accessible or not default-constructable
      template <typename T>
      constexpr auto has_const_iterator_helper(T* /* = nullptr */)
        -> decltype(typename T::const_iterator(), bool()) 
        { return true; }
      
      // Used as fallback when SFINAE culls the template method
      constexpr bool has_const_iterator_helper(...) { return false; }
      //------------------------------------------------------------------------
      
    } // namespace type_traits
  } // namespace details
  
  //---
  //--- Identity declaration
  //---
  template <class T>
  class Identity {
      public:
    typedef T argument_type;
    typedef T result_type;
    
    result_type& operator() (argument_type& x) const { return x; }
    const result_type& operator() (const argument_type& x) const { return x; }
  }; // class Identity<>
  
  
  //---
  //--- PairSecond declaration
  //---
  template <class T>
  class PairSecond {
      public:
    typedef T argument_type;
    typedef typename T::second_type result_type;
    
    result_type& operator() (argument_type& p) const
      { return p.second; }
    const result_type& operator() (const argument_type& p) const
      { return p.second; }
  }; // class PairSecond<>
  
  
  //---
  //--- deep_const_fwd_iterator_nested declaration
  //---
  template <typename ITER, typename INNERCONTEXTRACT>
  class deep_const_fwd_iterator_nested: public std::forward_iterator_tag {
      public:
    using OuterIterator_t = ITER;
    using InnerContainerExtractor_t = INNERCONTEXTRACT;
    using InnerContainer_t = typename InnerContainerExtractor_t::result_type;
    using InnerIterator_t
  //    = deep_fwd_const_iterator<typename ITER::value_type::const_iterator>;
      = typename InnerContainer_t::const_iterator;
    
  //  using iterator_type = deep_fwd_const_iterator<OuterIterator_t>;
    using iterator_type = deep_const_fwd_iterator_nested
      <OuterIterator_t, InnerContainerExtractor_t>;
    
    using value_type = typename InnerIterator_t::value_type;
    
    
    struct BeginPositionTag {};
    struct EndPositionTag {};
    
    static constexpr BeginPositionTag begin = {};
    static constexpr EndPositionTag end = {};
    
    deep_const_fwd_iterator_nested() = default;
    
    deep_const_fwd_iterator_nested(OuterIterator_t src, OuterIterator_t end);
    
    template <class CONT>
    deep_const_fwd_iterator_nested(const CONT& cont, BeginPositionTag):
      deep_const_fwd_iterator_nested(std::begin(cont), std::end(cont))
      { skip_empty(); }
    
    template <class CONT>
    deep_const_fwd_iterator_nested(const CONT& cont, EndPositionTag):
      deep_const_fwd_iterator_nested(std::end(cont)) {}
    
    iterator_type& operator++();
    
    iterator_type operator++(int)
      { iterator_type old(*this); this->operator++(); return old; }
    
    const value_type& operator*() const { return *inner_iter; }
    const value_type& operator->() const { return *inner_iter; }
    
    bool operator== (const iterator_type& as) const 
      {
        return (as.outer_iter == outer_iter)
          && ((as.inner_iter == inner_iter) || (is_end() && as.is_end()));
      }
    bool operator!= (const iterator_type& as) const 
      {
        return (as.outer_iter != outer_iter)
          || ((as.inner_iter != inner_iter) && (!is_end() || !as.is_end()));
      }
    
    

    operator bool() const { return !is_end(); }
    bool operator! () const { return is_end(); }
    
    void swap(iterator_type& with);
    
      protected:
    OuterIterator_t outer_iter; 
    OuterIterator_t outer_end; 
    
    InnerIterator_t inner_iter; 
    InnerIterator_t inner_end; 
    
    deep_const_fwd_iterator_nested(OuterIterator_t end):
      deep_const_fwd_iterator_nested(end, end) {}
    
      private:
    void init_inner();
    void reset_inner();
    void skip_empty(); 
    
    bool is_end() const { return outer_iter == outer_end; }
    
    const typename InnerContainerExtractor_t::result_type&
      extract_container(const typename OuterIterator_t::value_type& v)
      { return InnerContainerExtractor_t()(v); }
    
  }; // class deep_const_fwd_iterator_nested<>
  
  
  //---
  //--- deep_const_fwd_iterator_nested implementation
  //---
  
  template <typename ITER, typename INNERCONTEXTRACT>
  deep_const_fwd_iterator_nested<ITER, INNERCONTEXTRACT>
    ::deep_const_fwd_iterator_nested
    (OuterIterator_t src, OuterIterator_t end):
    outer_iter(src), outer_end(end)
  {
    if (is_end()) return;
    init_inner();
    skip_empty();
  } // deep_const_fwd_iterator_nested(OuterIterator_t, OuterIterator_t)
  
  
  template <typename ITER, typename INNERCONTEXTRACT>
  deep_const_fwd_iterator_nested<ITER, INNERCONTEXTRACT>&
  deep_const_fwd_iterator_nested<ITER, INNERCONTEXTRACT>::operator++() {
    ++inner_iter;
    skip_empty();
    return *this;
  } // deep_const_fwd_iterator_nested<>::operator++()
  
  
  template <typename ITER, typename INNERCONTEXTRACT>
  void deep_const_fwd_iterator_nested<ITER, INNERCONTEXTRACT>
    ::swap(iterator_type& with)
  {
    std::swap(outer_iter, with.outer_iter);
    std::swap(outer_end, with.outer_end);
    std::swap(inner_iter, with.inner_iter);
    std::swap(inner_end, with.inner_end);
  } // deep_const_fwd_iterator_nested<>::swap()
  
  
  template <typename ITER, typename INNERCONTEXTRACT>
  void deep_const_fwd_iterator_nested<ITER, INNERCONTEXTRACT>::init_inner() {
    inner_iter = std::begin(extract_container(*outer_iter));
    inner_end = std::end(extract_container(*outer_iter));
  } // deep_const_fwd_iterator_nested<>::init_inner()
  
  
  template <typename ITER, typename INNERCONTEXTRACT>
  void deep_const_fwd_iterator_nested<ITER, INNERCONTEXTRACT>::reset_inner()
    { inner_end = inner_iter = {}; }
  
  template <typename ITER, typename INNERCONTEXTRACT>
  void deep_const_fwd_iterator_nested<ITER, INNERCONTEXTRACT>::skip_empty() {
    while(inner_iter == inner_end) {
      ++outer_iter;
      if (is_end()) {
        reset_inner();
        return;
      } // if
      init_inner();
    } // while inner iterator ended
  } // skip_empty()
  
  
} // namespace lar


namespace std {
  template <typename CITER, typename INNERCONTEXTRACT>
  inline void swap(
    lar::deep_const_fwd_iterator_nested<CITER, INNERCONTEXTRACT>& a,
    lar::deep_const_fwd_iterator_nested<CITER, INNERCONTEXTRACT>& b
    )
    { a.swap(b); }
} // namespace std



#endif // NESTEDITERATOR_H