DereferenceIterator.h

Go to the documentation of this file.

#ifndef LARCORE_COREUTILS_DEREFERENCEITERATOR_H
#define LARCORE_COREUTILS_DEREFERENCEITERATOR_H

// C/C++ standard libraries
#include <utility> // std::move(), std::declval()
#include <type_traits> // std::add_lvalue_reference_t<>, std::add_pointer_t<>


namespace lar {
  namespace util {
    
    namespace detail {
      
      template <typename BeginIter, typename EndIter>
      class IteratorBox {
        BeginIter b;
        EndIter e;
        
          public:
        IteratorBox(BeginIter b, EndIter e): b(b), e(e) {}
        
        BeginIter const& begin() const { return b; }
        EndIter const& end() const { return e; }
        
      }; // IteratorBox<>
      
      template <typename BeginIter, typename EndIter>
      auto makeIteratorBox(BeginIter b, EndIter e)
        { return IteratorBox<BeginIter, EndIter>(b, e); }
      
      
      
      template <typename Iter, typename Value>
      class DereferenceIteratorBase {
        using iterator_t = Iter; 
        using this_t = DereferenceIteratorBase<Iter, Value>; 
        
        iterator_t iter; 
        
          public:
        struct initialize_tag {};
        
            
        using difference_type = typename iterator_t::difference_type;
        using value_type = Value;
        using pointer = std::add_pointer_t<value_type>;
        using reference = std::add_lvalue_reference_t<value_type>;
        using iterator_category = typename iterator_t::iterator_category;
        
        
        
        DereferenceIteratorBase() = default;
        
        DereferenceIteratorBase(Iter const& iter, initialize_tag)
          : iter(iter) {}
        
        DereferenceIteratorBase(Iter&& iter, initialize_tag)
          : iter(std::move(iter)) {}
        
        template <typename OtherIter, typename OtherValue>
        DereferenceIteratorBase
          (DereferenceIteratorBase<iterator_t, OtherValue> const& other)
          : iter(other.iter)
          {
            static_assert(std::is_convertible<OtherValue, value_type>::value,
              "Copying from a iterator with incompatible value"
              );
          }
        
        template <typename OtherIter, typename OtherValue>
        DereferenceIteratorBase
          (DereferenceIteratorBase<iterator_t, OtherValue>&& other)
          : iter(std::move(other.iter))
          {
            static_assert(std::is_convertible<OtherValue, value_type>::value,
              "Moving from a iterator with incompatible value"
              );
          }
        
        
        reference operator* () const { return **iter; }
        
        pointer operator-> () const { return *iter; }
        
        reference operator[] (difference_type i) const { return *(iter[i]); }
        
        this_t& operator++() { ++iter; return *this; }
        
        this_t& operator--() { --iter; return *this; }
        
        this_t operator++(int) { return this_t(iter++, {}); }
        
        this_t operator--(int) { return this_t(iter--, {}); }
        
        this_t operator+ (difference_type offset) const
          { return { iter + offset }; }
        this_t operator- (difference_type offset) const
          { return { iter - offset }; }
        
        this_t& operator+= (difference_type offset)
          { iter += offset; return *this; }
        this_t& operator-= (difference_type offset)
          { iter -= offset; return *this; }
        
        
        difference_type operator- (this_t const& other) const
          { return iter - other.iter; }
        
        bool is_null() const { return iterator_t::operator* () == nullptr; }
        
        
        bool operator== (this_t const& other) const
          { return other.iter == iter; }
        bool operator!= (this_t const& other) const
          { return other.iter != iter; }
        bool operator<= (this_t const& other) const
          { return other.iter <= iter; }
        bool operator>= (this_t const& other) const
          { return other.iter >= iter; }
        bool operator<  (this_t const& other) const
          { return other.iter < iter; }
        bool operator>  (this_t const& other) const
          { return other.iter < iter; }
          
        
      }; // class DereferenceIteratorBase
      
      template <typename Iter, typename Value>
      auto operator+ (
        typename DereferenceIteratorBase<Iter, Value>::difference_type offset,
        DereferenceIteratorBase<Iter, Value> const& iter
        )
        { return iter + offset; }
      
      
    } // namespace detail
    
    
    template <typename Iter>
    using DereferenceConstIterator = detail::DereferenceIteratorBase<
      Iter,
      std::add_const_t<std::decay_t<decltype(**(std::declval<Iter>()))>>
      >;
      
    template <typename Iter>
    using DereferenceIterator = detail::DereferenceIteratorBase<
      Iter,
      std::decay_t<decltype(**(std::declval<Iter>()))>
      >;
    
    
    
    template <typename Iter>
    auto makeDereferenceIterator(Iter&& iter)
      { return DereferenceIterator<Iter>(std::forward<Iter>(iter), {}); }
    
    template <typename Cont>
    auto beginDereferenceIterator(Cont& cont)
      { return makeDereferenceIterator(cont.begin()); }
    
    template <typename Cont>
    auto endDereferenceIterator(Cont& cont)
      { return makeDereferenceIterator(cont.end()); }
    
    template <typename Cont>
    auto rbeginDereferenceIterator(Cont& cont)
      { return makeDereferenceIterator(cont.rbegin()); }
    
    template <typename Cont>
    auto rendDereferenceIterator(Cont& cont)
      { return makeDereferenceIterator(cont.rend()); }
    
    template <typename Cont>
    auto dereferenceIteratorLoop(Cont& cont)
      { 
        return detail::makeIteratorBox
          (beginDereferenceIterator(cont), endDereferenceIterator(cont));
      } // dereferenceIteratorLoop()
    
    
    template <typename Cont>
    auto dereferenceIteratorReverseLoop(Cont& cont)
      { 
        return detail::makeIteratorBox
          (rbeginDereferenceIterator(cont), rendDereferenceIterator(cont));
      } // dereferenceIteratorReverseLoop()
    
    
    
    template <typename Iter>
    auto makeDereferenceConstIterator(Iter&& iter)
      { return DereferenceConstIterator<Iter>(std::forward<Iter>(iter), {}); }
    
    template <typename Cont>
    auto cbeginDereferenceIterator(Cont& cont)
      { return makeDereferenceConstIterator(cont.cbegin()); }
    
    template <typename Cont>
    auto cendDereferenceIterator(Cont& cont)
      { return makeDereferenceConstIterator(cont.cend()); }
    
    template <typename Cont>
    auto crbeginDereferenceIterator(Cont& cont)
      { return makeDereferenceConstIterator(cont.crbegin()); }
    
    template <typename Cont>
    auto crendDereferenceIterator(Cont& cont)
      { return makeDereferenceConstIterator(cont.crend()); }
    
    template <typename Cont>
    auto dereferenceConstIteratorLoop(Cont& cont)
      { 
        return detail::makeIteratorBox
          (cbeginDereferenceIterator(cont), cendDereferenceIterator(cont));
      } // dereferenceConstIteratorLoop()
    
    
    template <typename Cont>
    auto dereferenceConstIteratorReverseLoop(Cont& cont)
      { 
        return detail::makeIteratorBox
          (crbeginDereferenceIterator(cont), crendDereferenceIterator(cont));
      } // dereferenceConstIteratorReverseLoop()
    
    
  } // namespace util
} // namespace lar


#endif // LARCORE_COREUTILS_DEREFERENCEITERATOR_H