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 <iterator>    // std::iterator_traits
#include <stdexcept>   // std::logic_error
#include <type_traits> // std::is_same<>, std::enable_if_t<>, ...
#include <utility>     // std::move(), std::declval(), ...

namespace util {

  namespace details {

    template <typename BeginIter, typename EndIter>
    class RangeForWrapperIterator {

      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 {

      static_assert(std::is_reference<RangeRef>::value,
                    "RangeForWrapperBox requires a reference type.");

      using RangeRef_t = RangeRef; 

      using Range_t = std::remove_reference_t<RangeRef_t>;

      static auto extractBegin(RangeRef_t range)
      {
        using namespace std;
        return begin(range);
      }

      static auto extractEnd(RangeRef_t range)
      {
        using namespace std;
        return end(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;

      using value_type = typename Traits_t::value_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<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