2015-04-15 23:18:00 +00:00
|
|
|
/* Ranges for OctaSTD.
|
|
|
|
*
|
|
|
|
* This file is part of OctaSTD. See COPYING.md for futher information.
|
|
|
|
*/
|
|
|
|
|
2015-07-13 19:08:55 +00:00
|
|
|
#ifndef OSTD_RANGE_HH
|
|
|
|
#define OSTD_RANGE_HH
|
2015-04-15 23:18:00 +00:00
|
|
|
|
|
|
|
#include <stddef.h>
|
2015-07-03 17:21:05 +00:00
|
|
|
#include <string.h>
|
2015-04-15 23:18:00 +00:00
|
|
|
|
2015-07-13 19:08:55 +00:00
|
|
|
#include "ostd/new.hh"
|
|
|
|
#include "ostd/types.hh"
|
|
|
|
#include "ostd/utility.hh"
|
|
|
|
#include "ostd/type_traits.hh"
|
2016-03-27 20:06:00 +00:00
|
|
|
#include "ostd/tuple.hh"
|
2015-04-15 23:18:00 +00:00
|
|
|
|
2015-07-13 19:07:14 +00:00
|
|
|
namespace ostd {
|
2015-04-16 20:50:53 +00:00
|
|
|
|
2015-06-03 22:55:11 +00:00
|
|
|
struct InputRangeTag {};
|
|
|
|
struct OutputRangeTag {};
|
|
|
|
struct ForwardRangeTag: InputRangeTag {};
|
|
|
|
struct BidirectionalRangeTag: ForwardRangeTag {};
|
|
|
|
struct RandomAccessRangeTag: BidirectionalRangeTag {};
|
|
|
|
struct FiniteRandomAccessRangeTag: RandomAccessRangeTag {};
|
2015-07-23 00:28:25 +00:00
|
|
|
struct ContiguousRangeTag: FiniteRandomAccessRangeTag {};
|
2015-05-29 22:48:05 +00:00
|
|
|
|
2016-07-31 19:40:25 +00:00
|
|
|
template<typename T>
|
|
|
|
struct RangeHalf;
|
2015-06-03 22:55:11 +00:00
|
|
|
|
2015-07-13 19:08:55 +00:00
|
|
|
#define OSTD_RANGE_TRAIT(Name) \
|
2015-06-03 22:55:11 +00:00
|
|
|
namespace detail { \
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename T> \
|
2015-06-15 17:54:00 +00:00
|
|
|
struct Range##Name##Test { \
|
2016-07-31 19:40:25 +00:00
|
|
|
template<typename U> \
|
|
|
|
static char test(RemoveReference<typename U::Name> *); \
|
|
|
|
template<typename U> \
|
|
|
|
static int test(...); \
|
2015-06-15 17:54:00 +00:00
|
|
|
static constexpr bool value = (sizeof(test<T>(0)) == sizeof(char)); \
|
|
|
|
}; \
|
|
|
|
template<typename T, bool = Range##Name##Test<T>::value> \
|
|
|
|
struct Range##Name##Base {}; \
|
|
|
|
template<typename T> \
|
|
|
|
struct Range##Name##Base<T, true> { \
|
2015-06-10 00:18:56 +00:00
|
|
|
using Type = typename T::Name; \
|
2015-05-29 22:48:05 +00:00
|
|
|
}; \
|
2015-06-03 22:55:11 +00:00
|
|
|
} \
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename T> \
|
2015-07-05 22:59:36 +00:00
|
|
|
using Range##Name = typename detail::Range##Name##Base<T>::Type;
|
2015-05-29 22:48:05 +00:00
|
|
|
|
2015-07-13 19:08:55 +00:00
|
|
|
OSTD_RANGE_TRAIT(Category)
|
|
|
|
OSTD_RANGE_TRAIT(Size)
|
|
|
|
OSTD_RANGE_TRAIT(Value)
|
|
|
|
OSTD_RANGE_TRAIT(Reference)
|
|
|
|
OSTD_RANGE_TRAIT(Difference)
|
2015-05-29 22:48:05 +00:00
|
|
|
|
2015-07-13 19:08:55 +00:00
|
|
|
#undef OSTD_RANGE_TRAIT
|
2015-04-15 23:18:00 +00:00
|
|
|
|
2015-06-15 17:54:00 +00:00
|
|
|
namespace detail {
|
2016-07-31 19:40:25 +00:00
|
|
|
template<typename U>
|
|
|
|
static char is_range_test(
|
|
|
|
typename U::Category *, typename U::Size *,
|
|
|
|
typename U::Difference *, typename U::Value *,
|
|
|
|
RemoveReference<typename U::Reference> *
|
|
|
|
);
|
|
|
|
template<typename U>
|
|
|
|
static int is_range_test(...);
|
|
|
|
|
|
|
|
template<typename T> constexpr bool IsRangeTest =
|
|
|
|
(sizeof(is_range_test<T>(0, 0, 0, 0, 0)) == sizeof(char));
|
2015-06-15 17:54:00 +00:00
|
|
|
}
|
|
|
|
|
2015-06-03 22:55:11 +00:00
|
|
|
// is input range
|
2015-05-23 19:33:08 +00:00
|
|
|
|
2015-06-15 17:54:00 +00:00
|
|
|
namespace detail {
|
2016-07-31 19:40:25 +00:00
|
|
|
template<typename T>
|
|
|
|
constexpr bool IsInputRangeCore =
|
|
|
|
IsConvertible<RangeCategory<T>, InputRangeTag>;
|
2015-06-15 17:54:00 +00:00
|
|
|
|
2016-01-21 17:58:51 +00:00
|
|
|
template<typename T, bool = detail::IsRangeTest<T>>
|
2016-01-14 19:11:52 +00:00
|
|
|
constexpr bool IsInputRangeBase = false;
|
2016-01-13 17:42:37 +00:00
|
|
|
|
|
|
|
template<typename T>
|
2016-01-14 19:11:52 +00:00
|
|
|
constexpr bool IsInputRangeBase<T, true> = detail::IsInputRangeCore<T>;
|
2016-01-13 17:42:37 +00:00
|
|
|
}
|
2015-05-23 19:33:08 +00:00
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename T>
|
2016-01-14 19:11:52 +00:00
|
|
|
constexpr bool IsInputRange = detail::IsInputRangeBase<T>;
|
2015-05-23 19:33:08 +00:00
|
|
|
|
2015-06-03 22:55:11 +00:00
|
|
|
// is forward range
|
2015-05-23 19:33:08 +00:00
|
|
|
|
2015-06-15 17:54:00 +00:00
|
|
|
namespace detail {
|
2016-07-31 19:40:25 +00:00
|
|
|
template<typename T>
|
|
|
|
constexpr bool IsForwardRangeCore =
|
|
|
|
IsConvertible<RangeCategory<T>, ForwardRangeTag>;
|
2015-06-15 17:54:00 +00:00
|
|
|
|
2016-01-21 17:58:51 +00:00
|
|
|
template<typename T, bool = detail::IsRangeTest<T>>
|
2016-01-14 19:11:52 +00:00
|
|
|
constexpr bool IsForwardRangeBase = false;
|
2016-01-13 17:42:37 +00:00
|
|
|
|
|
|
|
template<typename T>
|
2016-01-14 19:11:52 +00:00
|
|
|
constexpr bool IsForwardRangeBase<T, true> = detail::IsForwardRangeCore<T>;
|
2016-01-13 17:42:37 +00:00
|
|
|
}
|
2015-05-23 19:33:08 +00:00
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename T>
|
2016-01-14 19:11:52 +00:00
|
|
|
constexpr bool IsForwardRange = detail::IsForwardRangeBase<T>;
|
2015-05-23 19:33:08 +00:00
|
|
|
|
2015-06-03 22:55:11 +00:00
|
|
|
// is bidirectional range
|
2015-05-23 19:33:08 +00:00
|
|
|
|
2015-06-15 17:54:00 +00:00
|
|
|
namespace detail {
|
2016-07-31 19:40:25 +00:00
|
|
|
template<typename T>
|
|
|
|
constexpr bool IsBidirectionalRangeCore =
|
|
|
|
IsConvertible<RangeCategory<T>, BidirectionalRangeTag>;
|
2015-06-15 17:54:00 +00:00
|
|
|
|
2016-01-21 17:58:51 +00:00
|
|
|
template<typename T, bool = detail::IsRangeTest<T>>
|
2016-01-14 19:11:52 +00:00
|
|
|
constexpr bool IsBidirectionalRangeBase = false;
|
2015-05-23 19:33:08 +00:00
|
|
|
|
2016-01-13 17:42:37 +00:00
|
|
|
template<typename T>
|
2016-01-14 19:11:52 +00:00
|
|
|
constexpr bool IsBidirectionalRangeBase<T, true> =
|
|
|
|
detail::IsBidirectionalRangeCore<T>;
|
2016-01-13 17:42:37 +00:00
|
|
|
}
|
|
|
|
|
2016-07-31 19:40:25 +00:00
|
|
|
template<typename T> constexpr bool IsBidirectionalRange =
|
|
|
|
detail::IsBidirectionalRangeBase<T>;
|
2015-05-23 19:33:08 +00:00
|
|
|
|
2015-06-03 22:55:11 +00:00
|
|
|
// is random access range
|
2015-05-23 19:33:08 +00:00
|
|
|
|
2015-06-15 17:54:00 +00:00
|
|
|
namespace detail {
|
2016-07-31 19:40:25 +00:00
|
|
|
template<typename T>
|
|
|
|
constexpr bool IsRandomAccessRangeCore =
|
|
|
|
IsConvertible<RangeCategory<T>, RandomAccessRangeTag>;
|
2015-06-15 17:54:00 +00:00
|
|
|
|
2016-01-21 17:58:51 +00:00
|
|
|
template<typename T, bool = detail::IsRangeTest<T>>
|
2016-01-14 19:11:52 +00:00
|
|
|
constexpr bool IsRandomAccessRangeBase = false;
|
2015-05-23 19:33:08 +00:00
|
|
|
|
2016-01-13 17:42:37 +00:00
|
|
|
template<typename T>
|
2016-01-14 19:11:52 +00:00
|
|
|
constexpr bool IsRandomAccessRangeBase<T, true> =
|
|
|
|
detail::IsRandomAccessRangeCore<T>;
|
2016-01-13 17:42:37 +00:00
|
|
|
}
|
|
|
|
|
2016-07-31 19:40:25 +00:00
|
|
|
template<typename T> constexpr bool IsRandomAccessRange =
|
|
|
|
detail::IsRandomAccessRangeBase<T>;
|
2015-05-23 19:33:08 +00:00
|
|
|
|
2015-06-03 22:55:11 +00:00
|
|
|
// is finite random access range
|
2015-05-23 19:33:08 +00:00
|
|
|
|
2015-06-15 17:54:00 +00:00
|
|
|
namespace detail {
|
2016-07-31 19:40:25 +00:00
|
|
|
template<typename T>
|
|
|
|
constexpr bool IsFiniteRandomAccessRangeCore =
|
|
|
|
IsConvertible<RangeCategory<T>, FiniteRandomAccessRangeTag>;
|
2015-06-15 17:54:00 +00:00
|
|
|
|
2016-01-21 17:58:51 +00:00
|
|
|
template<typename T, bool = detail::IsRangeTest<T>>
|
2016-01-14 19:11:52 +00:00
|
|
|
constexpr bool IsFiniteRandomAccessRangeBase = false;
|
2015-05-23 19:33:08 +00:00
|
|
|
|
2016-01-13 17:42:37 +00:00
|
|
|
template<typename T>
|
2016-01-14 19:11:52 +00:00
|
|
|
constexpr bool IsFiniteRandomAccessRangeBase<T, true> =
|
|
|
|
detail::IsFiniteRandomAccessRangeCore<T>;
|
2016-01-13 17:42:37 +00:00
|
|
|
}
|
|
|
|
|
2016-07-31 19:40:25 +00:00
|
|
|
template<typename T> constexpr bool IsFiniteRandomAccessRange =
|
|
|
|
detail::IsFiniteRandomAccessRangeBase<T>;
|
2015-05-23 19:33:08 +00:00
|
|
|
|
2015-06-03 22:55:11 +00:00
|
|
|
// is infinite random access range
|
2015-05-23 19:33:08 +00:00
|
|
|
|
2016-07-31 19:40:25 +00:00
|
|
|
template<typename T> constexpr bool IsInfiniteRandomAccessRange =
|
|
|
|
IsRandomAccessRange<T> && !IsFiniteRandomAccessRange<T>;
|
2015-05-23 19:33:08 +00:00
|
|
|
|
2015-07-23 00:28:25 +00:00
|
|
|
// is contiguous range
|
|
|
|
|
|
|
|
namespace detail {
|
2016-07-31 19:40:25 +00:00
|
|
|
template<typename T>
|
|
|
|
constexpr bool IsContiguousRangeCore =
|
|
|
|
IsConvertible<RangeCategory<T>, ContiguousRangeTag>;
|
2015-07-23 00:28:25 +00:00
|
|
|
|
2016-01-21 17:58:51 +00:00
|
|
|
template<typename T, bool = detail::IsRangeTest<T>>
|
2016-01-14 19:11:52 +00:00
|
|
|
constexpr bool IsContiguousRangeBase = false;
|
2015-07-23 00:28:25 +00:00
|
|
|
|
2016-01-13 17:42:37 +00:00
|
|
|
template<typename T>
|
2016-01-14 19:11:52 +00:00
|
|
|
constexpr bool IsContiguousRangeBase<T, true> =
|
|
|
|
detail::IsContiguousRangeCore<T>;
|
2016-01-13 17:42:37 +00:00
|
|
|
}
|
|
|
|
|
2016-07-31 19:40:25 +00:00
|
|
|
template<typename T> constexpr bool IsContiguousRange =
|
|
|
|
detail::IsContiguousRangeBase<T>;
|
2015-07-23 00:28:25 +00:00
|
|
|
|
2015-06-03 22:55:11 +00:00
|
|
|
// is output range
|
2015-05-23 19:33:08 +00:00
|
|
|
|
2015-06-03 22:55:11 +00:00
|
|
|
namespace detail {
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename T, typename P>
|
2015-06-03 22:55:11 +00:00
|
|
|
struct OutputRangeTest {
|
2016-07-31 19:40:25 +00:00
|
|
|
template<typename U, bool (U::*)(P)>
|
|
|
|
struct Test {};
|
|
|
|
template<typename U>
|
|
|
|
static char test(Test<U, &U::put> *);
|
|
|
|
template<typename U>
|
|
|
|
static int test(...);
|
2015-06-04 21:57:06 +00:00
|
|
|
static constexpr bool value = (sizeof(test<T>(0)) == sizeof(char));
|
2015-05-23 21:24:12 +00:00
|
|
|
};
|
|
|
|
|
2016-07-31 19:40:25 +00:00
|
|
|
template<typename T>
|
|
|
|
constexpr bool IsOutputRangeCore =
|
|
|
|
IsConvertible<RangeCategory<T>, OutputRangeTag> || (
|
|
|
|
IsInputRange<T> && (
|
|
|
|
detail::OutputRangeTest<T, RangeValue<T> const &>::value ||
|
|
|
|
detail::OutputRangeTest<T, RangeValue<T> &&>::value ||
|
|
|
|
detail::OutputRangeTest<T, RangeValue<T> >::value
|
|
|
|
)
|
|
|
|
);
|
2016-01-13 17:42:37 +00:00
|
|
|
|
2016-01-21 17:58:51 +00:00
|
|
|
template<typename T, bool = detail::IsRangeTest<T>>
|
2016-01-14 19:11:52 +00:00
|
|
|
constexpr bool IsOutputRangeBase = false;
|
2016-01-13 17:42:37 +00:00
|
|
|
|
|
|
|
template<typename T>
|
2016-01-14 19:11:52 +00:00
|
|
|
constexpr bool IsOutputRangeBase<T, true> = detail::IsOutputRangeCore<T>;
|
2016-01-13 17:42:37 +00:00
|
|
|
}
|
|
|
|
|
2016-01-14 19:11:52 +00:00
|
|
|
template<typename T> constexpr bool IsOutputRange = detail::IsOutputRangeBase<T>;
|
2015-05-23 19:33:08 +00:00
|
|
|
|
2015-06-03 22:55:11 +00:00
|
|
|
namespace detail {
|
2015-05-23 19:33:08 +00:00
|
|
|
// range iterator
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename T>
|
2015-06-03 22:55:11 +00:00
|
|
|
struct RangeIterator {
|
2016-07-31 19:40:25 +00:00
|
|
|
RangeIterator(): p_range(), p_init(false) {}
|
|
|
|
explicit RangeIterator(T const &range): p_range(), p_init(true) {
|
2015-06-29 22:18:29 +00:00
|
|
|
::new(&get_ref()) T(range);
|
|
|
|
}
|
2016-07-31 19:40:25 +00:00
|
|
|
explicit RangeIterator(T &&range): p_range(), p_init(true) {
|
2015-07-05 22:59:36 +00:00
|
|
|
::new(&get_ref()) T(move(range));
|
2015-06-29 22:18:29 +00:00
|
|
|
}
|
2016-07-31 19:40:25 +00:00
|
|
|
RangeIterator(const RangeIterator &v): p_range(), p_init(true) {
|
|
|
|
::new(&get_ref()) T(v.get_ref());
|
|
|
|
}
|
|
|
|
RangeIterator(RangeIterator &&v): p_range(), p_init(true) {
|
|
|
|
::new(&get_ref()) T(move(v.get_ref()));
|
|
|
|
}
|
|
|
|
RangeIterator &operator=(const RangeIterator &v) {
|
|
|
|
destroy();
|
|
|
|
::new(&get_ref()) T(v.get_ref());
|
|
|
|
p_init = true;
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
RangeIterator &operator=(RangeIterator &&v) {
|
|
|
|
destroy();
|
|
|
|
swap(v);
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
~RangeIterator() {
|
|
|
|
destroy();
|
|
|
|
}
|
2015-06-03 22:55:11 +00:00
|
|
|
RangeIterator &operator++() {
|
2015-06-29 22:18:29 +00:00
|
|
|
get_ref().pop_front();
|
2015-04-24 17:16:35 +00:00
|
|
|
return *this;
|
|
|
|
}
|
2015-06-04 21:57:06 +00:00
|
|
|
RangeReference<T> operator*() const {
|
2015-06-29 22:18:29 +00:00
|
|
|
return get_ref().front();
|
2015-04-24 17:16:35 +00:00
|
|
|
}
|
2015-06-29 22:18:29 +00:00
|
|
|
bool operator!=(RangeIterator) const { return !get_ref().empty(); }
|
2016-07-31 19:40:25 +00:00
|
|
|
void swap(RangeIterator &v) {
|
|
|
|
detail::swap_adl(get_ref(). v.get_ref());
|
|
|
|
detail::swap_adl(p_init, v.p_init);
|
|
|
|
}
|
2015-04-24 17:16:35 +00:00
|
|
|
private:
|
2016-07-02 03:56:23 +00:00
|
|
|
T &get_ref() { return *reinterpret_cast<T *>(&p_range); }
|
|
|
|
T const &get_ref() const { return *reinterpret_cast<T const *>(&p_range); }
|
2016-07-31 19:40:25 +00:00
|
|
|
void destroy() {
|
|
|
|
if (p_init) {
|
|
|
|
get_ref().~T();
|
|
|
|
p_init = false;
|
|
|
|
}
|
|
|
|
}
|
2015-07-05 22:59:36 +00:00
|
|
|
AlignedStorage<sizeof(T), alignof(T)> p_range;
|
2016-07-31 19:40:25 +00:00
|
|
|
bool p_init;
|
2015-04-24 17:16:35 +00:00
|
|
|
};
|
2015-06-03 22:55:11 +00:00
|
|
|
}
|
2015-04-15 23:18:00 +00:00
|
|
|
|
2015-06-03 22:55:11 +00:00
|
|
|
// range half
|
2015-05-29 22:32:25 +00:00
|
|
|
|
2016-07-31 19:40:25 +00:00
|
|
|
template<typename T>
|
|
|
|
struct HalfRange;
|
2015-06-09 23:12:52 +00:00
|
|
|
|
2015-06-14 03:53:23 +00:00
|
|
|
namespace detail {
|
2016-01-13 17:42:37 +00:00
|
|
|
template<typename R, bool = IsBidirectionalRange<typename R::Range>>
|
2015-06-14 03:53:23 +00:00
|
|
|
struct RangeAdd;
|
|
|
|
|
|
|
|
template<typename R>
|
|
|
|
struct RangeAdd<R, true> {
|
|
|
|
using Diff = RangeDifference<typename R::Range>;
|
|
|
|
|
|
|
|
static Diff add_n(R &half, Diff n) {
|
2016-07-31 19:40:25 +00:00
|
|
|
if (n < 0) {
|
|
|
|
return -half.prev_n(n);
|
|
|
|
}
|
2015-06-14 03:53:23 +00:00
|
|
|
return half.next_n(n);
|
|
|
|
}
|
|
|
|
static Diff sub_n(R &half, Diff n) {
|
2016-07-31 19:40:25 +00:00
|
|
|
if (n < 0) {
|
|
|
|
return -half.next_n(n);
|
|
|
|
}
|
2015-06-14 03:53:23 +00:00
|
|
|
return half.prev_n(n);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
template<typename R>
|
|
|
|
struct RangeAdd<R, false> {
|
|
|
|
using Diff = RangeDifference<typename R::Range>;
|
|
|
|
|
|
|
|
static Diff add_n(R &half, Diff n) {
|
2016-07-31 19:40:25 +00:00
|
|
|
if (n < 0) {
|
|
|
|
return 0;
|
|
|
|
}
|
2015-06-14 03:53:23 +00:00
|
|
|
return half.next_n(n);
|
|
|
|
}
|
|
|
|
static Diff sub_n(R &half, Diff n) {
|
2016-07-31 19:40:25 +00:00
|
|
|
if (n < 0) {
|
|
|
|
return 0;
|
|
|
|
}
|
2015-06-14 03:53:23 +00:00
|
|
|
return half.prev_n(n);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename T>
|
2015-06-03 22:55:11 +00:00
|
|
|
struct RangeHalf {
|
|
|
|
private:
|
2015-06-04 21:57:06 +00:00
|
|
|
T p_range;
|
2015-06-03 22:55:11 +00:00
|
|
|
public:
|
2015-06-07 23:55:08 +00:00
|
|
|
using Range = T;
|
2015-05-29 22:32:25 +00:00
|
|
|
|
2015-06-29 22:33:20 +00:00
|
|
|
RangeHalf() = delete;
|
2016-06-23 18:18:35 +00:00
|
|
|
RangeHalf(T const &range): p_range(range) {}
|
2015-06-25 00:07:11 +00:00
|
|
|
|
2016-01-13 18:09:21 +00:00
|
|
|
template<typename U, typename = EnableIf<IsConvertible<U, T>>>
|
2016-06-23 18:18:35 +00:00
|
|
|
RangeHalf(RangeHalf<U> const &half): p_range(half.p_range) {}
|
2015-06-25 00:07:11 +00:00
|
|
|
|
2016-06-23 18:18:35 +00:00
|
|
|
RangeHalf(RangeHalf const &half): p_range(half.p_range) {}
|
2015-07-05 22:59:36 +00:00
|
|
|
RangeHalf(RangeHalf &&half): p_range(move(half.p_range)) {}
|
2015-05-29 22:32:25 +00:00
|
|
|
|
2016-06-23 18:18:35 +00:00
|
|
|
RangeHalf &operator=(RangeHalf const &half) {
|
2015-06-03 22:55:11 +00:00
|
|
|
p_range = half.p_range;
|
|
|
|
return *this;
|
|
|
|
}
|
2015-05-29 22:32:25 +00:00
|
|
|
|
2015-06-03 22:55:11 +00:00
|
|
|
RangeHalf &operator=(RangeHalf &&half) {
|
2015-07-05 22:59:36 +00:00
|
|
|
p_range = move(half.p_range);
|
2015-06-03 22:55:11 +00:00
|
|
|
return *this;
|
|
|
|
}
|
2015-05-29 22:32:25 +00:00
|
|
|
|
2015-06-03 22:55:11 +00:00
|
|
|
bool next() { return p_range.pop_front(); }
|
|
|
|
bool prev() { return p_range.push_front(); }
|
2015-05-29 22:32:25 +00:00
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
RangeSize<T> next_n(RangeSize<T> n) {
|
2015-06-03 22:55:11 +00:00
|
|
|
return p_range.pop_front_n(n);
|
|
|
|
}
|
2015-06-04 21:57:06 +00:00
|
|
|
RangeSize<T> prev_n(RangeSize<T> n) {
|
2015-06-03 22:55:11 +00:00
|
|
|
return p_range.push_front_n(n);
|
|
|
|
}
|
2015-05-29 22:32:25 +00:00
|
|
|
|
2015-06-14 03:53:23 +00:00
|
|
|
RangeDifference<T> add_n(RangeDifference<T> n) {
|
2015-07-05 22:59:36 +00:00
|
|
|
return detail::RangeAdd<RangeHalf<T>>::add_n(*this, n);
|
2015-06-14 03:53:23 +00:00
|
|
|
}
|
|
|
|
RangeDifference<T> sub_n(RangeDifference<T> n) {
|
2015-07-05 22:59:36 +00:00
|
|
|
return detail::RangeAdd<RangeHalf<T>>::sub_n(*this, n);
|
2015-06-14 03:53:23 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
RangeReference<T> get() const {
|
2015-06-03 22:55:11 +00:00
|
|
|
return p_range.front();
|
|
|
|
}
|
2015-05-29 22:32:25 +00:00
|
|
|
|
2016-06-23 18:18:35 +00:00
|
|
|
RangeDifference<T> distance(RangeHalf const &half) const {
|
2015-06-03 22:55:11 +00:00
|
|
|
return p_range.distance_front(half.p_range);
|
|
|
|
}
|
2015-05-29 22:32:25 +00:00
|
|
|
|
2016-06-23 18:18:35 +00:00
|
|
|
bool equals(RangeHalf const &half) const {
|
2015-06-03 22:55:11 +00:00
|
|
|
return p_range.equals_front(half.p_range);
|
|
|
|
}
|
2015-05-29 22:32:25 +00:00
|
|
|
|
2016-06-23 18:18:35 +00:00
|
|
|
bool operator==(RangeHalf const &half) const {
|
2015-06-03 22:55:11 +00:00
|
|
|
return equals(half);
|
|
|
|
}
|
2016-06-23 18:18:35 +00:00
|
|
|
bool operator!=(RangeHalf const &half) const {
|
2015-06-03 22:55:11 +00:00
|
|
|
return !equals(half);
|
|
|
|
}
|
2015-05-29 22:32:25 +00:00
|
|
|
|
2015-06-03 22:55:11 +00:00
|
|
|
/* iterator like interface */
|
2015-05-29 22:32:25 +00:00
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
RangeReference<T> operator*() const {
|
2015-06-03 22:55:11 +00:00
|
|
|
return get();
|
|
|
|
}
|
2015-05-29 22:32:25 +00:00
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
RangeReference<T> operator[](RangeSize<T> idx) const {
|
2015-06-03 22:55:11 +00:00
|
|
|
return p_range[idx];
|
|
|
|
}
|
2015-05-29 22:32:25 +00:00
|
|
|
|
2015-06-03 22:55:11 +00:00
|
|
|
RangeHalf &operator++() {
|
|
|
|
next();
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
RangeHalf operator++(int) {
|
|
|
|
RangeHalf tmp(*this);
|
|
|
|
next();
|
2015-06-25 17:59:26 +00:00
|
|
|
return tmp;
|
2015-06-03 22:55:11 +00:00
|
|
|
}
|
2015-05-29 22:32:25 +00:00
|
|
|
|
2015-06-03 22:55:11 +00:00
|
|
|
RangeHalf &operator--() {
|
|
|
|
prev();
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
RangeHalf operator--(int) {
|
|
|
|
RangeHalf tmp(*this);
|
|
|
|
prev();
|
2015-06-25 17:59:26 +00:00
|
|
|
return tmp;
|
2015-06-03 22:55:11 +00:00
|
|
|
}
|
2015-05-29 22:32:25 +00:00
|
|
|
|
2015-06-21 21:29:17 +00:00
|
|
|
RangeHalf operator+(RangeDifference<T> n) const {
|
2015-06-03 22:55:11 +00:00
|
|
|
RangeHalf tmp(*this);
|
2015-06-14 03:53:23 +00:00
|
|
|
tmp.add_n(n);
|
2015-06-25 17:59:26 +00:00
|
|
|
return tmp;
|
2015-06-03 22:55:11 +00:00
|
|
|
}
|
2015-06-21 21:29:17 +00:00
|
|
|
RangeHalf operator-(RangeDifference<T> n) const {
|
2015-06-03 22:55:11 +00:00
|
|
|
RangeHalf tmp(*this);
|
2015-06-14 03:53:23 +00:00
|
|
|
tmp.sub_n(n);
|
2015-06-25 17:59:26 +00:00
|
|
|
return tmp;
|
2015-06-03 22:55:11 +00:00
|
|
|
}
|
2015-05-29 22:32:25 +00:00
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
RangeHalf &operator+=(RangeDifference<T> n) {
|
2015-06-14 03:53:23 +00:00
|
|
|
add_n(n);
|
2015-06-03 22:55:11 +00:00
|
|
|
return *this;
|
|
|
|
}
|
2015-06-04 21:57:06 +00:00
|
|
|
RangeHalf &operator-=(RangeDifference<T> n) {
|
2015-06-14 03:53:23 +00:00
|
|
|
sub_n(n);
|
2015-06-03 22:55:11 +00:00
|
|
|
return *this;
|
2015-05-30 00:46:50 +00:00
|
|
|
}
|
2015-06-09 23:12:52 +00:00
|
|
|
|
2015-06-26 20:01:16 +00:00
|
|
|
T iter() const { return p_range; }
|
2015-06-24 19:03:23 +00:00
|
|
|
|
2016-06-23 18:18:35 +00:00
|
|
|
HalfRange<RangeHalf> iter(RangeHalf const &other) const {
|
2015-06-09 23:12:52 +00:00
|
|
|
return HalfRange<RangeHalf>(*this, other);
|
|
|
|
}
|
2015-07-28 01:40:24 +00:00
|
|
|
|
|
|
|
RangeValue<T> *data() { return p_range.data(); }
|
2016-06-23 18:18:35 +00:00
|
|
|
RangeValue<T> const *data() const { return p_range.data(); }
|
2015-06-03 22:55:11 +00:00
|
|
|
};
|
2015-05-30 00:46:50 +00:00
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename R>
|
2016-06-23 18:18:35 +00:00
|
|
|
inline RangeDifference<R> operator-(R const &lhs, R const &rhs) {
|
2015-06-03 22:55:11 +00:00
|
|
|
return rhs.distance(lhs);
|
|
|
|
}
|
|
|
|
|
|
|
|
namespace detail {
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename R>
|
|
|
|
RangeSize<R> pop_front_n(R &range, RangeSize<R> n) {
|
2016-07-31 19:40:25 +00:00
|
|
|
for (RangeSize<R> i = 0; i < n; ++i) {
|
|
|
|
if (!range.pop_front()) {
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
}
|
2015-06-03 22:55:11 +00:00
|
|
|
return n;
|
2015-05-23 16:36:26 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename R>
|
|
|
|
RangeSize<R> pop_back_n(R &range, RangeSize<R> n) {
|
2016-07-31 19:40:25 +00:00
|
|
|
for (RangeSize<R> i = 0; i < n; ++i) {
|
|
|
|
if (!range.pop_back()) {
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
}
|
2015-06-03 22:55:11 +00:00
|
|
|
return n;
|
2015-05-23 16:36:26 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename R>
|
|
|
|
RangeSize<R> push_front_n(R &range, RangeSize<R> n) {
|
2016-07-31 19:40:25 +00:00
|
|
|
for (RangeSize<R> i = 0; i < n; ++i) {
|
|
|
|
if (!range.push_front()) {
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
}
|
2015-06-03 22:55:11 +00:00
|
|
|
return n;
|
2015-05-29 18:52:20 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename R>
|
|
|
|
RangeSize<R> push_back_n(R &range, RangeSize<R> n) {
|
2016-07-31 19:40:25 +00:00
|
|
|
for (RangeSize<R> i = 0; i < n; ++i) {
|
|
|
|
if (!range.push_back()) {
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
}
|
2015-06-03 22:55:11 +00:00
|
|
|
return n;
|
|
|
|
}
|
|
|
|
}
|
2015-05-23 16:36:26 +00:00
|
|
|
|
2016-07-31 19:40:25 +00:00
|
|
|
template<typename>
|
|
|
|
struct ReverseRange;
|
|
|
|
template<typename>
|
|
|
|
struct MoveRange;
|
|
|
|
template<typename>
|
|
|
|
struct EnumeratedRange;
|
|
|
|
template<typename>
|
|
|
|
struct TakeRange;
|
|
|
|
template<typename>
|
|
|
|
struct ChunksRange;
|
|
|
|
template<typename ...>
|
|
|
|
struct JoinRange;
|
|
|
|
template<typename ...>
|
|
|
|
struct ZipRange;
|
|
|
|
|
|
|
|
template<
|
|
|
|
typename B, typename C, typename V, typename R = V &,
|
|
|
|
typename S = Size, typename D = Ptrdiff
|
|
|
|
>
|
|
|
|
struct InputRange {
|
2015-06-07 23:55:08 +00:00
|
|
|
using Category = C;
|
|
|
|
using Size = S;
|
|
|
|
using Difference = D;
|
|
|
|
using Value = V;
|
|
|
|
using Reference = R;
|
2015-06-03 22:55:11 +00:00
|
|
|
|
2015-07-05 22:59:36 +00:00
|
|
|
detail::RangeIterator<B> begin() const {
|
2016-07-02 03:56:23 +00:00
|
|
|
return detail::RangeIterator<B>(*static_cast<B const *>(this));
|
2015-06-03 22:55:11 +00:00
|
|
|
}
|
2015-07-05 22:59:36 +00:00
|
|
|
detail::RangeIterator<B> end() const {
|
|
|
|
return detail::RangeIterator<B>();
|
2015-06-03 22:55:11 +00:00
|
|
|
}
|
2015-05-23 16:36:26 +00:00
|
|
|
|
2015-06-03 22:55:11 +00:00
|
|
|
Size pop_front_n(Size n) {
|
2016-07-02 03:56:23 +00:00
|
|
|
return detail::pop_front_n<B>(*static_cast<B *>(this), n);
|
2015-06-03 22:55:11 +00:00
|
|
|
}
|
2015-05-28 01:38:52 +00:00
|
|
|
|
2015-06-03 22:55:11 +00:00
|
|
|
Size pop_back_n(Size n) {
|
2016-07-02 03:56:23 +00:00
|
|
|
return detail::pop_back_n<B>(*static_cast<B *>(this), n);
|
2015-06-03 22:55:11 +00:00
|
|
|
}
|
2015-05-29 18:52:20 +00:00
|
|
|
|
2015-06-03 22:55:11 +00:00
|
|
|
Size push_front_n(Size n) {
|
2016-07-02 03:56:23 +00:00
|
|
|
return detail::push_front_n<B>(*static_cast<B *>(this), n);
|
2015-06-03 22:55:11 +00:00
|
|
|
}
|
2015-05-29 18:52:20 +00:00
|
|
|
|
2015-06-03 22:55:11 +00:00
|
|
|
Size push_back_n(Size n) {
|
2016-07-02 03:56:23 +00:00
|
|
|
return detail::push_back_n<B>(*static_cast<B *>(this), n);
|
2015-06-03 22:55:11 +00:00
|
|
|
}
|
2015-05-29 22:32:25 +00:00
|
|
|
|
2015-06-26 20:01:16 +00:00
|
|
|
B iter() const {
|
2016-07-02 03:56:23 +00:00
|
|
|
return B(*static_cast<B const *>(this));
|
2015-06-03 22:55:11 +00:00
|
|
|
}
|
2015-04-17 19:14:43 +00:00
|
|
|
|
2015-06-09 23:57:46 +00:00
|
|
|
ReverseRange<B> reverse() const {
|
2015-06-26 20:01:16 +00:00
|
|
|
return ReverseRange<B>(iter());
|
2015-06-09 20:18:43 +00:00
|
|
|
}
|
|
|
|
|
2015-06-09 23:12:52 +00:00
|
|
|
MoveRange<B> movable() const {
|
2015-06-26 20:01:16 +00:00
|
|
|
return MoveRange<B>(iter());
|
2015-06-03 22:55:11 +00:00
|
|
|
}
|
2015-06-09 23:57:46 +00:00
|
|
|
|
2016-04-26 19:13:32 +00:00
|
|
|
EnumeratedRange<B> enumerate() const {
|
|
|
|
return EnumeratedRange<B>(iter());
|
|
|
|
}
|
|
|
|
|
|
|
|
TakeRange<B> take(Size n) const {
|
|
|
|
return TakeRange<B>(iter(), n);
|
|
|
|
}
|
|
|
|
|
|
|
|
ChunksRange<B> chunks(Size n) const {
|
|
|
|
return ChunksRange<B>(iter(), n);
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename R1, typename ...RR>
|
2016-04-26 23:29:55 +00:00
|
|
|
JoinRange<B, R1, RR...> join(R1 r1, RR ...rr) const {
|
2016-04-26 19:13:32 +00:00
|
|
|
return JoinRange<B, R1, RR...>(iter(), move(r1), move(rr)...);
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename R1, typename ...RR>
|
2016-04-26 23:29:55 +00:00
|
|
|
ZipRange<B, R1, RR...> zip(R1 r1, RR ...rr) const {
|
2016-04-26 19:13:32 +00:00
|
|
|
return ZipRange<B, R1, RR...>(iter(), move(r1), move(rr)...);
|
|
|
|
}
|
|
|
|
|
2015-06-09 23:57:46 +00:00
|
|
|
RangeHalf<B> half() const {
|
2015-06-26 20:01:16 +00:00
|
|
|
return RangeHalf<B>(iter());
|
2015-06-09 23:57:46 +00:00
|
|
|
}
|
2015-07-01 20:46:58 +00:00
|
|
|
|
2016-06-23 18:18:35 +00:00
|
|
|
Size put_n(Value const *p, Size n) {
|
2016-07-02 03:56:23 +00:00
|
|
|
B &r = *static_cast<B *>(this);
|
2015-07-01 20:46:58 +00:00
|
|
|
Size on = n;
|
2015-07-02 18:02:59 +00:00
|
|
|
for (; n && r.put(*p++); --n);
|
2015-07-01 20:46:58 +00:00
|
|
|
return (on - n);
|
|
|
|
}
|
|
|
|
|
2016-03-23 22:11:15 +00:00
|
|
|
template<typename OR>
|
|
|
|
EnableIf<IsOutputRange<OR>, Size> copy(OR &&orange, Size n = -1) {
|
2016-07-02 03:56:23 +00:00
|
|
|
B r(*static_cast<B const *>(this));
|
2015-07-01 20:46:58 +00:00
|
|
|
Size on = n;
|
2015-07-01 21:26:56 +00:00
|
|
|
for (; n && !r.empty(); --n) {
|
2016-07-31 19:40:25 +00:00
|
|
|
if (!orange.put(r.front())) {
|
2016-03-23 22:11:15 +00:00
|
|
|
break;
|
2016-07-31 19:40:25 +00:00
|
|
|
}
|
2015-07-01 21:26:56 +00:00
|
|
|
r.pop_front();
|
|
|
|
}
|
2015-07-01 20:46:58 +00:00
|
|
|
return (on - n);
|
|
|
|
}
|
|
|
|
|
2016-03-22 01:13:43 +00:00
|
|
|
Size copy(RemoveCv<Value> *p, Size n = -1) {
|
2016-07-02 03:56:23 +00:00
|
|
|
B r(*static_cast<B const *>(this));
|
2015-07-01 20:46:58 +00:00
|
|
|
Size on = n;
|
2015-07-01 21:26:56 +00:00
|
|
|
for (; n && !r.empty(); --n) {
|
|
|
|
*p++ = r.front();
|
|
|
|
r.pop_front();
|
|
|
|
}
|
2015-07-01 20:46:58 +00:00
|
|
|
return (on - n);
|
|
|
|
}
|
2015-08-31 13:46:36 +00:00
|
|
|
|
|
|
|
/* iterator like interface operating on the front part of the range
|
|
|
|
* this is sometimes convenient as it can be used within expressions */
|
|
|
|
|
|
|
|
Reference operator*() const {
|
2016-07-02 03:56:23 +00:00
|
|
|
return static_cast<B const *>(this)->front();
|
2015-08-31 13:46:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
B &operator++() {
|
2016-07-02 03:56:23 +00:00
|
|
|
static_cast<B *>(this)->pop_front();
|
|
|
|
return *static_cast<B *>(this);
|
2015-08-31 13:46:36 +00:00
|
|
|
}
|
|
|
|
B operator++(int) {
|
2016-07-02 03:56:23 +00:00
|
|
|
B tmp(*static_cast<B const *>(this));
|
|
|
|
static_cast<B *>(this)->pop_front();
|
2015-08-31 13:46:36 +00:00
|
|
|
return tmp;
|
|
|
|
}
|
|
|
|
|
|
|
|
B &operator--() {
|
2016-07-02 03:56:23 +00:00
|
|
|
static_cast<B *>(this)->push_front();
|
|
|
|
return *static_cast<B *>(this);
|
2015-08-31 13:46:36 +00:00
|
|
|
}
|
|
|
|
B operator--(int) {
|
2016-07-02 03:56:23 +00:00
|
|
|
B tmp(*static_cast<B const *>(this));
|
|
|
|
static_cast<B *>(this)->push_front();
|
2015-08-31 13:46:36 +00:00
|
|
|
return tmp;
|
|
|
|
}
|
|
|
|
|
|
|
|
B operator+(Difference n) const {
|
2016-07-02 03:56:23 +00:00
|
|
|
B tmp(*static_cast<B const *>(this));
|
2015-08-31 13:46:36 +00:00
|
|
|
tmp.pop_front_n(n);
|
|
|
|
return tmp;
|
|
|
|
}
|
|
|
|
B operator-(Difference n) const {
|
2016-07-02 03:56:23 +00:00
|
|
|
B tmp(*static_cast<B const *>(this));
|
2015-08-31 13:46:36 +00:00
|
|
|
tmp.push_front_n(n);
|
|
|
|
return tmp;
|
|
|
|
}
|
|
|
|
|
|
|
|
B &operator+=(Difference n) {
|
2016-07-02 03:56:23 +00:00
|
|
|
static_cast<B *>(this)->pop_front_n(n);
|
|
|
|
return *static_cast<B *>(this);
|
2015-08-31 13:46:36 +00:00
|
|
|
}
|
|
|
|
B &operator-=(Difference n) {
|
2016-07-02 03:56:23 +00:00
|
|
|
static_cast<B *>(this)->push_front_n(n);
|
|
|
|
return *static_cast<B *>(this);
|
2015-08-31 13:46:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* universal bool operator */
|
|
|
|
|
2016-07-02 03:56:23 +00:00
|
|
|
explicit operator bool() const {
|
|
|
|
return !(static_cast<B const *>(this)->empty());
|
|
|
|
}
|
2015-06-03 22:55:11 +00:00
|
|
|
};
|
2015-04-17 20:33:01 +00:00
|
|
|
|
2016-04-26 19:13:32 +00:00
|
|
|
template<typename R, typename F, typename = EnableIf<IsInputRange<R>>>
|
2016-04-30 18:21:50 +00:00
|
|
|
inline auto operator|(R &&range, F &&func) {
|
|
|
|
return func(forward<R>(range));
|
2016-04-26 19:13:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
inline auto reverse() {
|
2016-04-30 18:21:50 +00:00
|
|
|
return [](auto &&obj) { return obj.reverse(); };
|
2016-04-26 19:13:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
inline auto movable() {
|
2016-04-30 18:21:50 +00:00
|
|
|
return [](auto &&obj) { return obj.movable(); };
|
2016-04-26 19:13:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
inline auto enumerate() {
|
2016-04-30 18:21:50 +00:00
|
|
|
return [](auto &&obj) { return obj.enumerate(); };
|
2016-04-26 19:13:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
template<typename T>
|
|
|
|
inline auto take(T n) {
|
2016-04-30 18:21:50 +00:00
|
|
|
return [n](auto &&obj) { return obj.take(n); };
|
2016-04-26 19:13:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-09 20:18:43 +00:00
|
|
|
template<typename T>
|
2016-04-26 19:13:32 +00:00
|
|
|
inline auto chunks(T n) {
|
2016-04-30 18:21:50 +00:00
|
|
|
return [n](auto &&obj) { return obj.chunks(n); };
|
2016-04-26 19:13:32 +00:00
|
|
|
}
|
|
|
|
|
2016-04-30 23:34:00 +00:00
|
|
|
namespace detail {
|
|
|
|
template<typename T, typename ...R, Size ...I>
|
2016-04-30 23:53:48 +00:00
|
|
|
inline auto join_proxy(T &&obj, Tuple<R &&...> &&tup, TupleIndices<I...>) {
|
2016-05-02 17:21:54 +00:00
|
|
|
return obj.join(forward<R>(get<I>(forward<Tuple<R &&...>>(tup)))...);
|
2016-04-30 23:34:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
template<typename T, typename ...R, Size ...I>
|
2016-04-30 23:53:48 +00:00
|
|
|
inline auto zip_proxy(T &&obj, Tuple<R &&...> &&tup, TupleIndices<I...>) {
|
2016-05-02 17:21:54 +00:00
|
|
|
return obj.zip(forward<R>(get<I>(forward<Tuple<R &&...>>(tup)))...);
|
2016-04-30 23:34:00 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename R>
|
|
|
|
inline auto join(R &&range) {
|
|
|
|
return [range = forward<R>(range)](auto &&obj) mutable {
|
|
|
|
return obj.join(forward<R>(range));
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2016-04-26 19:13:32 +00:00
|
|
|
template<typename R1, typename ...R>
|
2016-04-30 18:21:50 +00:00
|
|
|
inline auto join(R1 &&r1, R &&...rr) {
|
2016-07-31 19:40:25 +00:00
|
|
|
return [
|
|
|
|
ranges = forward_as_tuple(forward<R1>(r1), forward<R>(rr)...)
|
|
|
|
] (auto &&obj) mutable {
|
2016-04-30 23:34:00 +00:00
|
|
|
using Index = detail::MakeTupleIndices<sizeof...(R) + 1>;
|
2016-07-31 19:40:25 +00:00
|
|
|
return detail::join_proxy(
|
|
|
|
forward<decltype(obj)>(obj),
|
|
|
|
forward<decltype(ranges)>(ranges), Index()
|
|
|
|
);
|
2016-04-30 23:34:00 +00:00
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename R>
|
|
|
|
inline auto zip(R &&range) {
|
|
|
|
return [range = forward<R>(range)](auto &&obj) mutable {
|
|
|
|
return obj.zip(forward<R>(range));
|
|
|
|
};
|
2016-04-26 19:13:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
template<typename R1, typename ...R>
|
2016-04-30 18:21:50 +00:00
|
|
|
inline auto zip(R1 &&r1, R &&...rr) {
|
2016-07-31 19:40:25 +00:00
|
|
|
return [
|
|
|
|
ranges = forward_as_tuple(forward<R1>(r1), forward<R>(rr)...)
|
|
|
|
] (auto &&obj) mutable {
|
2016-04-30 23:34:00 +00:00
|
|
|
using Index = detail::MakeTupleIndices<sizeof...(R) + 1>;
|
2016-07-31 19:40:25 +00:00
|
|
|
return detail::zip_proxy(
|
|
|
|
forward<decltype(obj)>(obj),
|
|
|
|
forward<decltype(ranges)>(ranges), Index()
|
|
|
|
);
|
2016-04-30 23:34:00 +00:00
|
|
|
};
|
2016-04-26 19:13:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
template<typename T>
|
|
|
|
inline auto iter(T &r) -> decltype(r.iter()) {
|
2015-06-26 20:01:16 +00:00
|
|
|
return r.iter();
|
2015-06-09 20:18:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
template<typename T>
|
2016-06-23 18:18:35 +00:00
|
|
|
inline auto iter(T const &r) -> decltype(r.iter()) {
|
2015-06-26 20:01:16 +00:00
|
|
|
return r.iter();
|
2015-06-09 20:18:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
template<typename T>
|
2016-06-23 18:18:35 +00:00
|
|
|
inline auto citer(T const &r) -> decltype(r.iter()) {
|
2015-06-26 20:01:16 +00:00
|
|
|
return r.iter();
|
2015-06-09 20:18:43 +00:00
|
|
|
}
|
|
|
|
|
2016-07-31 19:40:25 +00:00
|
|
|
template<
|
|
|
|
typename B, typename V, typename R = V &,
|
|
|
|
typename S = Size, typename D = Ptrdiff
|
|
|
|
>
|
|
|
|
struct OutputRange {
|
2015-06-07 23:55:08 +00:00
|
|
|
using Category = OutputRangeTag;
|
|
|
|
using Size = S;
|
|
|
|
using Difference = D;
|
|
|
|
using Value = V;
|
|
|
|
using Reference = R;
|
2015-07-01 20:46:58 +00:00
|
|
|
|
2016-06-23 18:18:35 +00:00
|
|
|
Size put_n(Value const *p, Size n) {
|
2016-07-02 03:56:23 +00:00
|
|
|
B &r = *static_cast<B *>(this);
|
2015-07-01 20:46:58 +00:00
|
|
|
Size on = n;
|
2015-07-04 01:18:21 +00:00
|
|
|
for (; n && r.put(*p++); --n);
|
2015-07-01 20:46:58 +00:00
|
|
|
return (on - n);
|
|
|
|
}
|
2015-06-03 22:55:11 +00:00
|
|
|
};
|
2015-04-27 18:53:48 +00:00
|
|
|
|
2015-06-09 23:12:52 +00:00
|
|
|
template<typename T>
|
|
|
|
struct HalfRange: InputRange<HalfRange<T>,
|
2015-06-29 22:33:20 +00:00
|
|
|
RangeCategory<typename T::Range>,
|
|
|
|
RangeValue<typename T::Range>,
|
|
|
|
RangeReference<typename T::Range>,
|
|
|
|
RangeSize<typename T::Range>,
|
|
|
|
RangeDifference<typename T::Range>
|
2015-06-09 23:12:52 +00:00
|
|
|
> {
|
|
|
|
private:
|
2015-06-29 22:33:20 +00:00
|
|
|
using Rtype = typename T::Range;
|
2015-06-09 23:12:52 +00:00
|
|
|
T p_beg;
|
|
|
|
T p_end;
|
|
|
|
public:
|
2015-06-29 22:33:20 +00:00
|
|
|
HalfRange() = delete;
|
2016-07-31 19:40:25 +00:00
|
|
|
HalfRange(HalfRange const &range):
|
|
|
|
p_beg(range.p_beg), p_end(range.p_end)
|
|
|
|
{}
|
|
|
|
HalfRange(HalfRange &&range):
|
|
|
|
p_beg(move(range.p_beg)), p_end(move(range.p_end))
|
|
|
|
{}
|
|
|
|
HalfRange(T const &beg, T const &end):
|
|
|
|
p_beg(beg),p_end(end)
|
|
|
|
{}
|
|
|
|
HalfRange(T &&beg, T &&end):
|
|
|
|
p_beg(move(beg)), p_end(move(end))
|
|
|
|
{}
|
2015-06-09 23:12:52 +00:00
|
|
|
|
2016-06-23 18:18:35 +00:00
|
|
|
HalfRange &operator=(HalfRange const &range) {
|
2015-06-09 23:12:52 +00:00
|
|
|
p_beg = range.p_beg;
|
|
|
|
p_end = range.p_end;
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
HalfRange &operator=(HalfRange &&range) {
|
2015-07-05 22:59:36 +00:00
|
|
|
p_beg = move(range.p_beg);
|
|
|
|
p_end = move(range.p_end);
|
2015-06-09 23:12:52 +00:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool empty() const { return p_beg == p_end; }
|
|
|
|
|
|
|
|
bool pop_front() {
|
2016-07-31 19:40:25 +00:00
|
|
|
if (empty()) {
|
|
|
|
return false;
|
|
|
|
}
|
2015-06-09 23:12:52 +00:00
|
|
|
return p_beg.next();
|
|
|
|
}
|
|
|
|
bool push_front() {
|
|
|
|
return p_beg.prev();
|
|
|
|
}
|
|
|
|
bool pop_back() {
|
2016-07-31 19:40:25 +00:00
|
|
|
if (empty()) {
|
|
|
|
return false;
|
|
|
|
}
|
2015-06-09 23:12:52 +00:00
|
|
|
return p_end.prev();
|
|
|
|
}
|
|
|
|
bool push_back() {
|
|
|
|
return p_end.next();
|
|
|
|
}
|
|
|
|
|
2015-06-29 22:33:20 +00:00
|
|
|
RangeReference<Rtype> front() const { return *p_beg; }
|
|
|
|
RangeReference<Rtype> back() const { return *(p_end - 1); }
|
2015-06-09 23:12:52 +00:00
|
|
|
|
2016-06-23 18:18:35 +00:00
|
|
|
bool equals_front(HalfRange const &range) const {
|
2015-06-09 23:12:52 +00:00
|
|
|
return p_beg == range.p_beg;
|
|
|
|
}
|
2016-06-23 18:18:35 +00:00
|
|
|
bool equals_back(HalfRange const &range) const {
|
2015-06-09 23:12:52 +00:00
|
|
|
return p_end == range.p_end;
|
|
|
|
}
|
|
|
|
|
2016-06-23 18:18:35 +00:00
|
|
|
RangeDifference<Rtype> distance_front(HalfRange const &range) const {
|
2015-06-09 23:12:52 +00:00
|
|
|
return range.p_beg - p_beg;
|
|
|
|
}
|
2016-06-23 18:18:35 +00:00
|
|
|
RangeDifference<Rtype> distance_back(HalfRange const &range) const {
|
2015-06-09 23:12:52 +00:00
|
|
|
return range.p_end - p_end;
|
|
|
|
}
|
|
|
|
|
2015-06-29 22:33:20 +00:00
|
|
|
RangeSize<Rtype> size() const { return p_end - p_beg; }
|
2015-06-09 23:12:52 +00:00
|
|
|
|
2016-07-31 19:40:25 +00:00
|
|
|
HalfRange<Rtype> slice(RangeSize<Rtype> start, RangeSize<Rtype> end) const {
|
2015-12-30 14:13:07 +00:00
|
|
|
return HalfRange<Rtype>(p_beg + start, p_beg + end);
|
2015-06-09 23:12:52 +00:00
|
|
|
}
|
|
|
|
|
2015-06-29 22:33:20 +00:00
|
|
|
RangeReference<Rtype> operator[](RangeSize<Rtype> idx) const {
|
2015-06-09 23:12:52 +00:00
|
|
|
return p_beg[idx];
|
|
|
|
}
|
|
|
|
|
2016-06-23 18:18:35 +00:00
|
|
|
bool put(RangeValue<Rtype> const &v) {
|
2015-07-01 20:12:45 +00:00
|
|
|
return p_beg.range().put(v);
|
2015-06-09 23:12:52 +00:00
|
|
|
}
|
2015-07-01 20:12:45 +00:00
|
|
|
bool put(RangeValue<Rtype> &&v) {
|
2015-07-05 22:59:36 +00:00
|
|
|
return p_beg.range().put(move(v));
|
2015-06-09 23:12:52 +00:00
|
|
|
}
|
2015-07-28 01:40:24 +00:00
|
|
|
|
|
|
|
RangeValue<Rtype> *data() { return p_beg.data(); }
|
2016-06-23 18:18:35 +00:00
|
|
|
RangeValue<Rtype> const *data() const { return p_beg.data(); }
|
2015-06-09 23:12:52 +00:00
|
|
|
};
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename T>
|
|
|
|
struct ReverseRange: InputRange<ReverseRange<T>,
|
2015-07-28 01:40:24 +00:00
|
|
|
CommonType<RangeCategory<T>, FiniteRandomAccessRangeTag>,
|
|
|
|
RangeValue<T>, RangeReference<T>, RangeSize<T>, RangeDifference<T>
|
2015-06-03 22:55:11 +00:00
|
|
|
> {
|
|
|
|
private:
|
2015-06-07 23:55:08 +00:00
|
|
|
using Rref = RangeReference<T>;
|
|
|
|
using Rsize = RangeSize<T>;
|
2015-04-28 17:48:58 +00:00
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
T p_range;
|
2015-04-28 17:48:58 +00:00
|
|
|
|
2015-06-03 22:55:11 +00:00
|
|
|
public:
|
2015-06-29 22:33:20 +00:00
|
|
|
ReverseRange() = delete;
|
2016-06-23 18:18:35 +00:00
|
|
|
ReverseRange(T const &range): p_range(range) {}
|
|
|
|
ReverseRange(ReverseRange const &it): p_range(it.p_range) {}
|
2015-07-05 22:59:36 +00:00
|
|
|
ReverseRange(ReverseRange &&it): p_range(move(it.p_range)) {}
|
2015-04-18 19:31:07 +00:00
|
|
|
|
2016-06-23 18:18:35 +00:00
|
|
|
ReverseRange &operator=(ReverseRange const &v) {
|
2015-06-03 22:55:11 +00:00
|
|
|
p_range = v.p_range;
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
ReverseRange &operator=(ReverseRange &&v) {
|
2015-07-05 22:59:36 +00:00
|
|
|
p_range = move(v.p_range);
|
2015-06-03 22:55:11 +00:00
|
|
|
return *this;
|
|
|
|
}
|
2016-06-23 18:18:35 +00:00
|
|
|
ReverseRange &operator=(T const &v) {
|
2015-06-03 22:55:11 +00:00
|
|
|
p_range = v;
|
|
|
|
return *this;
|
|
|
|
}
|
2015-06-04 21:57:06 +00:00
|
|
|
ReverseRange &operator=(T &&v) {
|
2015-07-05 22:59:36 +00:00
|
|
|
p_range = move(v);
|
2015-06-03 22:55:11 +00:00
|
|
|
return *this;
|
|
|
|
}
|
2015-04-27 18:53:48 +00:00
|
|
|
|
2015-06-03 22:55:11 +00:00
|
|
|
bool empty() const { return p_range.empty(); }
|
2015-06-07 23:55:08 +00:00
|
|
|
Rsize size() const { return p_range.size(); }
|
2015-05-29 22:32:25 +00:00
|
|
|
|
2016-06-23 18:18:35 +00:00
|
|
|
bool equals_front(ReverseRange const &r) const {
|
2016-07-31 19:40:25 +00:00
|
|
|
return p_range.equals_back(r.p_range);
|
2015-06-03 22:55:11 +00:00
|
|
|
}
|
2016-06-23 18:18:35 +00:00
|
|
|
bool equals_back(ReverseRange const &r) const {
|
2015-06-03 22:55:11 +00:00
|
|
|
return p_range.equals_front(r.p_range);
|
|
|
|
}
|
2015-05-29 22:32:25 +00:00
|
|
|
|
2016-06-23 18:18:35 +00:00
|
|
|
RangeDifference<T> distance_front(ReverseRange const &r) const {
|
2015-06-03 22:55:11 +00:00
|
|
|
return -p_range.distance_back(r.p_range);
|
|
|
|
}
|
2016-06-23 18:18:35 +00:00
|
|
|
RangeDifference<T> distance_back(ReverseRange const &r) const {
|
2015-06-03 22:55:11 +00:00
|
|
|
return -p_range.distance_front(r.p_range);
|
|
|
|
}
|
2015-04-16 01:07:32 +00:00
|
|
|
|
2015-06-03 22:55:11 +00:00
|
|
|
bool pop_front() { return p_range.pop_back(); }
|
|
|
|
bool pop_back() { return p_range.pop_front(); }
|
2015-04-16 01:07:32 +00:00
|
|
|
|
2015-06-03 22:55:11 +00:00
|
|
|
bool push_front() { return p_range.push_back(); }
|
|
|
|
bool push_back() { return p_range.push_front(); }
|
2015-05-29 18:52:20 +00:00
|
|
|
|
2015-06-07 23:55:08 +00:00
|
|
|
Rsize pop_front_n(Rsize n) { return p_range.pop_front_n(n); }
|
|
|
|
Rsize pop_back_n(Rsize n) { return p_range.pop_back_n(n); }
|
2015-05-23 16:36:26 +00:00
|
|
|
|
2015-06-07 23:55:08 +00:00
|
|
|
Rsize push_front_n(Rsize n) { return p_range.push_front_n(n); }
|
|
|
|
Rsize push_back_n(Rsize n) { return p_range.push_back_n(n); }
|
2015-04-16 01:07:32 +00:00
|
|
|
|
2015-06-07 23:55:08 +00:00
|
|
|
Rref front() const { return p_range.back(); }
|
|
|
|
Rref back() const { return p_range.front(); }
|
2015-04-16 01:07:32 +00:00
|
|
|
|
2015-06-07 23:55:08 +00:00
|
|
|
Rref operator[](Rsize i) const { return p_range[size() - i - 1]; }
|
2015-04-16 01:07:32 +00:00
|
|
|
|
2015-06-07 23:55:08 +00:00
|
|
|
ReverseRange<T> slice(Rsize start, Rsize end) const {
|
|
|
|
Rsize len = p_range.size();
|
2015-06-04 21:57:06 +00:00
|
|
|
return ReverseRange<T>(p_range.slice(len - end, len - start));
|
2015-04-16 01:07:32 +00:00
|
|
|
}
|
2015-06-03 22:55:11 +00:00
|
|
|
};
|
2015-04-16 22:06:39 +00:00
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename T>
|
|
|
|
struct MoveRange: InputRange<MoveRange<T>,
|
2015-07-28 01:40:24 +00:00
|
|
|
CommonType<RangeCategory<T>, FiniteRandomAccessRangeTag>,
|
|
|
|
RangeValue<T>, RangeValue<T> &&, RangeSize<T>, RangeDifference<T>
|
2015-06-03 22:55:11 +00:00
|
|
|
> {
|
|
|
|
private:
|
2015-06-07 23:55:08 +00:00
|
|
|
using Rval = RangeValue<T>;
|
|
|
|
using Rref = RangeValue<T> &&;
|
|
|
|
using Rsize = RangeSize<T>;
|
2015-04-28 17:48:58 +00:00
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
T p_range;
|
2015-04-16 22:06:39 +00:00
|
|
|
|
2015-06-03 22:55:11 +00:00
|
|
|
public:
|
2015-06-29 22:33:20 +00:00
|
|
|
MoveRange() = delete;
|
2016-06-23 18:18:35 +00:00
|
|
|
MoveRange(T const &range): p_range(range) {}
|
|
|
|
MoveRange(MoveRange const &it): p_range(it.p_range) {}
|
2015-07-05 22:59:36 +00:00
|
|
|
MoveRange(MoveRange &&it): p_range(move(it.p_range)) {}
|
2015-04-16 22:06:39 +00:00
|
|
|
|
2016-06-23 18:18:35 +00:00
|
|
|
MoveRange &operator=(MoveRange const &v) {
|
2015-06-03 22:55:11 +00:00
|
|
|
p_range = v.p_range;
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
MoveRange &operator=(MoveRange &&v) {
|
2015-07-05 22:59:36 +00:00
|
|
|
p_range = move(v.p_range);
|
2015-06-03 22:55:11 +00:00
|
|
|
return *this;
|
|
|
|
}
|
2016-06-23 18:18:35 +00:00
|
|
|
MoveRange &operator=(T const &v) {
|
2015-06-03 22:55:11 +00:00
|
|
|
p_range = v;
|
|
|
|
return *this;
|
|
|
|
}
|
2015-06-04 21:57:06 +00:00
|
|
|
MoveRange &operator=(T &&v) {
|
2015-07-05 22:59:36 +00:00
|
|
|
p_range = move(v);
|
2015-06-03 22:55:11 +00:00
|
|
|
return *this;
|
|
|
|
}
|
2015-05-29 22:32:25 +00:00
|
|
|
|
2015-06-03 22:55:11 +00:00
|
|
|
bool empty() const { return p_range.empty(); }
|
2015-06-07 23:55:08 +00:00
|
|
|
Rsize size() const { return p_range.size(); }
|
2015-05-29 22:32:25 +00:00
|
|
|
|
2016-06-23 18:18:35 +00:00
|
|
|
bool equals_front(MoveRange const &r) const {
|
2015-06-03 22:55:11 +00:00
|
|
|
return p_range.equals_front(r.p_range);
|
|
|
|
}
|
2016-06-23 18:18:35 +00:00
|
|
|
bool equals_back(MoveRange const &r) const {
|
2015-06-03 22:55:11 +00:00
|
|
|
return p_range.equals_back(r.p_range);
|
|
|
|
}
|
2015-04-16 22:06:39 +00:00
|
|
|
|
2016-06-23 18:18:35 +00:00
|
|
|
RangeDifference<T> distance_front(MoveRange const &r) const {
|
2015-06-03 22:55:11 +00:00
|
|
|
return p_range.distance_front(r.p_range);
|
|
|
|
}
|
2016-06-23 18:18:35 +00:00
|
|
|
RangeDifference<T> distance_back(MoveRange const &r) const {
|
2015-06-03 22:55:11 +00:00
|
|
|
return p_range.distance_back(r.p_range);
|
|
|
|
}
|
2015-05-29 18:52:20 +00:00
|
|
|
|
2015-06-03 22:55:11 +00:00
|
|
|
bool pop_front() { return p_range.pop_front(); }
|
|
|
|
bool pop_back() { return p_range.pop_back(); }
|
2015-05-29 18:52:20 +00:00
|
|
|
|
2015-06-03 22:55:11 +00:00
|
|
|
bool push_front() { return p_range.push_front(); }
|
|
|
|
bool push_back() { return p_range.push_back(); }
|
2015-05-23 16:36:26 +00:00
|
|
|
|
2015-06-07 23:55:08 +00:00
|
|
|
Rsize pop_front_n(Rsize n) { return p_range.pop_front_n(n); }
|
|
|
|
Rsize pop_back_n(Rsize n) { return p_range.pop_back_n(n); }
|
2015-04-16 22:06:39 +00:00
|
|
|
|
2015-06-07 23:55:08 +00:00
|
|
|
Rsize push_front_n(Rsize n) { return p_range.push_front_n(n); }
|
|
|
|
Rsize push_back_n(Rsize n) { return p_range.push_back_n(n); }
|
2015-04-16 22:06:39 +00:00
|
|
|
|
2015-07-05 22:59:36 +00:00
|
|
|
Rref front() const { return move(p_range.front()); }
|
|
|
|
Rref back() const { return move(p_range.back()); }
|
2015-04-18 21:05:24 +00:00
|
|
|
|
2015-07-05 22:59:36 +00:00
|
|
|
Rref operator[](Rsize i) const { return move(p_range[i]); }
|
2015-04-16 22:26:10 +00:00
|
|
|
|
2015-06-07 23:55:08 +00:00
|
|
|
MoveRange<T> slice(Rsize start, Rsize end) const {
|
2015-06-04 21:57:06 +00:00
|
|
|
return MoveRange<T>(p_range.slice(start, end));
|
2015-04-16 22:26:10 +00:00
|
|
|
}
|
2015-04-16 23:55:50 +00:00
|
|
|
|
2016-06-23 18:18:35 +00:00
|
|
|
bool put(Rval const &v) { return p_range.put(v); }
|
2015-07-05 22:59:36 +00:00
|
|
|
bool put(Rval &&v) { return p_range.put(move(v)); }
|
2015-06-03 22:55:11 +00:00
|
|
|
};
|
2015-05-29 22:32:25 +00:00
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename T>
|
|
|
|
struct NumberRange: InputRange<NumberRange<T>, ForwardRangeTag, T, T> {
|
2015-06-29 22:33:20 +00:00
|
|
|
NumberRange() = delete;
|
2016-07-31 19:40:25 +00:00
|
|
|
NumberRange(NumberRange const &it):
|
|
|
|
p_a(it.p_a), p_b(it.p_b), p_step(it.p_step)
|
|
|
|
{}
|
|
|
|
NumberRange(T a, T b, T step = T(1)):
|
|
|
|
p_a(a), p_b(b), p_step(step)
|
|
|
|
{}
|
2015-06-04 21:57:06 +00:00
|
|
|
NumberRange(T v): p_a(0), p_b(v), p_step(1) {}
|
2015-04-16 23:55:50 +00:00
|
|
|
|
2015-06-03 22:55:11 +00:00
|
|
|
bool empty() const { return p_a * p_step >= p_b * p_step; }
|
2015-04-17 19:33:36 +00:00
|
|
|
|
2016-06-23 18:18:35 +00:00
|
|
|
bool equals_front(NumberRange const &range) const {
|
2015-06-03 22:55:11 +00:00
|
|
|
return p_a == range.p_a;
|
2015-04-17 19:33:36 +00:00
|
|
|
}
|
2015-04-18 23:02:38 +00:00
|
|
|
|
2015-06-03 22:55:11 +00:00
|
|
|
bool pop_front() { p_a += p_step; return true; }
|
2015-06-04 21:57:06 +00:00
|
|
|
T front() const { return p_a; }
|
2015-05-08 01:03:48 +00:00
|
|
|
|
2015-06-03 22:55:11 +00:00
|
|
|
private:
|
2015-06-04 21:57:06 +00:00
|
|
|
T p_a, p_b, p_step;
|
2015-06-03 22:55:11 +00:00
|
|
|
};
|
2015-04-18 23:02:38 +00:00
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename T>
|
2016-04-26 19:13:32 +00:00
|
|
|
inline NumberRange<T> range(T a, T b, T step = T(1)) {
|
2015-06-04 21:57:06 +00:00
|
|
|
return NumberRange<T>(a, b, step);
|
2015-06-03 22:55:11 +00:00
|
|
|
}
|
2015-04-18 23:02:38 +00:00
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename T>
|
2016-04-26 19:13:32 +00:00
|
|
|
inline NumberRange<T> range(T v) {
|
2015-06-04 21:57:06 +00:00
|
|
|
return NumberRange<T>(v);
|
2015-06-03 22:55:11 +00:00
|
|
|
}
|
2015-05-23 16:36:26 +00:00
|
|
|
|
2015-06-16 23:15:44 +00:00
|
|
|
template<typename T>
|
2015-07-23 00:28:25 +00:00
|
|
|
struct PointerRange: InputRange<PointerRange<T>, ContiguousRangeTag, T> {
|
2015-08-05 01:09:44 +00:00
|
|
|
private:
|
|
|
|
struct Nat {};
|
|
|
|
|
|
|
|
public:
|
2015-07-29 00:37:00 +00:00
|
|
|
PointerRange(): p_beg(nullptr), p_end(nullptr) {}
|
2015-08-05 01:09:44 +00:00
|
|
|
|
|
|
|
template<typename U>
|
|
|
|
PointerRange(T *beg, U end, EnableIf<
|
2016-01-13 18:09:21 +00:00
|
|
|
(IsPointer<U> || IsNullPointer<U>) && IsConvertible<U, T *>, Nat
|
2015-08-05 01:09:44 +00:00
|
|
|
> = Nat()): p_beg(beg), p_end(end) {}
|
|
|
|
|
2015-07-05 22:59:36 +00:00
|
|
|
PointerRange(T *beg, Size n): p_beg(beg), p_end(beg + n) {}
|
2015-06-03 22:55:11 +00:00
|
|
|
|
2016-01-13 18:09:21 +00:00
|
|
|
template<typename U, typename = EnableIf<IsConvertible<U *, T *>>>
|
2016-06-23 18:18:35 +00:00
|
|
|
PointerRange(PointerRange<U> const &v): p_beg(&v[0]), p_end(&v[v.size()]) {}
|
2015-06-16 23:44:41 +00:00
|
|
|
|
2016-06-23 18:18:35 +00:00
|
|
|
PointerRange &operator=(PointerRange const &v) {
|
2015-06-03 22:55:11 +00:00
|
|
|
p_beg = v.p_beg;
|
|
|
|
p_end = v.p_end;
|
|
|
|
return *this;
|
|
|
|
}
|
2015-05-29 18:52:20 +00:00
|
|
|
|
2015-06-03 22:55:11 +00:00
|
|
|
/* satisfy InputRange / ForwardRange */
|
|
|
|
bool empty() const { return p_beg == p_end; }
|
2015-04-18 23:02:38 +00:00
|
|
|
|
2015-06-03 22:55:11 +00:00
|
|
|
bool pop_front() {
|
2016-07-31 19:40:25 +00:00
|
|
|
if (p_beg == p_end) {
|
|
|
|
return false;
|
|
|
|
}
|
2015-06-03 22:55:11 +00:00
|
|
|
++p_beg;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
bool push_front() {
|
|
|
|
--p_beg; return true;
|
|
|
|
}
|
2015-05-29 22:32:25 +00:00
|
|
|
|
2015-07-05 22:59:36 +00:00
|
|
|
Size pop_front_n(Size n) {
|
|
|
|
Size olen = p_end - p_beg;
|
2015-06-03 22:55:11 +00:00
|
|
|
p_beg += n;
|
|
|
|
if (p_beg > p_end) {
|
|
|
|
p_beg = p_end;
|
|
|
|
return olen;
|
2015-05-29 22:32:25 +00:00
|
|
|
}
|
2015-06-03 22:55:11 +00:00
|
|
|
return n;
|
|
|
|
}
|
2015-05-29 22:32:25 +00:00
|
|
|
|
2015-07-05 22:59:36 +00:00
|
|
|
Size push_front_n(Size n) {
|
2015-06-03 22:55:11 +00:00
|
|
|
p_beg -= n; return true;
|
|
|
|
}
|
2015-04-18 23:02:38 +00:00
|
|
|
|
2015-06-16 23:15:44 +00:00
|
|
|
T &front() const { return *p_beg; }
|
2015-05-23 16:36:26 +00:00
|
|
|
|
2016-06-23 18:18:35 +00:00
|
|
|
bool equals_front(PointerRange const &range) const {
|
2015-06-03 22:55:11 +00:00
|
|
|
return p_beg == range.p_beg;
|
|
|
|
}
|
2015-05-29 18:52:20 +00:00
|
|
|
|
2016-06-23 18:18:35 +00:00
|
|
|
Ptrdiff distance_front(PointerRange const &range) const {
|
2015-06-03 22:55:11 +00:00
|
|
|
return range.p_beg - p_beg;
|
|
|
|
}
|
2015-04-18 23:02:38 +00:00
|
|
|
|
2015-06-03 22:55:11 +00:00
|
|
|
/* satisfy BidirectionalRange */
|
|
|
|
bool pop_back() {
|
2016-07-31 19:40:25 +00:00
|
|
|
if (p_end == p_beg) {
|
|
|
|
return false;
|
|
|
|
}
|
2015-06-03 22:55:11 +00:00
|
|
|
--p_end;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
bool push_back() {
|
|
|
|
++p_end; return true;
|
|
|
|
}
|
2015-05-29 22:32:25 +00:00
|
|
|
|
2015-07-05 22:59:36 +00:00
|
|
|
Size pop_back_n(Size n) {
|
|
|
|
Size olen = p_end - p_beg;
|
2015-06-03 22:55:11 +00:00
|
|
|
p_end -= n;
|
|
|
|
if (p_end < p_beg) {
|
|
|
|
p_end = p_beg;
|
|
|
|
return olen;
|
2015-05-29 22:32:25 +00:00
|
|
|
}
|
2015-06-03 22:55:11 +00:00
|
|
|
return n;
|
|
|
|
}
|
2015-05-29 22:32:25 +00:00
|
|
|
|
2015-07-05 22:59:36 +00:00
|
|
|
Size push_back_n(Size n) {
|
2015-06-03 22:55:11 +00:00
|
|
|
p_end += n; return true;
|
|
|
|
}
|
2015-04-18 23:02:38 +00:00
|
|
|
|
2015-06-16 23:15:44 +00:00
|
|
|
T &back() const { return *(p_end - 1); }
|
2015-04-18 23:02:38 +00:00
|
|
|
|
2016-06-23 18:18:35 +00:00
|
|
|
bool equals_back(PointerRange const &range) const {
|
2015-06-03 22:55:11 +00:00
|
|
|
return p_end == range.p_end;
|
|
|
|
}
|
2015-04-18 23:02:38 +00:00
|
|
|
|
2016-06-23 18:18:35 +00:00
|
|
|
Ptrdiff distance_back(PointerRange const &range) const {
|
2015-06-03 22:55:11 +00:00
|
|
|
return range.p_end - p_end;
|
|
|
|
}
|
2015-04-21 16:56:36 +00:00
|
|
|
|
2015-06-03 22:55:11 +00:00
|
|
|
/* satisfy FiniteRandomAccessRange */
|
2015-07-05 22:59:36 +00:00
|
|
|
Size size() const { return p_end - p_beg; }
|
2015-04-21 16:58:36 +00:00
|
|
|
|
2015-07-05 22:59:36 +00:00
|
|
|
PointerRange slice(Size start, Size end) const {
|
2015-06-03 22:55:11 +00:00
|
|
|
return PointerRange(p_beg + start, p_beg + end);
|
|
|
|
}
|
2015-04-21 16:58:36 +00:00
|
|
|
|
2015-07-05 22:59:36 +00:00
|
|
|
T &operator[](Size i) const { return p_beg[i]; }
|
2015-04-27 18:53:48 +00:00
|
|
|
|
2015-06-03 22:55:11 +00:00
|
|
|
/* satisfy OutputRange */
|
2016-06-23 18:18:35 +00:00
|
|
|
bool put(T const &v) {
|
2016-07-31 19:40:25 +00:00
|
|
|
if (empty()) {
|
|
|
|
return false;
|
|
|
|
}
|
2015-06-03 22:55:11 +00:00
|
|
|
*(p_beg++) = v;
|
2015-07-01 20:12:45 +00:00
|
|
|
return true;
|
2015-06-03 22:55:11 +00:00
|
|
|
}
|
2015-07-01 20:12:45 +00:00
|
|
|
bool put(T &&v) {
|
2016-07-31 19:40:25 +00:00
|
|
|
if (empty()) {
|
|
|
|
return false;
|
|
|
|
}
|
2015-07-05 22:59:36 +00:00
|
|
|
*(p_beg++) = move(v);
|
2015-07-01 20:12:45 +00:00
|
|
|
return true;
|
2015-06-03 22:55:11 +00:00
|
|
|
}
|
2015-04-28 17:48:58 +00:00
|
|
|
|
2016-06-23 18:18:35 +00:00
|
|
|
Size put_n(T const *p, Size n) {
|
2015-07-05 22:59:36 +00:00
|
|
|
Size ret = size();
|
2016-07-31 19:40:25 +00:00
|
|
|
if (n < ret) {
|
|
|
|
ret = n;
|
|
|
|
}
|
2016-01-12 21:45:26 +00:00
|
|
|
if (IsPod<T>) {
|
2015-07-01 20:46:58 +00:00
|
|
|
memcpy(p_beg, p, ret * sizeof(T));
|
|
|
|
p_beg += ret;
|
|
|
|
return ret;
|
|
|
|
}
|
2016-07-31 19:40:25 +00:00
|
|
|
for (Size i = ret; i; --i) {
|
2015-07-01 20:46:58 +00:00
|
|
|
*p_beg++ = *p++;
|
2016-07-31 19:40:25 +00:00
|
|
|
}
|
2015-07-01 20:46:58 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-03-23 22:11:15 +00:00
|
|
|
template<typename R>
|
|
|
|
EnableIf<IsOutputRange<R>, Size> copy(R &&orange, Size n = -1) {
|
2015-07-05 22:59:36 +00:00
|
|
|
Size c = size();
|
2016-07-31 19:40:25 +00:00
|
|
|
if (n < c) {
|
|
|
|
c = n;
|
|
|
|
}
|
2015-07-01 20:46:58 +00:00
|
|
|
return orange.put_n(p_beg, c);
|
|
|
|
}
|
|
|
|
|
2016-03-22 01:13:43 +00:00
|
|
|
Size copy(RemoveCv<T> *p, Size n = -1) {
|
2015-07-05 22:59:36 +00:00
|
|
|
Size c = size();
|
2016-07-31 19:40:25 +00:00
|
|
|
if (n < c) {
|
|
|
|
c = n;
|
|
|
|
}
|
2016-03-23 22:11:15 +00:00
|
|
|
if (IsPod<T>) {
|
|
|
|
memcpy(p_beg, data(), c * sizeof(T));
|
|
|
|
return c;
|
|
|
|
}
|
2015-07-01 21:32:41 +00:00
|
|
|
return copy(PointerRange(p, c), c);
|
2015-07-01 20:46:58 +00:00
|
|
|
}
|
|
|
|
|
2015-07-23 00:32:22 +00:00
|
|
|
T *data() { return p_beg; }
|
2016-06-23 18:18:35 +00:00
|
|
|
T const *data() const { return p_beg; }
|
2015-07-23 00:32:22 +00:00
|
|
|
|
2015-06-03 22:55:11 +00:00
|
|
|
private:
|
2015-06-16 23:15:44 +00:00
|
|
|
T *p_beg, *p_end;
|
2015-06-03 22:55:11 +00:00
|
|
|
};
|
2015-04-28 17:48:58 +00:00
|
|
|
|
2015-07-05 22:59:36 +00:00
|
|
|
template<typename T, Size N>
|
2016-04-26 19:13:32 +00:00
|
|
|
inline PointerRange<T> iter(T (&array)[N]) {
|
2015-06-09 20:18:43 +00:00
|
|
|
return PointerRange<T>(array, N);
|
|
|
|
}
|
|
|
|
|
2016-01-23 17:38:41 +00:00
|
|
|
template<typename T, Size N>
|
2016-06-23 18:18:35 +00:00
|
|
|
inline PointerRange<T const> iter(T const (&array)[N]) {
|
|
|
|
return PointerRange<T const>(array, N);
|
2016-01-23 17:38:41 +00:00
|
|
|
}
|
|
|
|
|
2015-08-07 01:36:58 +00:00
|
|
|
namespace detail {
|
|
|
|
struct PtrNat {};
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename T, typename U>
|
2016-04-26 19:13:32 +00:00
|
|
|
inline PointerRange<T> iter(T *a, U b, EnableIf<
|
2016-01-13 18:09:21 +00:00
|
|
|
(IsPointer<U> || IsNullPointer<U>) && IsConvertible<U, T *>, detail::PtrNat
|
2015-08-07 01:36:58 +00:00
|
|
|
> = detail::PtrNat()) {
|
|
|
|
return PointerRange<T>(a, b);
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename T>
|
2016-04-26 19:13:32 +00:00
|
|
|
inline PointerRange<T> iter(T *a, ostd::Size b) {
|
2015-08-07 01:36:58 +00:00
|
|
|
return PointerRange<T>(a, b);
|
2015-07-04 02:20:51 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename T, typename S>
|
2015-06-03 22:55:11 +00:00
|
|
|
struct EnumeratedValue {
|
2015-06-04 21:57:06 +00:00
|
|
|
S index;
|
|
|
|
T value;
|
2015-06-03 22:55:11 +00:00
|
|
|
};
|
2015-04-28 17:48:58 +00:00
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename T>
|
|
|
|
struct EnumeratedRange: InputRange<EnumeratedRange<T>,
|
|
|
|
CommonType<RangeCategory<T>, ForwardRangeTag>, RangeValue<T>,
|
|
|
|
EnumeratedValue<RangeReference<T>, RangeSize<T>>,
|
|
|
|
RangeSize<T>
|
2015-06-03 22:55:11 +00:00
|
|
|
> {
|
|
|
|
private:
|
2015-06-07 23:55:08 +00:00
|
|
|
using Rref = RangeReference<T>;
|
|
|
|
using Rsize = RangeSize<T>;
|
2015-04-21 16:58:36 +00:00
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
T p_range;
|
2015-06-07 23:55:08 +00:00
|
|
|
Rsize p_index;
|
2015-04-28 17:48:58 +00:00
|
|
|
|
2015-06-03 22:55:11 +00:00
|
|
|
public:
|
2015-06-29 22:33:20 +00:00
|
|
|
EnumeratedRange() = delete;
|
2015-04-21 16:58:36 +00:00
|
|
|
|
2016-06-23 18:18:35 +00:00
|
|
|
EnumeratedRange(T const &range): p_range(range), p_index(0) {}
|
2015-04-21 16:58:36 +00:00
|
|
|
|
2016-06-23 18:18:35 +00:00
|
|
|
EnumeratedRange(EnumeratedRange const &it):
|
2016-07-31 19:40:25 +00:00
|
|
|
p_range(it.p_range), p_index(it.p_index)
|
|
|
|
{}
|
2015-05-29 22:32:25 +00:00
|
|
|
|
2015-06-03 22:55:11 +00:00
|
|
|
EnumeratedRange(EnumeratedRange &&it):
|
2016-07-31 19:40:25 +00:00
|
|
|
p_range(move(it.p_range)), p_index(it.p_index)
|
|
|
|
{}
|
2015-04-21 16:58:36 +00:00
|
|
|
|
2016-06-23 18:18:35 +00:00
|
|
|
EnumeratedRange &operator=(EnumeratedRange const &v) {
|
2015-06-03 22:55:11 +00:00
|
|
|
p_range = v.p_range;
|
|
|
|
p_index = v.p_index;
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
EnumeratedRange &operator=(EnumeratedRange &&v) {
|
2015-07-05 22:59:36 +00:00
|
|
|
p_range = move(v.p_range);
|
2015-06-03 22:55:11 +00:00
|
|
|
p_index = v.p_index;
|
|
|
|
return *this;
|
|
|
|
}
|
2016-06-23 18:18:35 +00:00
|
|
|
EnumeratedRange &operator=(T const &v) {
|
2015-06-03 22:55:11 +00:00
|
|
|
p_range = v;
|
|
|
|
p_index = 0;
|
|
|
|
return *this;
|
|
|
|
}
|
2015-06-04 21:57:06 +00:00
|
|
|
EnumeratedRange &operator=(T &&v) {
|
2015-07-05 22:59:36 +00:00
|
|
|
p_range = move(v);
|
2015-06-03 22:55:11 +00:00
|
|
|
p_index = 0;
|
|
|
|
return *this;
|
|
|
|
}
|
2015-05-23 16:36:26 +00:00
|
|
|
|
2015-06-03 22:55:11 +00:00
|
|
|
bool empty() const { return p_range.empty(); }
|
2015-04-21 16:58:36 +00:00
|
|
|
|
2016-06-23 18:18:35 +00:00
|
|
|
bool equals_front(EnumeratedRange const &r) const {
|
2015-06-03 22:55:11 +00:00
|
|
|
return p_range.equals_front(r.p_range);
|
2015-04-21 16:58:36 +00:00
|
|
|
}
|
2015-05-26 18:25:20 +00:00
|
|
|
|
2015-06-03 22:55:11 +00:00
|
|
|
bool pop_front() {
|
|
|
|
if (p_range.pop_front()) {
|
|
|
|
++p_index;
|
|
|
|
return true;
|
2015-05-27 19:45:34 +00:00
|
|
|
}
|
2015-06-03 22:55:11 +00:00
|
|
|
return false;
|
|
|
|
}
|
2015-05-27 19:45:34 +00:00
|
|
|
|
2015-06-07 23:55:08 +00:00
|
|
|
Rsize pop_front_n(Rsize n) {
|
|
|
|
Rsize ret = p_range.pop_front_n(n);
|
2015-06-03 22:55:11 +00:00
|
|
|
p_index += ret;
|
|
|
|
return ret;
|
|
|
|
}
|
2015-05-27 19:45:34 +00:00
|
|
|
|
2015-06-07 23:55:08 +00:00
|
|
|
EnumeratedValue<Rref, Rsize> front() const {
|
|
|
|
return EnumeratedValue<Rref, Rsize> { p_index, p_range.front() };
|
2015-06-03 22:55:11 +00:00
|
|
|
}
|
|
|
|
};
|
2015-05-29 18:52:20 +00:00
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename T>
|
|
|
|
struct TakeRange: InputRange<TakeRange<T>,
|
|
|
|
CommonType<RangeCategory<T>, ForwardRangeTag>,
|
|
|
|
RangeValue<T>, RangeReference<T>, RangeSize<T>
|
2015-06-03 22:55:11 +00:00
|
|
|
> {
|
|
|
|
private:
|
2015-06-04 21:57:06 +00:00
|
|
|
T p_range;
|
|
|
|
RangeSize<T> p_remaining;
|
2015-06-03 22:55:11 +00:00
|
|
|
public:
|
2015-06-29 22:33:20 +00:00
|
|
|
TakeRange() = delete;
|
2016-07-31 19:40:25 +00:00
|
|
|
TakeRange(T const &range, RangeSize<T> rem):
|
|
|
|
p_range(range), p_remaining(rem)
|
|
|
|
{}
|
|
|
|
TakeRange(TakeRange const &it):
|
|
|
|
p_range(it.p_range), p_remaining(it.p_remaining)
|
|
|
|
{}
|
|
|
|
TakeRange(TakeRange &&it):
|
|
|
|
p_range(move(it.p_range)), p_remaining(it.p_remaining)
|
|
|
|
{}
|
2015-06-03 22:55:11 +00:00
|
|
|
|
2016-06-23 18:18:35 +00:00
|
|
|
TakeRange &operator=(TakeRange const &v) {
|
2015-06-03 22:55:11 +00:00
|
|
|
p_range = v.p_range; p_remaining = v.p_remaining; return *this;
|
|
|
|
}
|
|
|
|
TakeRange &operator=(TakeRange &&v) {
|
2015-07-05 22:59:36 +00:00
|
|
|
p_range = move(v.p_range);
|
2015-06-03 22:55:11 +00:00
|
|
|
p_remaining = v.p_remaining;
|
|
|
|
return *this;
|
|
|
|
}
|
2015-05-27 19:45:34 +00:00
|
|
|
|
2015-06-03 22:55:11 +00:00
|
|
|
bool empty() const { return (p_remaining <= 0) || p_range.empty(); }
|
2015-05-27 19:45:34 +00:00
|
|
|
|
2015-06-03 22:55:11 +00:00
|
|
|
bool pop_front() {
|
|
|
|
if (p_range.pop_front()) {
|
|
|
|
--p_remaining;
|
|
|
|
return true;
|
2015-05-27 19:45:34 +00:00
|
|
|
}
|
2015-06-03 22:55:11 +00:00
|
|
|
return false;
|
2015-05-27 19:45:34 +00:00
|
|
|
}
|
2015-05-27 19:56:44 +00:00
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
RangeSize<T> pop_front_n(RangeSize<T> n) {
|
|
|
|
RangeSize<T> ret = p_range.pop_front_n(n);
|
2015-06-03 22:55:11 +00:00
|
|
|
p_remaining -= ret;
|
|
|
|
return ret;
|
|
|
|
}
|
2015-05-29 22:32:25 +00:00
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
RangeReference<T> front() const { return p_range.front(); }
|
2015-05-27 19:56:44 +00:00
|
|
|
|
2016-06-23 18:18:35 +00:00
|
|
|
bool equals_front(TakeRange const &r) const {
|
2015-06-03 22:55:11 +00:00
|
|
|
return p_range.equals_front(r.p_range);
|
|
|
|
}
|
|
|
|
};
|
2015-05-27 19:56:44 +00:00
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename T>
|
|
|
|
struct ChunksRange: InputRange<ChunksRange<T>,
|
|
|
|
CommonType<RangeCategory<T>, ForwardRangeTag>,
|
|
|
|
TakeRange<T>, TakeRange<T>, RangeSize<T>
|
2015-06-03 22:55:11 +00:00
|
|
|
> {
|
|
|
|
private:
|
2015-06-04 21:57:06 +00:00
|
|
|
T p_range;
|
|
|
|
RangeSize<T> p_chunksize;
|
2015-06-03 22:55:11 +00:00
|
|
|
public:
|
2015-06-29 22:33:20 +00:00
|
|
|
ChunksRange() = delete;
|
2016-07-31 19:40:25 +00:00
|
|
|
ChunksRange(T const &range, RangeSize<T> chs):
|
|
|
|
p_range(range), p_chunksize(chs)
|
|
|
|
{}
|
|
|
|
ChunksRange(ChunksRange const &it):
|
|
|
|
p_range(it.p_range), p_chunksize(it.p_chunksize)
|
|
|
|
{}
|
|
|
|
ChunksRange(ChunksRange &&it):
|
|
|
|
p_range(move(it.p_range)), p_chunksize(it.p_chunksize)
|
|
|
|
{}
|
2015-06-03 22:55:11 +00:00
|
|
|
|
2016-06-23 18:18:35 +00:00
|
|
|
ChunksRange &operator=(ChunksRange const &v) {
|
2015-06-03 22:55:11 +00:00
|
|
|
p_range = v.p_range; p_chunksize = v.p_chunksize; return *this;
|
|
|
|
}
|
|
|
|
ChunksRange &operator=(ChunksRange &&v) {
|
2015-07-05 22:59:36 +00:00
|
|
|
p_range = move(v.p_range);
|
2015-06-03 22:55:11 +00:00
|
|
|
p_chunksize = v.p_chunksize;
|
|
|
|
return *this;
|
2015-05-26 18:25:20 +00:00
|
|
|
}
|
|
|
|
|
2015-06-03 22:55:11 +00:00
|
|
|
bool empty() const { return p_range.empty(); }
|
|
|
|
|
2016-06-23 18:18:35 +00:00
|
|
|
bool equals_front(ChunksRange const &r) const {
|
2015-06-03 22:55:11 +00:00
|
|
|
return p_range.equals_front(r.p_range);
|
2015-05-26 18:25:20 +00:00
|
|
|
}
|
|
|
|
|
2015-06-03 22:55:11 +00:00
|
|
|
bool pop_front() { return p_range.pop_front_n(p_chunksize) > 0; }
|
2015-06-04 21:57:06 +00:00
|
|
|
RangeSize<T> pop_front_n(RangeSize<T> n) {
|
2015-06-03 22:55:11 +00:00
|
|
|
return p_range.pop_front_n(p_chunksize * n) / p_chunksize;
|
|
|
|
}
|
2015-05-29 22:32:25 +00:00
|
|
|
|
2016-04-26 19:13:32 +00:00
|
|
|
TakeRange<T> front() const { return p_range.take(p_chunksize); }
|
2015-06-03 22:55:11 +00:00
|
|
|
};
|
2015-05-31 23:33:59 +00:00
|
|
|
|
2016-03-27 20:06:00 +00:00
|
|
|
namespace detail {
|
|
|
|
template<Size I, Size N>
|
2016-03-27 22:49:27 +00:00
|
|
|
struct JoinRangeEmpty {
|
2016-03-27 20:06:00 +00:00
|
|
|
template<typename T>
|
2016-06-23 18:18:35 +00:00
|
|
|
static bool empty(T const &tup) {
|
2016-07-31 19:40:25 +00:00
|
|
|
if (!ostd::get<I>(tup).empty()) {
|
2016-03-27 20:06:00 +00:00
|
|
|
return false;
|
2016-07-31 19:40:25 +00:00
|
|
|
}
|
2016-03-27 22:49:27 +00:00
|
|
|
return JoinRangeEmpty<I + 1, N>::empty(tup);
|
2016-03-27 20:06:00 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
template<Size N>
|
2016-03-27 22:49:27 +00:00
|
|
|
struct JoinRangeEmpty<N, N> {
|
2016-03-27 20:06:00 +00:00
|
|
|
template<typename T>
|
2016-06-23 18:18:35 +00:00
|
|
|
static bool empty(T const &) {
|
2016-03-27 20:06:00 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
template<Size I, Size N>
|
2016-03-27 22:49:27 +00:00
|
|
|
struct TupleRangeEqual {
|
2016-03-27 20:06:00 +00:00
|
|
|
template<typename T>
|
2016-06-23 18:18:35 +00:00
|
|
|
static bool equal(T const &tup1, T const &tup2) {
|
2016-07-31 19:40:25 +00:00
|
|
|
if (!ostd::get<I>(tup1).equals_front(ostd::get<I>(tup2))) {
|
2016-03-27 20:06:00 +00:00
|
|
|
return false;
|
2016-07-31 19:40:25 +00:00
|
|
|
}
|
2016-03-27 22:49:27 +00:00
|
|
|
return TupleRangeEqual<I + 1, N>::equal(tup1, tup2);
|
2016-03-27 20:06:00 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
template<Size N>
|
2016-03-27 22:49:27 +00:00
|
|
|
struct TupleRangeEqual<N, N> {
|
2016-03-27 20:06:00 +00:00
|
|
|
template<typename T>
|
2016-06-23 18:18:35 +00:00
|
|
|
static bool equal(T const &, T const &) {
|
2016-03-27 20:06:00 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
template<Size I, Size N>
|
2016-03-27 22:49:27 +00:00
|
|
|
struct JoinRangePop {
|
2016-03-27 20:06:00 +00:00
|
|
|
template<typename T>
|
|
|
|
static bool pop(T &tup) {
|
|
|
|
if (!ostd::get<I>(tup).empty()) {
|
|
|
|
return ostd::get<I>(tup).pop_front();
|
|
|
|
}
|
2016-03-27 22:49:27 +00:00
|
|
|
return JoinRangePop<I + 1, N>::pop(tup);
|
2016-03-27 20:06:00 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
template<Size N>
|
2016-03-27 22:49:27 +00:00
|
|
|
struct JoinRangePop<N, N> {
|
2016-03-27 20:06:00 +00:00
|
|
|
template<typename T>
|
|
|
|
static bool pop(T &) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
template<Size I, Size N, typename T>
|
2016-03-27 22:49:27 +00:00
|
|
|
struct JoinRangeFront {
|
2016-03-27 20:06:00 +00:00
|
|
|
template<typename U>
|
2016-06-23 18:18:35 +00:00
|
|
|
static T front(U const &tup) {
|
2016-03-27 20:06:00 +00:00
|
|
|
if (!ostd::get<I>(tup).empty()) {
|
|
|
|
return ostd::get<I>(tup).front();
|
|
|
|
}
|
2016-03-27 22:49:27 +00:00
|
|
|
return JoinRangeFront<I + 1, N, T>::front(tup);
|
2016-03-27 20:06:00 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
template<Size N, typename T>
|
2016-03-27 22:49:27 +00:00
|
|
|
struct JoinRangeFront<N, N, T> {
|
2016-03-27 20:06:00 +00:00
|
|
|
template<typename U>
|
2016-06-23 18:18:35 +00:00
|
|
|
static T front(U const &tup) {
|
2016-03-27 20:06:00 +00:00
|
|
|
return ostd::get<0>(tup).front();
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename ...R>
|
|
|
|
struct JoinRange: InputRange<JoinRange<R...>,
|
|
|
|
CommonType<ForwardRangeTag, RangeCategory<R>...>,
|
|
|
|
CommonType<RangeValue<R>...>, CommonType<RangeReference<R>...>,
|
|
|
|
CommonType<RangeSize<R>...>, CommonType<RangeDifference<R>...>> {
|
|
|
|
private:
|
|
|
|
Tuple<R...> p_ranges;
|
|
|
|
public:
|
|
|
|
JoinRange() = delete;
|
2016-06-23 18:18:35 +00:00
|
|
|
JoinRange(R const &...ranges): p_ranges(ranges...) {}
|
2016-03-27 20:06:00 +00:00
|
|
|
JoinRange(R &&...ranges): p_ranges(forward<R>(ranges)...) {}
|
2016-06-23 18:18:35 +00:00
|
|
|
JoinRange(JoinRange const &v): p_ranges(v.p_ranges) {}
|
2016-03-27 20:06:00 +00:00
|
|
|
JoinRange(JoinRange &&v): p_ranges(move(v.p_ranges)) {}
|
|
|
|
|
2016-06-23 18:18:35 +00:00
|
|
|
JoinRange &operator=(JoinRange const &v) {
|
2016-03-27 20:06:00 +00:00
|
|
|
p_ranges = v.p_ranges;
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
JoinRange &operator=(JoinRange &&v) {
|
|
|
|
p_ranges = move(v.p_ranges);
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool empty() const {
|
2016-03-27 22:49:27 +00:00
|
|
|
return detail::JoinRangeEmpty<0, sizeof...(R)>::empty(p_ranges);
|
2016-03-27 20:06:00 +00:00
|
|
|
}
|
|
|
|
|
2016-06-23 18:18:35 +00:00
|
|
|
bool equals_front(JoinRange const &r) const {
|
2016-07-31 19:40:25 +00:00
|
|
|
return detail::TupleRangeEqual<0, sizeof...(R)>::equal(
|
|
|
|
p_ranges, r.p_ranges
|
|
|
|
);
|
2016-03-27 20:06:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bool pop_front() {
|
2016-03-27 22:49:27 +00:00
|
|
|
return detail::JoinRangePop<0, sizeof...(R)>::pop(p_ranges);
|
2016-03-27 20:06:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
CommonType<RangeReference<R>...> front() const {
|
2016-07-31 19:40:25 +00:00
|
|
|
return detail::JoinRangeFront<
|
|
|
|
0, sizeof...(R), CommonType<RangeReference<R>...>
|
|
|
|
>::front(p_ranges);
|
2016-03-27 20:06:00 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2016-03-27 22:49:27 +00:00
|
|
|
namespace detail {
|
|
|
|
template<typename ...T>
|
|
|
|
struct ZipValueType {
|
|
|
|
using Type = Tuple<T...>;
|
|
|
|
};
|
|
|
|
|
|
|
|
template<typename T, typename U>
|
|
|
|
struct ZipValueType<T, U> {
|
|
|
|
using Type = Pair<T, U>;
|
|
|
|
};
|
|
|
|
|
|
|
|
template<typename ...T>
|
|
|
|
using ZipValue = typename detail::ZipValueType<T...>::Type;
|
|
|
|
|
|
|
|
template<Size I, Size N>
|
|
|
|
struct ZipRangeEmpty {
|
|
|
|
template<typename T>
|
2016-06-23 18:18:35 +00:00
|
|
|
static bool empty(T const &tup) {
|
2016-07-31 19:40:25 +00:00
|
|
|
if (ostd::get<I>(tup).empty()) {
|
2016-03-27 22:49:27 +00:00
|
|
|
return true;
|
2016-07-31 19:40:25 +00:00
|
|
|
}
|
2016-03-27 22:49:27 +00:00
|
|
|
return ZipRangeEmpty<I + 1, N>::empty(tup);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
template<Size N>
|
|
|
|
struct ZipRangeEmpty<N, N> {
|
|
|
|
template<typename T>
|
2016-06-23 18:18:35 +00:00
|
|
|
static bool empty(T const &) {
|
2016-03-27 22:49:27 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
template<Size I, Size N>
|
|
|
|
struct ZipRangePop {
|
|
|
|
template<typename T>
|
|
|
|
static bool pop(T &tup) {
|
2016-07-31 19:40:25 +00:00
|
|
|
return (
|
|
|
|
ostd::get<I>(tup).pop_front() && ZipRangePop<I + 1, N>::pop(tup)
|
|
|
|
);
|
2016-03-27 22:49:27 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
template<Size N>
|
|
|
|
struct ZipRangePop<N, N> {
|
|
|
|
template<typename T>
|
|
|
|
static bool pop(T &) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
template<typename ...T>
|
|
|
|
struct ZipRangeFront {
|
|
|
|
template<typename U, Size ...I>
|
2016-06-23 18:18:35 +00:00
|
|
|
static ZipValue<T...> tup_get(U const &tup, detail::TupleIndices<I...>) {
|
2016-03-27 22:49:27 +00:00
|
|
|
return ZipValue<T...>(ostd::get<I>(tup).front()...);
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename U>
|
2016-06-23 18:18:35 +00:00
|
|
|
static ZipValue<T...> front(U const &tup) {
|
2016-03-27 22:49:27 +00:00
|
|
|
using Index = detail::MakeTupleIndices<sizeof...(T)>;
|
|
|
|
return ZipRangeFront<T...>::tup_get(tup, Index());
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename ...R>
|
|
|
|
struct ZipRange: InputRange<ZipRange<R...>,
|
|
|
|
CommonType<ForwardRangeTag, RangeCategory<R>...>,
|
2016-03-30 19:41:59 +00:00
|
|
|
detail::ZipValue<RangeValue<R>...>,
|
2016-03-27 22:49:27 +00:00
|
|
|
detail::ZipValue<RangeReference<R>...>,
|
|
|
|
CommonType<RangeSize<R>...>, CommonType<RangeDifference<R>...>> {
|
|
|
|
private:
|
|
|
|
Tuple<R...> p_ranges;
|
|
|
|
public:
|
|
|
|
ZipRange() = delete;
|
2016-06-23 18:18:35 +00:00
|
|
|
ZipRange(R const &...ranges): p_ranges(ranges...) {}
|
2016-03-27 22:49:27 +00:00
|
|
|
ZipRange(R &&...ranges): p_ranges(forward<R>(ranges)...) {}
|
2016-06-23 18:18:35 +00:00
|
|
|
ZipRange(ZipRange const &v): p_ranges(v.p_ranges) {}
|
2016-03-27 22:49:27 +00:00
|
|
|
ZipRange(ZipRange &&v): p_ranges(move(v.p_ranges)) {}
|
|
|
|
|
2016-06-23 18:18:35 +00:00
|
|
|
ZipRange &operator=(ZipRange const &v) {
|
2016-03-27 22:49:27 +00:00
|
|
|
p_ranges = v.p_ranges;
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
ZipRange &operator=(ZipRange &&v) {
|
|
|
|
p_ranges = move(v.p_ranges);
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool empty() const {
|
|
|
|
return detail::ZipRangeEmpty<0, sizeof...(R)>::empty(p_ranges);
|
|
|
|
}
|
|
|
|
|
2016-06-23 18:18:35 +00:00
|
|
|
bool equals_front(ZipRange const &r) const {
|
2016-07-31 19:40:25 +00:00
|
|
|
return detail::TupleRangeEqual<0, sizeof...(R)>::equal(
|
|
|
|
p_ranges, r.p_ranges
|
|
|
|
);
|
2016-03-27 22:49:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bool pop_front() {
|
|
|
|
return detail::ZipRangePop<0, sizeof...(R)>::pop(p_ranges);
|
|
|
|
}
|
|
|
|
|
|
|
|
detail::ZipValue<RangeReference<R>...> front() const {
|
|
|
|
return detail::ZipRangeFront<RangeReference<R>...>::front(p_ranges);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2015-07-04 20:09:07 +00:00
|
|
|
template<typename T>
|
2015-07-05 02:37:36 +00:00
|
|
|
struct AppenderRange: OutputRange<AppenderRange<T>, typename T::Value,
|
|
|
|
typename T::Reference, typename T::Size, typename T::Difference> {
|
2015-07-04 20:09:07 +00:00
|
|
|
AppenderRange(): p_data() {}
|
2016-06-23 18:18:35 +00:00
|
|
|
AppenderRange(T const &v): p_data(v) {}
|
2015-07-05 22:59:36 +00:00
|
|
|
AppenderRange(T &&v): p_data(move(v)) {}
|
2016-06-23 18:18:35 +00:00
|
|
|
AppenderRange(AppenderRange const &v): p_data(v.p_data) {}
|
2015-07-05 22:59:36 +00:00
|
|
|
AppenderRange(AppenderRange &&v): p_data(move(v.p_data)) {}
|
2015-07-04 20:09:07 +00:00
|
|
|
|
2016-06-23 18:18:35 +00:00
|
|
|
AppenderRange &operator=(AppenderRange const &v) {
|
2015-07-04 20:09:07 +00:00
|
|
|
p_data = v.p_data;
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
AppenderRange &operator=(AppenderRange &&v) {
|
2015-07-05 22:59:36 +00:00
|
|
|
p_data = move(v.p_data);
|
2015-07-04 20:09:07 +00:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2016-06-23 18:18:35 +00:00
|
|
|
AppenderRange &operator=(T const &v) {
|
2015-07-04 20:09:07 +00:00
|
|
|
p_data = v;
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
AppenderRange &operator=(T &&v) {
|
2015-07-05 22:59:36 +00:00
|
|
|
p_data = move(v);
|
2015-07-04 20:09:07 +00:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
void clear() { p_data.clear(); }
|
|
|
|
|
|
|
|
void reserve(typename T::Size cap) { p_data.reserve(cap); }
|
|
|
|
void resize(typename T::Size len) { p_data.resize(len); }
|
|
|
|
|
|
|
|
typename T::Size size() const { return p_data.size(); }
|
|
|
|
typename T::Size capacity() const { return p_data.capacity(); }
|
|
|
|
|
2015-07-05 02:37:36 +00:00
|
|
|
bool put(typename T::ConstReference v) {
|
2015-07-04 20:09:07 +00:00
|
|
|
p_data.push(v);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool put(typename T::Value &&v) {
|
2015-07-05 22:59:36 +00:00
|
|
|
p_data.push(move(v));
|
2015-07-04 20:09:07 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
T &get() { return p_data; }
|
|
|
|
private:
|
|
|
|
T p_data;
|
|
|
|
};
|
|
|
|
|
|
|
|
template<typename T>
|
2016-04-26 19:13:32 +00:00
|
|
|
inline AppenderRange<T> appender() {
|
2015-07-04 20:09:07 +00:00
|
|
|
return AppenderRange<T>();
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename T>
|
2016-04-26 19:13:32 +00:00
|
|
|
inline AppenderRange<T> appender(T &&v) {
|
2015-07-05 22:59:36 +00:00
|
|
|
return AppenderRange<T>(forward<T>(v));
|
2015-07-04 20:09:07 +00:00
|
|
|
}
|
|
|
|
|
2015-06-03 22:55:11 +00:00
|
|
|
// range of
|
2015-07-05 22:59:36 +00:00
|
|
|
template<typename T> using RangeOf = decltype(iter(declval<T>()));
|
2015-06-03 22:55:11 +00:00
|
|
|
|
2015-07-13 19:07:14 +00:00
|
|
|
} /* namespace ostd */
|
2015-06-03 22:55:11 +00:00
|
|
|
|
2016-02-07 21:17:15 +00:00
|
|
|
#endif
|