iterator_range.hpp

Go to the documentation of this file.

#ifndef ZEN_ITERATOR_RANGE_HPP
#define ZEN_ITERATOR_RANGE_HPP
 
#include <iterator>
#include <tuple>
#include <type_traits>
#include <utility>
 
#include "zen/config.hpp"
#include "zen/concepts.hpp"
#include "zen/compat.hpp"
#include "zen/mapped_iterator.hpp"
#include "zen/zip_iterator.hpp"
 
ZEN_NAMESPACE_START
 
template<typename IterT>
class iterator_range {
 
  IterT left;
  IterT right;
 
  using trait_type = std::iterator_traits<IterT>;
 
public:
 
  using value_type = typename trait_type::value_type;
  using reference = typename trait_type::reference;
  using iterator = IterT;
  using difference_type = typename trait_type::difference_type;
 
  iterator_range(IterT left, IterT right):
    left(left), right(right) {}
 

  IterT begin() {
    return left;
  }

  IterT end() {
    return right;
  }
 
  iterator_range& operator++() requires std::incrementable<IterT> {
    ++left;
    return *this;
  }
 
  iterator_range operator++(int) requires std::incrementable<IterT> {
    return iterator_range { left++, right };
  }
 
  iterator_range& operator--() requires std::incrementable<IterT> {
    --left;
    return *this;
  }
 
  iterator_range operator--(int) requires std::incrementable<IterT> {
    return iterator_range { left--, right };
  }
 
  template<typename F>
  auto map(F func) {
    using iter = mapped_iterator<IterT, F>;
    return iterator_range<iter> {
      iter { left, func },
      iter { right, func },
    };
  }
 
  auto map_first() {
    return map([](auto pair) { return pair.first; });
  }
 
  auto map_second() {
    return map([](auto pair) { return pair.second; });
  }
 
};

template <typename IterT> auto make_iterator_range(IterT &&a, IterT &&b) {
  return iterator_range<IterT> { std::forward<IterT>(a), std::forward<IterT>(b) };
}

template<typename IterT>
auto make_iterator_range(std::pair<IterT, IterT>&& pair) {
  return iterator_range<IterT> { std::forward<IterT>(pair.first), std::forward<IterT>(pair.second) };
}
 
template<range T>
auto make_iterator_range(T& container) {
  return make_iterator_range(
    std::begin(container),
    std::end(container)
  );
}
 
// By default, we don't allow rvalues.
//
// For example, a container passed to `zip` would be destroyed before the
// iterator can run.
template <typename T>
struct _zip_accept_rvalue : std::false_type {};
 
// An iterator_range should be passed by value.
template<typename IterT>
struct _zip_accept_rvalue<iterator_range<IterT>> : std::true_type {};

template<range ...Ts>
auto zip(Ts&& ...args) {
  // TODO
  // static_assert(
  //   meta::andmap_v<
  //     meta::bind<
  //       std::disjunction<
  //         std::is_lvalue_reference<meta::_1>,
  //         _zip_accept_rvalue<std::remove_reference_t<meta::_1>>
  //       >
  //     >,
  //     std::tuple<Ts...>
  //   >,
  //   "the provided value cannot be passed in as an rvalue"
  // );
  return make_iterator_range(
    zip(std::begin(args)...),
    zip(std::end(args)...)
  );
}
 
ZEN_NAMESPACE_END
 
#endif // of #ifndef ZEN_ITERATOR_RANGE_HPP