RangeForWrapper.h

Go to the documentation of this file.

#ifndef LARDATA_UTILITIES_RANGEFORWRAPPER_H
#define LARDATA_UTILITIES_RANGEFORWRAPPER_H

// Boost libraries
#include "boost/variant.hpp"

// C/C++ standard libraries
#include <stdexcept> // std::logic_error
#include <utility> // std::move(), std::declval(), ...
#include <iterator> // std::iterator_traits
#include <type_traits> // std::is_same<>, std::enable_if_t<>, ...


namespace util {
  
  namespace details {
    
    template <typename BeginIter, typename EndIter>
    class RangeForWrapperIterator {
      struct Dereferencer;
      struct Incrementer;
      struct Comparer;
      struct Dumper;
      
      using traits_t = std::iterator_traits<BeginIter>;
      
        public:
      using begin_t = BeginIter; 
      using end_t = EndIter; 
      using this_t = RangeForWrapperIterator<begin_t, end_t>; 
      
      using difference_type   = typename traits_t::difference_type;
      using value_type        = typename traits_t::value_type;
      using pointer           = typename traits_t::pointer;
      using reference         = typename traits_t::reference;
      //
      // This wrapper fully supports up to bidirectional iterators;
      // if the wrapped iterator is a random or contiguous iterator,
      // the wrapper will still expose only a bidirectional iterator interface.
      // Supporting random access is possible, but writing a proper unit test
      // is tedious... open a feature request if needed.
      //
      using iterator_category = std::conditional_t<
        std::is_base_of<std::bidirectional_iterator_tag, typename traits_t::iterator_category>::value,
        std::bidirectional_iterator_tag,
        typename traits_t::iterator_category
        >;
      
      explicit RangeForWrapperIterator()
        : fIter(end_t{})
        {}
      
      explicit RangeForWrapperIterator(begin_t&& begin)
        : fIter(std::move(begin))
        {}
      
      explicit RangeForWrapperIterator(end_t&& end)
        : fIter(std::move(end))
        {}
      
      reference operator*() const
        { return boost::apply_visitor(Dereferencer(), fIter); }
      
      pointer operator->() const
        { return boost::apply_visitor(MemberAccessor(), fIter); }
      
      this_t& operator++()
        { boost::apply_visitor(Incrementer(), fIter); return *this; }
      
      this_t& operator--()
        { boost::apply_visitor(Decrementer(), fIter); return *this; }
      
      this_t operator++(int)
        { auto old = *this; this_t::operator++(); return old; }
      
      this_t operator--(int)
        { auto old = *this; this_t::operator--(); return old; }
      
      bool operator!=(this_t const& other) const
        { return boost::apply_visitor(Comparer(), fIter, other.fIter); }
      
      bool operator==(this_t const& other) const
        { return !(this->operator!=(other)); }
      
      
      reference operator[] (difference_type offset) const
        { return boost::apply_visitor(IndexAccessor(offset), fIter); }
      
      difference_type operator- (this_t const& other) const
        { return boost::apply_visitor(Difference(), fIter, other.fIter); }
      
        private: 
      static_assert(!std::is_same<begin_t, end_t>::value,
        "RangeForWrapperIterator requires two different iterator types."
        );
      
      boost::variant<begin_t, end_t> fIter; 
      
      //
      // We opt for allowing all the operations if the underlying operators do.
      // While it is true that, for example, an end iterator should not be
      // dereferenced, if it's bidirectional, its operator--() may make it
      // useful, but its type will still be the one of the end iterator.
      // Therefore we don't judge by the type, but by the action.
      //
      
      struct Dereferencer: public boost::static_visitor<reference> {
        
        template <typename Iter>
        auto operator() (Iter& iter) const -> decltype(auto)
          { return DereferencerImpl<reference, Iter>::dereference(iter); }
        
          private:
        template <typename Result, typename Iter, typename = void>
        struct DereferencerImpl;
        
      }; // Dereferencer
      
      struct MemberAccessor: public boost::static_visitor<pointer> {
        
        template <typename Iter>
        auto operator() (Iter& iter) const -> decltype(auto)
          { return MemberAccessorImpl<pointer, Iter>::access(iter); }
        
          private:
        template <typename Result, typename Iter, typename = void>
        struct MemberAccessorImpl;
        
      }; // MemberAccessor
      
      struct Incrementer: public boost::static_visitor<> {
        
        template <typename Iter>
        void operator() (Iter& iter) const
          { IncrementerImpl<Iter>::increment(iter); }
        
          private:
        template <typename Iter, typename = void>
        struct IncrementerImpl;
        
      }; // Incrementer
      
      struct Decrementer: public boost::static_visitor<> {
        
        template <typename Iter>
        void operator() (Iter& iter) const
          { DecrementerImpl<Iter>::decrement(iter); }
        
          private:
        template <typename Iter, typename = void>
        struct DecrementerImpl;
        
      }; // Decrementer
      
      
      struct Comparer: public boost::static_visitor<bool> {
        
        template <typename A, typename B>
        bool operator() (A const& left, B const& right) const
          { return ComparerImpl<A, B>::compare(left, right); }
        
          private:
        template <typename A, typename B, typename = void>
        struct ComparerImpl;
        
      }; // Comparer
      
      struct IndexAccessor: public boost::static_visitor<reference> {
        
        difference_type offset;
        
        IndexAccessor(difference_type offset): offset(offset) {}
        
        template <typename Iter>
        bool operator() (Iter& iter) const
          { return IndexAccessorImpl<reference, Iter>(offset).access(iter); }
        
          private:
        template <typename Result, typename Iter, typename = void>
        struct IndexAccessorImpl;
        
      }; // IndexAccessor
      
      struct Difference: public boost::static_visitor<difference_type > {
        
        template <typename A, typename B>
        difference_type operator() (A const& minuend, B const& subtrahend) const
          { return DifferenceImpl<A, B>::subtract(minuend, subtrahend); }
        
          private:
        template <typename A, typename B, typename = void>
        struct DifferenceImpl;
        
      }; // Difference
      
    }; // class RangeForWrapperIterator<>
    
    
    
    template <typename RangeRef>
    struct RangeForWrapperTraits {
      
      using RangeRef_t = RangeRef; 
      
      using Range_t = std::remove_reference_t<RangeRef_t>;
      
      static auto extractBegin(RangeRef_t range)
        { using namespace std; return begin(static_cast<RangeRef_t>(range)); }
      
      static auto extractEnd(RangeRef_t range)
        { using namespace std; return end(static_cast<RangeRef_t>(range)); }
      
      using BeginIter_t = decltype(extractBegin(std::declval<RangeRef_t>()));
      
      using EndIter_t = decltype(extractEnd(std::declval<RangeRef_t>()));
      
      static constexpr bool sameIteratorTypes
        = std::is_same<BeginIter_t, EndIter_t>();
      
      using Iterator_t = RangeForWrapperIterator<BeginIter_t, EndIter_t>;
      
      using value_type = typename BeginIter_t::value_type;
      using size_type = std::size_t;
      using difference_type = typename BeginIter_t::difference_type;
      using reference = typename BeginIter_t::value_type;
      using pointer = typename BeginIter_t::pointer;
      
    }; // class RangeForWrapperTraits<>
    
    
    template <typename RangeRef>
    class RangeForWrapperBox {
      
      static_assert(std::is_reference<RangeRef>::value,
        "RangeForWrapperBox requires a reference type.");
      
      using Traits_t = RangeForWrapperTraits<RangeRef>;
      
        public:
      
      // Import traits
      using RangeRef_t = typename Traits_t::RangeRef_t;
      using Range_t = typename Traits_t::Range_t;
      
      using Iterator_t = typename Traits_t::Iterator_t;
      
      using size_type = typename Traits_t::size_type;
      
      using difference_type = typename Traits_t::difference_type;
      
      RangeForWrapperBox(Range_t& range)
        : fRange(range)
        {}
      
      RangeForWrapperBox(Range_t&& range)
        : fRange(std::move(range))
        {}
      
      Iterator_t begin() const
        { return Iterator_t(wrappedBegin()); }
      
      Iterator_t end() const
        { return Iterator_t(wrappedEnd()); }
      
      
      auto size() const { return std::distance(begin(), end()); }
      
      bool empty() const { return !(wrappedBegin() != wrappedEnd()); }
      
      auto operator[] (difference_type index) const -> decltype(auto)
        { return wrappedBegin()[index]; }
      
      
      
        private:
      
      struct DataBox {
        
        using Stored_t = std::conditional_t<
          std::is_rvalue_reference<RangeRef_t>::value,
          std::remove_reference_t<RangeRef_t>,
          RangeRef_t
          >;
        using Data_t = std::remove_reference_t<Stored_t>;
        
        Stored_t data;
        
        // only one of these is valid...
        DataBox(Data_t& data): data(data) {}
        DataBox(Data_t&& data): data(std::move(data)) {}
        
        operator RangeRef_t() const { return RangeRef_t(data); }
        operator RangeRef_t() { return RangeRef_t(data); }
        
      }; // DataBox
      
      DataBox fRange; 
      
      auto wrappedBegin() const -> decltype(auto)
        { return Traits_t::extractBegin(static_cast<RangeRef_t>(fRange)); }
      auto wrappedEnd() const -> decltype(auto)
        { return Traits_t::extractEnd(static_cast<RangeRef_t>(fRange)); }
      
    }; // class RangeForWrapperBox<>
    
    
    struct SameIterTag {};
    
    struct DiffIterTag {};
    
    // the return type decltype(auto) is necessary to preserve the forwarded
    // referenceness
    template <
      typename BaseRange,
      bool SameIteratorsType
        = details::RangeForWrapperTraits<std::decay_t<BaseRange>>::sameIteratorTypes
      >
    struct WrapRangeForDispatcher;
    
    // Template specialization for same iterator types
    template <typename BaseRange>
    struct WrapRangeForDispatcher<BaseRange, true> {
      
      using BaseRange_t = std::decay_t<BaseRange>;
      
      static BaseRange_t wrap(BaseRange_t&& range) { return std::move(range); }
      static BaseRange_t& wrap(BaseRange_t& range) { return range; }
      static BaseRange_t const& wrap(BaseRange_t const& range) { return range; }
    }; // WrapRangeForDispatcher<BaseRange, true>
    
    
    // Template specialization for different-iterator types
    template <typename BaseRange>
    struct WrapRangeForDispatcher<BaseRange, false> {
      template <typename Range>
      static auto wrap(Range&& range)
        { 
          return RangeForWrapperBox<decltype(range)>
            (static_cast<decltype(range)>(range));
        }
    }; // WrapRangeForDispatcher<BaseRange, false> 
    
  } // namespace details
  
  
  template <typename Range>
  auto wrapRangeFor(Range&& range) -> decltype(auto)
    {
      return details::WrapRangeForDispatcher<Range>::wrap
        (std::forward<Range>(range));
    }
  
  
  struct RangeForWrapperTag {};
  
  constexpr RangeForWrapperTag range_for;
  
  template <typename Range>
  auto operator| (Range&& range, RangeForWrapperTag) -> decltype(auto)
    { return wrapRangeFor(std::forward<Range>(range)); }
  
  
} // namespace util


//------------------------------------------------------------------------------
//---  template implementation
//------------------------------------------------------------------------------
namespace util {
  
  namespace details {
    
    //--------------------------------------------------------------------------
    template <typename T>
    struct is_type: public std::true_type {};
    
    template <typename T>
    constexpr bool is_type_v = is_type<T>();
    
    
    //--------------------------------------------------------------------------
    template <typename BeginIter, typename EndIter>
    template <typename A, typename B, typename /* = void */>
    struct RangeForWrapperIterator<BeginIter, EndIter>::Comparer::ComparerImpl {
      // this would be worth a static_assert(), but apparently boost::variant
      // visitor instantiates it even when it's not called
      static bool compare(A const&, B const&)
        { throw std::logic_error("These iterators can't be compared!"); }
    }; //
    
    //--------------------------------------------------------------------------
    template <typename BeginIter, typename EndIter>
    template <typename A, typename B>
    struct RangeForWrapperIterator<BeginIter, EndIter>::Comparer::ComparerImpl<
      A, B, std::enable_if_t<
        std::is_convertible
          <decltype(std::declval<A>() != std::declval<B>()), bool>::value
        >
      >
    {
      static bool compare(A const& left, B const& right) 
        { return left != right; }
    }; //
    
    
    //--------------------------------------------------------------------------
    template <typename BeginIter, typename EndIter>
    template <typename Result, typename Iter, typename /* = void */>
    struct RangeForWrapperIterator<BeginIter, EndIter>::Dereferencer::DereferencerImpl {
      // this would be worth a static_assert(), but apparently boost::variant
      // visitor instantiates it even when it's not called
      [[noreturn]] static Result dereference(Iter const&)
        { throw std::logic_error("This iterator can't be dereferenced!"); }
    }; //
    
    //--------------------------------------------------------------------------
    template <typename BeginIter, typename EndIter>
    template <typename Result, typename Iter>
    struct RangeForWrapperIterator<BeginIter, EndIter>::Dereferencer::DereferencerImpl<
      Result, Iter, std::enable_if_t<is_type_v<decltype(*(std::declval<Iter>()))>>
      >
    {
      static Result dereference(Iter const& iter)
        { return *iter; }
    }; //
    
    
    //--------------------------------------------------------------------------
    template <typename BeginIter, typename EndIter>
    template <typename Result, typename Iter, typename /* = void */>
    struct RangeForWrapperIterator<BeginIter, EndIter>::MemberAccessor::MemberAccessorImpl {
      // this would be worth a static_assert(), but apparently boost::variant
      // visitor instantiates it even when it's not called
      [[noreturn]] static Result access(Iter const&)
        { throw std::logic_error("This iterator can't be dereferenced!"); }
    }; //
    
    //--------------------------------------------------------------------------
    template <typename BeginIter, typename EndIter>
    template <typename Result, typename Iter>
    struct RangeForWrapperIterator<BeginIter, EndIter>::MemberAccessor::MemberAccessorImpl<
      Result, Iter, std::enable_if_t<is_type_v<decltype(std::declval<Iter>().operator->())>>
      >
    {
      static Result access(Iter const& iter)
        { return iter.operator->(); }
    }; //
    
    
    //--------------------------------------------------------------------------
    template <typename BeginIter, typename EndIter>
    template <typename Iter, typename /* = void */>
    struct RangeForWrapperIterator<BeginIter, EndIter>::Incrementer::IncrementerImpl {
      // this would be worth a static_assert(), but apparently boost::variant
      // visitor instantiates it even when it's not called
      [[noreturn]] static void increment(Iter&)
        { throw std::logic_error("This iterator can't be incremented!"); }
    }; //
    
    //--------------------------------------------------------------------------
    template <typename BeginIter, typename EndIter>
    template <typename Iter>
    struct RangeForWrapperIterator<BeginIter, EndIter>::Incrementer::IncrementerImpl<
      Iter, std::enable_if_t<is_type_v<decltype(++(std::declval<Iter>()))>>
      >
    {
      static void increment(Iter& iter) 
        { ++iter; }
    }; //
    
    
    //--------------------------------------------------------------------------
    template <typename BeginIter, typename EndIter>
    template <typename Iter, typename /* = void */>
    struct RangeForWrapperIterator<BeginIter, EndIter>::Decrementer::DecrementerImpl {
      // this would be worth a static_assert(), but apparently boost::variant
      // visitor instantiates it even when it's not called
      [[noreturn]] static void decrement(Iter&)
        { throw std::logic_error("This iterator can't be decremented!"); }
    }; //
    
    //--------------------------------------------------------------------------
    template <typename BeginIter, typename EndIter>
    template <typename Iter>
    struct RangeForWrapperIterator<BeginIter, EndIter>::Decrementer::DecrementerImpl<
      Iter, std::enable_if_t<is_type_v<decltype(--(std::declval<Iter>()))>>
      >
    {
      static void decrement(Iter& iter) 
        { --iter; }
    }; //
    
    
    //--------------------------------------------------------------------------
    template <typename BeginIter, typename EndIter>
    template <typename Result, typename Iter, typename /* = void */>
    struct RangeForWrapperIterator<BeginIter, EndIter>::IndexAccessor::IndexAccessorImpl {
      // this would be worth a static_assert(), but apparently boost::variant
      // visitor instantiates it even when it's not called
      
      IndexAccessorImpl(difference_type) {}
      
      [[noreturn]] Result access(Iter const&) const
        { throw std::logic_error("This iterator can't be indexed!"); }
    }; //
    
    //--------------------------------------------------------------------------
    template <typename BeginIter, typename EndIter>
    template <typename Result, typename Iter>
    struct RangeForWrapperIterator<BeginIter, EndIter>::IndexAccessor::IndexAccessorImpl<
      Result, Iter, std::enable_if_t<is_type_v<decltype((std::declval<Iter>())[0])>>
      >
    {
      difference_type offset;
      
      IndexAccessorImpl(difference_type offset): offset(offset) {}
      
      Result dereference(Iter const& iter) const
        { return iter[offset]; }
    }; //
    
    
    //--------------------------------------------------------------------------
    template <typename BeginIter, typename EndIter>
    template <typename A, typename B, typename /* = void */>
    struct RangeForWrapperIterator<BeginIter, EndIter>::Difference::DifferenceImpl {
      // this would be worth a static_assert(), but apparently boost::variant
      // visitor instantiates it even when it's not called
      static difference_type subtract(A const&, B const&)
        { throw std::logic_error("These iterators can't be subtracted!"); }
    }; //
    
    //--------------------------------------------------------------------------
    template <typename BeginIter, typename EndIter>
    template <typename A, typename B>
    struct RangeForWrapperIterator<BeginIter, EndIter>::Difference::DifferenceImpl<
      A, B, std::enable_if_t<
        std::is_convertible<
          decltype(std::declval<A>() - std::declval<B>()),
          typename RangeForWrapperIterator<BeginIter, EndIter>::difference_type>::value
        >
      >
    {
      static difference_type subtract(A const& minuend, B const& subtrahend) 
        { return minuend - subtrahend; }
    }; //
    
    
    //--------------------------------------------------------------------------
    
    
  } // namespace details
} // namespace util
  

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


#endif // LARDATA_UTILITIES_RANGEFORWRAPPER_H