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>
|
2017-01-28 17:30:31 +00:00
|
|
|
|
2017-01-14 14:09:27 +00:00
|
|
|
#include <new>
|
2017-01-28 17:30:31 +00:00
|
|
|
#include <tuple>
|
|
|
|
#include <utility>
|
2017-01-30 21:07:12 +00:00
|
|
|
#include <iterator>
|
2017-02-09 19:56:15 +00:00
|
|
|
#include <type_traits>
|
2017-02-14 16:44:24 +00:00
|
|
|
#include <initializer_list>
|
2017-02-19 15:45:06 +00:00
|
|
|
#include <algorithm>
|
2015-04-15 23:18:00 +00:00
|
|
|
|
2015-07-13 19:08:55 +00:00
|
|
|
#include "ostd/types.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
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
struct input_range_tag {};
|
|
|
|
struct output_range_tag {};
|
|
|
|
struct forward_range_tag: input_range_tag {};
|
|
|
|
struct bidirectional_range_tag: forward_range_tag {};
|
|
|
|
struct random_access_range_tag: bidirectional_range_tag {};
|
|
|
|
struct finite_random_access_range_tag: random_access_range_tag {};
|
2017-02-16 19:39:05 +00:00
|
|
|
struct contiguous_range_tag: finite_random_access_range_tag {};
|
2015-05-29 22:48:05 +00:00
|
|
|
|
2017-02-18 14:05:42 +00:00
|
|
|
namespace detail {
|
|
|
|
template<typename R>
|
|
|
|
struct range_category_test {
|
|
|
|
template<typename RR>
|
|
|
|
static char test(typename RR::range_category *);
|
|
|
|
template<typename>
|
|
|
|
static int test(...);
|
|
|
|
static constexpr bool value = (sizeof(test<R>(0)) == sizeof(char));
|
|
|
|
};
|
|
|
|
|
|
|
|
template<typename R>
|
|
|
|
constexpr bool test_range_category = range_category_test<R>::value;
|
|
|
|
|
|
|
|
template<typename R, bool>
|
|
|
|
struct range_traits_base {};
|
|
|
|
|
|
|
|
template<typename R>
|
|
|
|
struct range_traits_base<R, true> {
|
|
|
|
using range_category = typename R::range_category;
|
|
|
|
using size_type = typename R::size_type;
|
|
|
|
using value_type = typename R::value_type;
|
|
|
|
using reference = typename R::reference;
|
|
|
|
using difference_type = typename R::difference_type;
|
|
|
|
};
|
|
|
|
|
|
|
|
template<typename R, bool>
|
|
|
|
struct range_traits_impl {};
|
|
|
|
|
|
|
|
template<typename R>
|
|
|
|
struct range_traits_impl<R, true>: range_traits_base<
|
|
|
|
R,
|
|
|
|
std::is_convertible_v<typename R::range_category, input_range_tag> ||
|
|
|
|
std::is_convertible_v<typename R::range_category, output_range_tag>
|
|
|
|
> {};
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename R>
|
|
|
|
struct range_traits: detail::range_traits_impl<R, detail::test_range_category<R>> {};
|
|
|
|
|
|
|
|
template<typename R>
|
|
|
|
using range_category_t = typename range_traits<R>::range_category;
|
|
|
|
|
|
|
|
template<typename R>
|
|
|
|
using range_size_t = typename range_traits<R>::size_type;
|
|
|
|
|
|
|
|
template<typename R>
|
|
|
|
using range_value_t = typename range_traits<R>::value_type;
|
|
|
|
|
|
|
|
template<typename R>
|
|
|
|
using range_reference_t = typename range_traits<R>::reference;
|
|
|
|
|
|
|
|
template<typename R>
|
|
|
|
using range_difference_t = typename range_traits<R>::difference_type;
|
2015-04-15 23:18: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>
|
2017-02-16 19:02:55 +00:00
|
|
|
constexpr bool is_input_range_core =
|
|
|
|
std::is_convertible_v<range_category_t<T>, input_range_tag>;
|
2015-06-15 17:54:00 +00:00
|
|
|
|
2017-02-18 14:23:57 +00:00
|
|
|
template<typename T, bool = detail::test_range_category<T>>
|
2017-02-16 19:02:55 +00:00
|
|
|
constexpr bool is_input_range_base = false;
|
2016-01-13 17:42:37 +00:00
|
|
|
|
|
|
|
template<typename T>
|
2017-02-16 19:02:55 +00:00
|
|
|
constexpr bool is_input_range_base<T, true> = detail::is_input_range_core<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>
|
2017-02-16 19:02:55 +00:00
|
|
|
constexpr bool is_input_range = detail::is_input_range_base<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>
|
2017-02-16 19:02:55 +00:00
|
|
|
constexpr bool is_forward_range_core =
|
|
|
|
std::is_convertible_v<range_category_t<T>, forward_range_tag>;
|
2015-06-15 17:54:00 +00:00
|
|
|
|
2017-02-18 14:23:57 +00:00
|
|
|
template<typename T, bool = detail::test_range_category<T>>
|
2017-02-16 19:02:55 +00:00
|
|
|
constexpr bool is_forward_range_base = false;
|
2016-01-13 17:42:37 +00:00
|
|
|
|
|
|
|
template<typename T>
|
2017-02-16 19:02:55 +00:00
|
|
|
constexpr bool is_forward_range_base<T, true> = detail::is_forward_range_core<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>
|
2017-02-16 19:02:55 +00:00
|
|
|
constexpr bool is_forward_range = detail::is_forward_range_base<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>
|
2017-02-16 19:02:55 +00:00
|
|
|
constexpr bool is_bidirectional_range_core =
|
|
|
|
std::is_convertible_v<range_category_t<T>, bidirectional_range_tag>;
|
2015-06-15 17:54:00 +00:00
|
|
|
|
2017-02-18 14:23:57 +00:00
|
|
|
template<typename T, bool = detail::test_range_category<T>>
|
2017-02-16 19:02:55 +00:00
|
|
|
constexpr bool is_bidirectional_range_base = false;
|
2015-05-23 19:33:08 +00:00
|
|
|
|
2016-01-13 17:42:37 +00:00
|
|
|
template<typename T>
|
2017-02-16 19:02:55 +00:00
|
|
|
constexpr bool is_bidirectional_range_base<T, true> =
|
|
|
|
detail::is_bidirectional_range_core<T>;
|
2016-01-13 17:42:37 +00:00
|
|
|
}
|
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
template<typename T> constexpr bool is_bidirectional_range =
|
|
|
|
detail::is_bidirectional_range_base<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>
|
2017-02-16 19:02:55 +00:00
|
|
|
constexpr bool is_random_access_range_core =
|
|
|
|
std::is_convertible_v<range_category_t<T>, random_access_range_tag>;
|
2015-06-15 17:54:00 +00:00
|
|
|
|
2017-02-18 14:23:57 +00:00
|
|
|
template<typename T, bool = detail::test_range_category<T>>
|
2017-02-16 19:02:55 +00:00
|
|
|
constexpr bool is_random_access_range_base = false;
|
2015-05-23 19:33:08 +00:00
|
|
|
|
2016-01-13 17:42:37 +00:00
|
|
|
template<typename T>
|
2017-02-16 19:02:55 +00:00
|
|
|
constexpr bool is_random_access_range_base<T, true> =
|
|
|
|
detail::is_random_access_range_core<T>;
|
2016-01-13 17:42:37 +00:00
|
|
|
}
|
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
template<typename T> constexpr bool is_random_access_range =
|
|
|
|
detail::is_random_access_range_base<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>
|
2017-02-16 19:02:55 +00:00
|
|
|
constexpr bool is_finite_random_access_range_core =
|
|
|
|
std::is_convertible_v<range_category_t<T>, finite_random_access_range_tag>;
|
2015-06-15 17:54:00 +00:00
|
|
|
|
2017-02-18 14:23:57 +00:00
|
|
|
template<typename T, bool = detail::test_range_category<T>>
|
2017-02-16 19:02:55 +00:00
|
|
|
constexpr bool is_finite_random_access_range_base = false;
|
2015-05-23 19:33:08 +00:00
|
|
|
|
2016-01-13 17:42:37 +00:00
|
|
|
template<typename T>
|
2017-02-16 19:02:55 +00:00
|
|
|
constexpr bool is_finite_random_access_range_base<T, true> =
|
|
|
|
detail::is_finite_random_access_range_core<T>;
|
2016-01-13 17:42:37 +00:00
|
|
|
}
|
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
template<typename T> constexpr bool is_finite_random_access_range =
|
|
|
|
detail::is_finite_random_access_range_base<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
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
template<typename T> constexpr bool is_infinite_random_access_range =
|
|
|
|
is_random_access_range<T> && !is_finite_random_access_range<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>
|
2017-02-16 19:02:55 +00:00
|
|
|
constexpr bool is_contiguous_range_core =
|
2017-02-16 19:39:05 +00:00
|
|
|
std::is_convertible_v<range_category_t<T>, contiguous_range_tag>;
|
2015-07-23 00:28:25 +00:00
|
|
|
|
2017-02-18 14:23:57 +00:00
|
|
|
template<typename T, bool = detail::test_range_category<T>>
|
2017-02-16 19:02:55 +00:00
|
|
|
constexpr bool is_contiguous_range_base = false;
|
2015-07-23 00:28:25 +00:00
|
|
|
|
2016-01-13 17:42:37 +00:00
|
|
|
template<typename T>
|
2017-02-16 19:02:55 +00:00
|
|
|
constexpr bool is_contiguous_range_base<T, true> =
|
|
|
|
detail::is_contiguous_range_core<T>;
|
2016-01-13 17:42:37 +00:00
|
|
|
}
|
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
template<typename T> constexpr bool is_contiguous_range =
|
|
|
|
detail::is_contiguous_range_base<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 {
|
2017-02-18 14:23:57 +00:00
|
|
|
template<typename R, typename T>
|
|
|
|
static std::true_type test_outrange(typename std::is_same<
|
2017-02-19 15:45:06 +00:00
|
|
|
decltype(std::declval<R &>().put(std::declval<T>())), void
|
2017-02-18 14:23:57 +00:00
|
|
|
>::type *);
|
|
|
|
|
|
|
|
template<typename, typename>
|
|
|
|
static std::false_type test_outrange(...);
|
|
|
|
|
|
|
|
template<typename R, typename T>
|
|
|
|
constexpr bool output_range_test = decltype(test_outrange<R, T>())::value;
|
2015-05-23 21:24:12 +00:00
|
|
|
|
2016-07-31 19:40:25 +00:00
|
|
|
template<typename T>
|
2017-02-16 19:02:55 +00:00
|
|
|
constexpr bool is_output_range_core =
|
|
|
|
std::is_convertible_v<range_category_t<T>, output_range_tag> || (
|
|
|
|
is_input_range<T> && (
|
2017-02-18 14:23:57 +00:00
|
|
|
output_range_test<T, range_value_t<T> const &> ||
|
|
|
|
output_range_test<T, range_value_t<T> &&> ||
|
|
|
|
output_range_test<T, range_value_t<T> >
|
2016-07-31 19:40:25 +00:00
|
|
|
)
|
|
|
|
);
|
2016-01-13 17:42:37 +00:00
|
|
|
|
2017-02-18 14:23:57 +00:00
|
|
|
template<typename T, bool = detail::test_range_category<T>>
|
2017-02-16 19:02:55 +00:00
|
|
|
constexpr bool is_output_range_base = false;
|
2016-01-13 17:42:37 +00:00
|
|
|
|
|
|
|
template<typename T>
|
2017-02-16 19:02:55 +00:00
|
|
|
constexpr bool is_output_range_base<T, true> = detail::is_output_range_core<T>;
|
2016-01-13 17:42:37 +00:00
|
|
|
}
|
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
template<typename T>
|
|
|
|
constexpr bool is_output_range = detail::is_output_range_base<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>
|
2017-02-16 19:02:55 +00:00
|
|
|
struct range_iterator {
|
|
|
|
range_iterator(): p_range(), p_init(false) {}
|
|
|
|
explicit range_iterator(T const &range): p_range(), p_init(true) {
|
2015-06-29 22:18:29 +00:00
|
|
|
::new(&get_ref()) T(range);
|
|
|
|
}
|
2017-02-16 19:02:55 +00:00
|
|
|
explicit range_iterator(T &&range): p_range(), p_init(true) {
|
2017-01-25 00:44:22 +00:00
|
|
|
::new(&get_ref()) T(std::move(range));
|
2015-06-29 22:18:29 +00:00
|
|
|
}
|
2017-02-16 19:02:55 +00:00
|
|
|
range_iterator(const range_iterator &v): p_range(), p_init(true) {
|
2016-07-31 19:40:25 +00:00
|
|
|
::new(&get_ref()) T(v.get_ref());
|
|
|
|
}
|
2017-02-16 19:02:55 +00:00
|
|
|
range_iterator(range_iterator &&v): p_range(), p_init(true) {
|
2017-01-25 00:44:22 +00:00
|
|
|
::new(&get_ref()) T(std::move(v.get_ref()));
|
2016-07-31 19:40:25 +00:00
|
|
|
}
|
2017-02-16 19:02:55 +00:00
|
|
|
range_iterator &operator=(const range_iterator &v) {
|
2016-07-31 19:40:25 +00:00
|
|
|
destroy();
|
|
|
|
::new(&get_ref()) T(v.get_ref());
|
|
|
|
p_init = true;
|
|
|
|
return *this;
|
|
|
|
}
|
2017-02-16 19:02:55 +00:00
|
|
|
range_iterator &operator=(range_iterator &&v) {
|
2016-07-31 19:40:25 +00:00
|
|
|
destroy();
|
|
|
|
swap(v);
|
|
|
|
return *this;
|
|
|
|
}
|
2017-02-16 19:02:55 +00:00
|
|
|
~range_iterator() {
|
2016-07-31 19:40:25 +00:00
|
|
|
destroy();
|
|
|
|
}
|
2017-02-16 19:02:55 +00:00
|
|
|
range_iterator &operator++() {
|
2015-06-29 22:18:29 +00:00
|
|
|
get_ref().pop_front();
|
2015-04-24 17:16:35 +00:00
|
|
|
return *this;
|
|
|
|
}
|
2017-02-16 19:02:55 +00:00
|
|
|
range_reference_t<T> operator*() const {
|
2015-06-29 22:18:29 +00:00
|
|
|
return get_ref().front();
|
2015-04-24 17:16:35 +00:00
|
|
|
}
|
2017-02-16 19:02:55 +00:00
|
|
|
bool operator!=(range_iterator) const { return !get_ref().empty(); }
|
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;
|
|
|
|
}
|
|
|
|
}
|
2017-02-09 19:56:15 +00:00
|
|
|
std::aligned_storage_t<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>
|
2017-02-16 19:02:55 +00:00
|
|
|
struct half_range;
|
2015-06-09 23:12:52 +00:00
|
|
|
|
2015-06-14 03:53:23 +00:00
|
|
|
namespace detail {
|
2017-02-16 19:39:05 +00:00
|
|
|
template<typename R, bool = is_bidirectional_range<typename R::range>>
|
|
|
|
struct range_add;
|
2015-06-14 03:53:23 +00:00
|
|
|
|
|
|
|
template<typename R>
|
2017-02-16 19:39:05 +00:00
|
|
|
struct range_add<R, true> {
|
|
|
|
using diff_t = range_difference_t<typename R::range>;
|
2015-06-14 03:53:23 +00:00
|
|
|
|
2017-02-16 19:39:05 +00:00
|
|
|
static diff_t add_n(R &half, diff_t 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);
|
|
|
|
}
|
2017-02-16 19:39:05 +00:00
|
|
|
static diff_t sub_n(R &half, diff_t 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>
|
2017-02-16 19:39:05 +00:00
|
|
|
struct range_add<R, false> {
|
|
|
|
using diff_t = range_difference_t<typename R::range>;
|
2015-06-14 03:53:23 +00:00
|
|
|
|
2017-02-16 19:39:05 +00:00
|
|
|
static diff_t add_n(R &half, diff_t 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);
|
|
|
|
}
|
2017-02-16 19:39:05 +00:00
|
|
|
static diff_t sub_n(R &half, diff_t 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);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2017-02-01 17:28:57 +00:00
|
|
|
namespace detail {
|
|
|
|
template<typename>
|
2017-02-16 19:39:05 +00:00
|
|
|
struct range_iterator_tag {
|
2017-02-01 17:28:57 +00:00
|
|
|
/* better range types all become random access iterators */
|
2017-02-16 19:39:05 +00:00
|
|
|
using type = std::random_access_iterator_tag;
|
2017-02-01 17:28:57 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
template<>
|
2017-02-16 19:39:05 +00:00
|
|
|
struct range_iterator_tag<input_range_tag> {
|
|
|
|
using type = std::input_iterator_tag;
|
2017-02-01 17:28:57 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
template<>
|
2017-02-16 19:39:05 +00:00
|
|
|
struct range_iterator_tag<output_range_tag> {
|
|
|
|
using type = std::output_iterator_tag;
|
2017-02-01 17:28:57 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
template<>
|
2017-02-16 19:39:05 +00:00
|
|
|
struct range_iterator_tag<forward_range_tag> {
|
|
|
|
using type = std::forward_iterator_tag;
|
2017-02-01 17:28:57 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
template<>
|
2017-02-16 19:39:05 +00:00
|
|
|
struct range_iterator_tag<bidirectional_range_tag> {
|
|
|
|
using type = std::bidirectional_iterator_tag;
|
2017-02-01 17:28:57 +00:00
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename T>
|
2017-02-16 19:02:55 +00:00
|
|
|
struct range_half {
|
2015-06-03 22:55:11 +00:00
|
|
|
private:
|
2015-06-04 21:57:06 +00:00
|
|
|
T p_range;
|
2015-06-03 22:55:11 +00:00
|
|
|
public:
|
2017-02-16 19:39:05 +00:00
|
|
|
using range = T;
|
2015-05-29 22:32:25 +00:00
|
|
|
|
2017-02-16 19:39:05 +00:00
|
|
|
using iterator_category = typename detail::range_iterator_tag<T>::type;
|
2017-02-16 19:02:55 +00:00
|
|
|
using value_type = range_value_t<T>;
|
|
|
|
using difference_type = range_difference_t<T>;
|
|
|
|
using pointer = range_value_t<T> *;
|
|
|
|
using reference = range_reference_t<T>;
|
2017-02-01 17:28:57 +00:00
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
range_half() = delete;
|
|
|
|
range_half(T const &range): p_range(range) {}
|
2015-06-25 00:07:11 +00:00
|
|
|
|
2017-02-09 19:56:15 +00:00
|
|
|
template<typename U, typename = std::enable_if_t<std::is_convertible_v<U, T>>>
|
2017-02-16 19:02:55 +00:00
|
|
|
range_half(range_half<U> const &half): p_range(half.p_range) {}
|
2015-06-25 00:07:11 +00:00
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
range_half(range_half const &half): p_range(half.p_range) {}
|
|
|
|
range_half(range_half &&half): p_range(std::move(half.p_range)) {}
|
2015-05-29 22:32:25 +00:00
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
range_half &operator=(range_half 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
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
range_half &operator=(range_half &&half) {
|
2017-01-25 00:44:22 +00:00
|
|
|
p_range = std::move(half.p_range);
|
2015-06-03 22:55:11 +00:00
|
|
|
return *this;
|
|
|
|
}
|
2015-05-29 22:32:25 +00:00
|
|
|
|
2017-02-19 15:45:06 +00:00
|
|
|
void next() { p_range.pop_front(); }
|
|
|
|
void prev() { p_range.push_front(); }
|
2015-05-29 22:32:25 +00:00
|
|
|
|
2017-02-19 15:45:06 +00:00
|
|
|
void next_n(range_size_t<T> n) {
|
|
|
|
p_range.pop_front_n(n);
|
2015-06-03 22:55:11 +00:00
|
|
|
}
|
2017-02-19 15:45:06 +00:00
|
|
|
void prev_n(range_size_t<T> n) {
|
|
|
|
p_range.push_front_n(n);
|
2015-06-03 22:55:11 +00:00
|
|
|
}
|
2015-05-29 22:32:25 +00:00
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
range_difference_t<T> add_n(range_difference_t<T> n) {
|
2017-02-16 19:39:05 +00:00
|
|
|
return detail::range_add<range_half<T>>::add_n(*this, n);
|
2015-06-14 03:53:23 +00:00
|
|
|
}
|
2017-02-16 19:02:55 +00:00
|
|
|
range_difference_t<T> sub_n(range_difference_t<T> n) {
|
2017-02-16 19:39:05 +00:00
|
|
|
return detail::range_add<range_half<T>>::sub_n(*this, n);
|
2015-06-14 03:53:23 +00:00
|
|
|
}
|
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
range_reference_t<T> get() const {
|
2015-06-03 22:55:11 +00:00
|
|
|
return p_range.front();
|
|
|
|
}
|
2015-05-29 22:32:25 +00:00
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
range_difference_t<T> distance(range_half 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
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
bool equals(range_half 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
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
bool operator==(range_half const &half) const {
|
2015-06-03 22:55:11 +00:00
|
|
|
return equals(half);
|
|
|
|
}
|
2017-02-16 19:02:55 +00:00
|
|
|
bool operator!=(range_half const &half) const {
|
2015-06-03 22:55:11 +00:00
|
|
|
return !equals(half);
|
|
|
|
}
|
2017-03-11 13:24:41 +00:00
|
|
|
bool operator<(range_half const &half) const {
|
|
|
|
return distance(half) > 0;
|
|
|
|
}
|
|
|
|
bool operator>(range_half const &half) const {
|
|
|
|
return distance(half) < 0;
|
|
|
|
}
|
|
|
|
bool operator<=(range_half const &half) const {
|
|
|
|
return distance(half) >= 0;
|
|
|
|
}
|
|
|
|
bool operator>=(range_half const &half) const {
|
|
|
|
return distance(half) <= 0;
|
|
|
|
}
|
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
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
range_reference_t<T> operator*() const {
|
2017-02-01 17:28:57 +00:00
|
|
|
return p_range.front();
|
2015-06-03 22:55:11 +00:00
|
|
|
}
|
2015-05-29 22:32:25 +00:00
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
range_reference_t<T> operator[](range_size_t<T> idx) const {
|
2015-06-03 22:55:11 +00:00
|
|
|
return p_range[idx];
|
|
|
|
}
|
2015-05-29 22:32:25 +00:00
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
range_half &operator++() {
|
2015-06-03 22:55:11 +00:00
|
|
|
next();
|
|
|
|
return *this;
|
|
|
|
}
|
2017-02-16 19:02:55 +00:00
|
|
|
range_half operator++(int) {
|
|
|
|
range_half tmp(*this);
|
2015-06-03 22:55:11 +00:00
|
|
|
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
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
range_half &operator--() {
|
2015-06-03 22:55:11 +00:00
|
|
|
prev();
|
|
|
|
return *this;
|
|
|
|
}
|
2017-02-16 19:02:55 +00:00
|
|
|
range_half operator--(int) {
|
|
|
|
range_half tmp(*this);
|
2015-06-03 22:55:11 +00:00
|
|
|
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
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
range_half operator+(range_difference_t<T> n) const {
|
|
|
|
range_half 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
|
|
|
}
|
2017-02-16 19:02:55 +00:00
|
|
|
range_half operator-(range_difference_t<T> n) const {
|
|
|
|
range_half 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
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
range_half &operator+=(range_difference_t<T> n) {
|
2015-06-14 03:53:23 +00:00
|
|
|
add_n(n);
|
2015-06-03 22:55:11 +00:00
|
|
|
return *this;
|
|
|
|
}
|
2017-02-16 19:02:55 +00:00
|
|
|
range_half &operator-=(range_difference_t<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
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
half_range<range_half> iter(range_half const &other) const {
|
|
|
|
return half_range<range_half>(*this, other);
|
2015-06-09 23:12:52 +00:00
|
|
|
}
|
2015-07-28 01:40:24 +00:00
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
range_value_t<T> *data() { return p_range.data(); }
|
|
|
|
range_value_t<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>
|
2017-02-16 19:02:55 +00:00
|
|
|
inline range_difference_t<R> operator-(
|
|
|
|
range_half<R> const &lhs, range_half<R> const &rhs
|
2017-02-01 17:28:57 +00:00
|
|
|
) {
|
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>
|
2017-02-19 15:45:06 +00:00
|
|
|
void pop_front_n(R &range, range_size_t<R> n) {
|
2017-02-16 19:02:55 +00:00
|
|
|
for (range_size_t<R> i = 0; i < n; ++i) {
|
2017-02-19 15:45:06 +00:00
|
|
|
range.pop_front();
|
2016-07-31 19:40:25 +00:00
|
|
|
}
|
2015-05-23 16:36:26 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename R>
|
2017-02-19 15:45:06 +00:00
|
|
|
void pop_back_n(R &range, range_size_t<R> n) {
|
2017-02-16 19:02:55 +00:00
|
|
|
for (range_size_t<R> i = 0; i < n; ++i) {
|
2017-02-19 15:45:06 +00:00
|
|
|
range.pop_back();
|
2016-07-31 19:40:25 +00:00
|
|
|
}
|
2015-05-23 16:36:26 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename R>
|
2017-02-19 15:45:06 +00:00
|
|
|
void push_front_n(R &range, range_size_t<R> n) {
|
2017-02-16 19:02:55 +00:00
|
|
|
for (range_size_t<R> i = 0; i < n; ++i) {
|
2017-02-19 15:45:06 +00:00
|
|
|
range.push_front();
|
2016-07-31 19:40:25 +00:00
|
|
|
}
|
2015-05-29 18:52:20 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename R>
|
2017-02-19 15:45:06 +00:00
|
|
|
void push_back_n(R &range, range_size_t<R> n) {
|
2017-02-16 19:02:55 +00:00
|
|
|
for (range_size_t<R> i = 0; i < n; ++i) {
|
2017-02-19 15:45:06 +00:00
|
|
|
range.push_back();
|
2016-07-31 19:40:25 +00:00
|
|
|
}
|
2015-06-03 22:55:11 +00:00
|
|
|
}
|
|
|
|
}
|
2015-05-23 16:36:26 +00:00
|
|
|
|
2016-07-31 19:40:25 +00:00
|
|
|
template<typename>
|
2017-02-16 19:02:55 +00:00
|
|
|
struct reverse_range;
|
2016-07-31 19:40:25 +00:00
|
|
|
template<typename>
|
2017-02-16 19:02:55 +00:00
|
|
|
struct move_range;
|
2016-07-31 19:40:25 +00:00
|
|
|
template<typename>
|
2017-02-16 19:02:55 +00:00
|
|
|
struct enumerated_range;
|
2016-07-31 19:40:25 +00:00
|
|
|
template<typename>
|
2017-02-16 19:02:55 +00:00
|
|
|
struct take_range;
|
2016-07-31 19:40:25 +00:00
|
|
|
template<typename>
|
2017-02-16 19:02:55 +00:00
|
|
|
struct chunks_range;
|
2016-07-31 19:40:25 +00:00
|
|
|
template<typename ...>
|
2017-02-16 19:02:55 +00:00
|
|
|
struct join_range;
|
2016-07-31 19:40:25 +00:00
|
|
|
template<typename ...>
|
2017-02-16 19:02:55 +00:00
|
|
|
struct zip_range;
|
2016-07-31 19:40:25 +00:00
|
|
|
|
2017-02-13 22:04:02 +00:00
|
|
|
template<typename B>
|
2017-02-16 19:02:55 +00:00
|
|
|
struct input_range {
|
|
|
|
detail::range_iterator<B> begin() const {
|
|
|
|
return detail::range_iterator<B>(*static_cast<B const *>(this));
|
2015-06-03 22:55:11 +00:00
|
|
|
}
|
2017-02-16 19:02:55 +00:00
|
|
|
detail::range_iterator<B> end() const {
|
|
|
|
return detail::range_iterator<B>();
|
2015-06-03 22:55:11 +00:00
|
|
|
}
|
2015-05-23 16:36:26 +00:00
|
|
|
|
2017-02-13 22:04:02 +00:00
|
|
|
template<typename Size>
|
2017-02-19 15:45:06 +00:00
|
|
|
void pop_front_n(Size n) {
|
|
|
|
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
|
|
|
|
2017-02-13 22:04:02 +00:00
|
|
|
template<typename Size>
|
2017-02-19 15:45:06 +00:00
|
|
|
void pop_back_n(Size n) {
|
|
|
|
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
|
|
|
|
2017-02-13 22:04:02 +00:00
|
|
|
template<typename Size>
|
2017-02-19 15:45:06 +00:00
|
|
|
void push_front_n(Size n) {
|
|
|
|
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
|
|
|
|
2017-02-13 22:04:02 +00:00
|
|
|
template<typename Size>
|
2017-02-19 15:45:06 +00:00
|
|
|
void push_back_n(Size n) {
|
|
|
|
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
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
reverse_range<B> reverse() const {
|
|
|
|
return reverse_range<B>(iter());
|
2015-06-09 20:18:43 +00:00
|
|
|
}
|
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
move_range<B> movable() const {
|
|
|
|
return move_range<B>(iter());
|
2015-06-03 22:55:11 +00:00
|
|
|
}
|
2015-06-09 23:57:46 +00:00
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
enumerated_range<B> enumerate() const {
|
|
|
|
return enumerated_range<B>(iter());
|
2016-04-26 19:13:32 +00:00
|
|
|
}
|
|
|
|
|
2017-02-13 22:04:02 +00:00
|
|
|
template<typename Size>
|
2017-02-16 19:02:55 +00:00
|
|
|
take_range<B> take(Size n) const {
|
|
|
|
return take_range<B>(iter(), n);
|
2016-04-26 19:13:32 +00:00
|
|
|
}
|
|
|
|
|
2017-02-13 22:04:02 +00:00
|
|
|
template<typename Size>
|
2017-02-16 19:02:55 +00:00
|
|
|
chunks_range<B> chunks(Size n) const {
|
|
|
|
return chunks_range<B>(iter(), n);
|
2016-04-26 19:13:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
template<typename R1, typename ...RR>
|
2017-02-16 19:02:55 +00:00
|
|
|
join_range<B, R1, RR...> join(R1 r1, RR ...rr) const {
|
|
|
|
return join_range<B, R1, RR...>(iter(), std::move(r1), std::move(rr)...);
|
2016-04-26 19:13:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
template<typename R1, typename ...RR>
|
2017-02-16 19:02:55 +00:00
|
|
|
zip_range<B, R1, RR...> zip(R1 r1, RR ...rr) const {
|
|
|
|
return zip_range<B, R1, RR...>(iter(), std::move(r1), std::move(rr)...);
|
2016-04-26 19:13:32 +00:00
|
|
|
}
|
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
range_half<B> half() const {
|
|
|
|
return range_half<B>(iter());
|
2015-06-09 23:57:46 +00:00
|
|
|
}
|
2015-07-01 20:46:58 +00:00
|
|
|
|
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 */
|
|
|
|
|
2017-02-13 22:04:02 +00:00
|
|
|
auto operator*() const {
|
|
|
|
return std::forward<decltype(static_cast<B const *>(this)->front())>(
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2017-02-13 22:04:02 +00:00
|
|
|
template<typename Difference>
|
2015-08-31 13:46:36 +00:00
|
|
|
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;
|
|
|
|
}
|
2017-02-13 22:04:02 +00:00
|
|
|
template<typename Difference>
|
2015-08-31 13:46:36 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2017-02-13 22:04:02 +00:00
|
|
|
template<typename Difference>
|
2015-08-31 13:46:36 +00:00
|
|
|
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
|
|
|
}
|
2017-02-13 22:04:02 +00:00
|
|
|
template<typename Difference>
|
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
|
|
|
}
|
|
|
|
|
2017-02-13 20:12:32 +00:00
|
|
|
/* pipe op, must be a member to work for user ranges automagically */
|
|
|
|
|
|
|
|
template<typename F>
|
|
|
|
auto operator|(F &&func) & {
|
|
|
|
return func(*static_cast<B *>(this));
|
|
|
|
}
|
|
|
|
template<typename F>
|
|
|
|
auto operator|(F &&func) const & {
|
|
|
|
return func(*static_cast<B const *>(this));
|
|
|
|
}
|
|
|
|
template<typename F>
|
|
|
|
auto operator|(F &&func) && {
|
|
|
|
return func(std::move(*static_cast<B *>(this)));
|
|
|
|
}
|
|
|
|
template<typename F>
|
|
|
|
auto operator|(F &&func) const && {
|
|
|
|
return func(std::move(*static_cast<B const *>(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
|
|
|
|
2017-02-13 22:04:02 +00:00
|
|
|
template<typename B>
|
2017-02-16 19:02:55 +00:00
|
|
|
struct output_range {
|
|
|
|
using range_category = output_range_tag;
|
2017-02-13 22:04:02 +00:00
|
|
|
};
|
|
|
|
|
2017-02-19 17:14:09 +00:00
|
|
|
template<typename OR, typename IR>
|
|
|
|
inline void range_put_all(OR &orange, IR range) {
|
|
|
|
for (; !range.empty(); range.pop_front()) {
|
|
|
|
orange.put(range.front());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-18 18:05:03 +00:00
|
|
|
template<typename T>
|
|
|
|
struct noop_output_range: output_range<noop_output_range<T>> {
|
|
|
|
using value_type = T;
|
|
|
|
using reference = T &;
|
|
|
|
using size_type = size_t;
|
|
|
|
using difference_type = ptrdiff_t;
|
|
|
|
|
2017-02-19 15:45:06 +00:00
|
|
|
void put(T const &) {}
|
2017-02-18 18:05:03 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
template<typename R>
|
|
|
|
struct counting_output_range: output_range<counting_output_range<R>> {
|
|
|
|
using value_type = range_value_t<R>;
|
|
|
|
using reference = range_reference_t<R>;
|
|
|
|
using size_type = range_size_t<R>;
|
|
|
|
using difference_type = range_difference_t<R>;
|
|
|
|
|
|
|
|
private:
|
|
|
|
R p_range;
|
|
|
|
size_type p_written = 0;
|
|
|
|
|
|
|
|
public:
|
|
|
|
counting_output_range() = delete;
|
|
|
|
counting_output_range(R const &range): p_range(range) {}
|
|
|
|
|
2017-02-19 15:45:06 +00:00
|
|
|
void put(value_type const &v) {
|
|
|
|
p_range.put(v);
|
|
|
|
++p_written;
|
2017-02-18 18:05:03 +00:00
|
|
|
}
|
2017-02-19 15:45:06 +00:00
|
|
|
void put(value_type &&v) {
|
|
|
|
p_range.put(std::move(v));
|
|
|
|
++p_written;
|
2017-02-18 18:05:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
size_type get_written() const {
|
|
|
|
return p_written;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
template<typename R>
|
|
|
|
inline counting_output_range<R> range_counter(R const &range) {
|
|
|
|
return counting_output_range<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
|
|
|
template<typename R>
|
|
|
|
inline auto join(R &&range) {
|
2017-01-25 00:44:22 +00:00
|
|
|
return [range = std::forward<R>(range)](auto &&obj) mutable {
|
|
|
|
return obj.join(std::forward<R>(range));
|
2016-04-30 23:34:00 +00:00
|
|
|
};
|
|
|
|
}
|
|
|
|
|
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 [
|
2017-01-28 17:30:31 +00:00
|
|
|
ranges = std::forward_as_tuple(
|
|
|
|
std::forward<R1>(r1), std::forward<R>(rr)...
|
|
|
|
)
|
2016-07-31 19:40:25 +00:00
|
|
|
] (auto &&obj) mutable {
|
2017-02-18 13:30:00 +00:00
|
|
|
return std::apply([&obj](auto &&...args) mutable {
|
|
|
|
return obj.join(std::forward<decltype(args)>(args)...);
|
|
|
|
}, std::move(ranges));
|
2016-04-30 23:34:00 +00:00
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename R>
|
|
|
|
inline auto zip(R &&range) {
|
2017-01-25 00:44:22 +00:00
|
|
|
return [range = std::forward<R>(range)](auto &&obj) mutable {
|
|
|
|
return obj.zip(std::forward<R>(range));
|
2016-04-30 23:34:00 +00:00
|
|
|
};
|
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 [
|
2017-01-28 17:30:31 +00:00
|
|
|
ranges = std::forward_as_tuple(
|
|
|
|
std::forward<R1>(r1), std::forward<R>(rr)...
|
|
|
|
)
|
2016-07-31 19:40:25 +00:00
|
|
|
] (auto &&obj) mutable {
|
2017-02-18 13:30:00 +00:00
|
|
|
return std::apply([&obj](auto &&...args) mutable {
|
|
|
|
return obj.zip(std::forward<decltype(args)>(args)...);
|
|
|
|
}, std::move(ranges));
|
2016-04-30 23:34:00 +00:00
|
|
|
};
|
2016-04-26 19:13:32 +00:00
|
|
|
}
|
|
|
|
|
2017-01-25 23:27:54 +00:00
|
|
|
namespace detail {
|
|
|
|
template<typename C>
|
2017-02-15 18:13:52 +00:00
|
|
|
static std::true_type test_direct_iter(decltype(std::declval<C &>().iter()) *);
|
2017-01-25 23:27:54 +00:00
|
|
|
|
|
|
|
template<typename>
|
2017-02-09 19:56:15 +00:00
|
|
|
static std::false_type test_direct_iter(...);
|
2017-01-25 23:27:54 +00:00
|
|
|
|
|
|
|
template<typename C>
|
|
|
|
constexpr bool direct_iter_test = decltype(test_direct_iter<C>(0))::value;
|
2017-02-14 17:32:51 +00:00
|
|
|
|
2017-02-18 13:30:00 +00:00
|
|
|
template<typename C>
|
|
|
|
static std::true_type test_std_iter(
|
|
|
|
decltype(std::begin(std::declval<C &>())) *,
|
|
|
|
decltype(std::end(std::declval<C &>())) *
|
|
|
|
);
|
|
|
|
|
|
|
|
template<typename>
|
|
|
|
static std::false_type test_std_iter(...);
|
2017-02-14 17:32:51 +00:00
|
|
|
|
|
|
|
template<typename C>
|
2017-02-18 13:30:00 +00:00
|
|
|
constexpr bool std_iter_test = decltype(test_std_iter<C>(0, 0))::value;
|
|
|
|
|
|
|
|
/* direct iter and std iter; the case for std iter is
|
|
|
|
* specialized after iterator_range is actually defined
|
|
|
|
*/
|
|
|
|
template<typename C, bool, bool>
|
|
|
|
struct ranged_traits_core {};
|
|
|
|
|
|
|
|
/* direct iter is available, regardless of std iter being available */
|
|
|
|
template<typename C, bool B>
|
|
|
|
struct ranged_traits_core<C, true, B> {
|
2017-02-15 18:13:52 +00:00
|
|
|
using range = decltype(std::declval<C &>().iter());
|
|
|
|
|
|
|
|
static range iter(C &r) {
|
2017-02-14 17:32:51 +00:00
|
|
|
return r.iter();
|
|
|
|
}
|
|
|
|
};
|
2017-02-18 13:30:00 +00:00
|
|
|
|
|
|
|
template<typename C>
|
|
|
|
struct ranged_traits_impl: ranged_traits_core<
|
|
|
|
C, direct_iter_test<C>, std_iter_test<C>
|
|
|
|
> {};
|
2017-01-25 23:27:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
template<typename C>
|
2017-02-18 13:30:00 +00:00
|
|
|
struct ranged_traits: detail::ranged_traits_impl<C> {};
|
2017-01-25 23:27:54 +00:00
|
|
|
|
2016-04-26 19:13:32 +00:00
|
|
|
template<typename T>
|
2017-03-02 18:45:57 +00:00
|
|
|
inline auto iter(T &&r) ->
|
|
|
|
decltype(ranged_traits<std::remove_reference_t<T>>::iter(r))
|
|
|
|
{
|
|
|
|
return ranged_traits<std::remove_reference_t<T>>::iter(r);
|
2015-06-09 20:18:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
template<typename T>
|
2017-01-25 23:27:54 +00:00
|
|
|
inline auto citer(T const &r) -> decltype(ranged_traits<T const>::iter(r)) {
|
|
|
|
return ranged_traits<T const>::iter(r);
|
2015-06-09 20:18:43 +00:00
|
|
|
}
|
|
|
|
|
2017-02-20 19:43:38 +00:00
|
|
|
namespace detail {
|
|
|
|
template<typename T>
|
|
|
|
static std::true_type test_iterable(decltype(ostd::iter(std::declval<T>())) *);
|
|
|
|
template<typename>
|
|
|
|
static std::false_type test_iterable(...);
|
|
|
|
|
|
|
|
template<typename T>
|
|
|
|
constexpr bool iterable_test = decltype(test_iterable<T>(0))::value;
|
|
|
|
}
|
|
|
|
|
2015-06-09 23:12:52 +00:00
|
|
|
template<typename T>
|
2017-02-16 19:02:55 +00:00
|
|
|
struct half_range: input_range<half_range<T>> {
|
2017-02-16 19:39:05 +00:00
|
|
|
using range_category = range_category_t <typename T::range>;
|
|
|
|
using value_type = range_value_t <typename T::range>;
|
|
|
|
using reference = range_reference_t <typename T::range>;
|
|
|
|
using size_type = range_size_t <typename T::range>;
|
|
|
|
using difference_type = range_difference_t<typename T::range>;
|
2017-02-13 22:04:02 +00:00
|
|
|
|
2015-06-09 23:12:52 +00:00
|
|
|
private:
|
|
|
|
T p_beg;
|
|
|
|
T p_end;
|
2017-02-13 22:04:02 +00:00
|
|
|
|
2015-06-09 23:12:52 +00:00
|
|
|
public:
|
2017-02-16 19:02:55 +00:00
|
|
|
half_range() = delete;
|
|
|
|
half_range(half_range const &range):
|
2016-07-31 19:40:25 +00:00
|
|
|
p_beg(range.p_beg), p_end(range.p_end)
|
|
|
|
{}
|
2017-02-16 19:02:55 +00:00
|
|
|
half_range(half_range &&range):
|
2017-01-25 00:44:22 +00:00
|
|
|
p_beg(std::move(range.p_beg)), p_end(std::move(range.p_end))
|
2016-07-31 19:40:25 +00:00
|
|
|
{}
|
2017-02-16 19:02:55 +00:00
|
|
|
half_range(T const &beg, T const &end):
|
2016-07-31 19:40:25 +00:00
|
|
|
p_beg(beg),p_end(end)
|
|
|
|
{}
|
2017-02-16 19:02:55 +00:00
|
|
|
half_range(T &&beg, T &&end):
|
2017-01-25 00:44:22 +00:00
|
|
|
p_beg(std::move(beg)), p_end(std::move(end))
|
2016-07-31 19:40:25 +00:00
|
|
|
{}
|
2015-06-09 23:12:52 +00:00
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
half_range &operator=(half_range const &range) {
|
2015-06-09 23:12:52 +00:00
|
|
|
p_beg = range.p_beg;
|
|
|
|
p_end = range.p_end;
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
half_range &operator=(half_range &&range) {
|
2017-01-25 00:44:22 +00:00
|
|
|
p_beg = std::move(range.p_beg);
|
|
|
|
p_end = std::move(range.p_end);
|
2015-06-09 23:12:52 +00:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool empty() const { return p_beg == p_end; }
|
|
|
|
|
2017-02-19 15:45:06 +00:00
|
|
|
void pop_front() {
|
|
|
|
p_beg.next();
|
2015-06-09 23:12:52 +00:00
|
|
|
}
|
2017-02-19 15:45:06 +00:00
|
|
|
void push_front() {
|
|
|
|
p_beg.prev();
|
2015-06-09 23:12:52 +00:00
|
|
|
}
|
2017-02-19 15:45:06 +00:00
|
|
|
void pop_back() {
|
|
|
|
p_end.prev();
|
2015-06-09 23:12:52 +00:00
|
|
|
}
|
2017-02-19 15:45:06 +00:00
|
|
|
void push_back() {
|
|
|
|
p_end.next();
|
2015-06-09 23:12:52 +00:00
|
|
|
}
|
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
reference front() const { return *p_beg; }
|
|
|
|
reference back() const { return *(p_end - 1); }
|
2015-06-09 23:12:52 +00:00
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
bool equals_front(half_range const &range) const {
|
2015-06-09 23:12:52 +00:00
|
|
|
return p_beg == range.p_beg;
|
|
|
|
}
|
2017-02-16 19:02:55 +00:00
|
|
|
bool equals_back(half_range const &range) const {
|
2015-06-09 23:12:52 +00:00
|
|
|
return p_end == range.p_end;
|
|
|
|
}
|
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
difference_type distance_front(half_range const &range) const {
|
2015-06-09 23:12:52 +00:00
|
|
|
return range.p_beg - p_beg;
|
|
|
|
}
|
2017-02-16 19:02:55 +00:00
|
|
|
difference_type distance_back(half_range const &range) const {
|
2015-06-09 23:12:52 +00:00
|
|
|
return range.p_end - p_end;
|
|
|
|
}
|
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
size_type size() const { return p_end - p_beg; }
|
2015-06-09 23:12:52 +00:00
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
half_range slice(size_type start, size_type end) const {
|
|
|
|
return half_range{p_beg + start, p_beg + end};
|
2015-06-09 23:12:52 +00:00
|
|
|
}
|
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
reference operator[](size_type idx) const {
|
2015-06-09 23:12:52 +00:00
|
|
|
return p_beg[idx];
|
|
|
|
}
|
|
|
|
|
2017-02-19 15:45:06 +00:00
|
|
|
void put(value_type const &v) {
|
|
|
|
p_beg.range().put(v);
|
2015-06-09 23:12:52 +00:00
|
|
|
}
|
2017-02-19 15:45:06 +00:00
|
|
|
void put(value_type &&v) {
|
|
|
|
p_beg.range().put(std::move(v));
|
2015-06-09 23:12:52 +00:00
|
|
|
}
|
2015-07-28 01:40:24 +00:00
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
value_type *data() { return p_beg.data(); }
|
|
|
|
value_type 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>
|
2017-02-16 19:02:55 +00:00
|
|
|
struct reverse_range: input_range<reverse_range<T>> {
|
|
|
|
using range_category = std::common_type_t<
|
|
|
|
range_category_t<T>, finite_random_access_range_tag
|
2017-02-13 22:04:02 +00:00
|
|
|
>;
|
2017-02-16 19:02:55 +00:00
|
|
|
using value_type = range_value_t <T>;
|
|
|
|
using reference = range_reference_t <T>;
|
|
|
|
using size_type = range_size_t <T>;
|
|
|
|
using difference_type = range_difference_t<T>;
|
2015-04-28 17:48:58 +00:00
|
|
|
|
2017-02-13 22:04:02 +00:00
|
|
|
private:
|
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:
|
2017-02-16 19:02:55 +00:00
|
|
|
reverse_range() = delete;
|
|
|
|
reverse_range(T const &range): p_range(range) {}
|
|
|
|
reverse_range(reverse_range const &it): p_range(it.p_range) {}
|
|
|
|
reverse_range(reverse_range &&it): p_range(std::move(it.p_range)) {}
|
2015-04-18 19:31:07 +00:00
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
reverse_range &operator=(reverse_range const &v) {
|
2015-06-03 22:55:11 +00:00
|
|
|
p_range = v.p_range;
|
|
|
|
return *this;
|
|
|
|
}
|
2017-02-16 19:02:55 +00:00
|
|
|
reverse_range &operator=(reverse_range &&v) {
|
2017-01-25 00:44:22 +00:00
|
|
|
p_range = std::move(v.p_range);
|
2015-06-03 22:55:11 +00:00
|
|
|
return *this;
|
|
|
|
}
|
2017-02-16 19:02:55 +00:00
|
|
|
reverse_range &operator=(T const &v) {
|
2015-06-03 22:55:11 +00:00
|
|
|
p_range = v;
|
|
|
|
return *this;
|
|
|
|
}
|
2017-02-16 19:02:55 +00:00
|
|
|
reverse_range &operator=(T &&v) {
|
2017-01-25 00:44:22 +00:00
|
|
|
p_range = std::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(); }
|
2017-02-16 19:02:55 +00:00
|
|
|
size_type size() const { return p_range.size(); }
|
2015-05-29 22:32:25 +00:00
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
bool equals_front(reverse_range 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
|
|
|
}
|
2017-02-16 19:02:55 +00:00
|
|
|
bool equals_back(reverse_range 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
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
difference_type distance_front(reverse_range const &r) const {
|
2015-06-03 22:55:11 +00:00
|
|
|
return -p_range.distance_back(r.p_range);
|
|
|
|
}
|
2017-02-16 19:02:55 +00:00
|
|
|
difference_type distance_back(reverse_range 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
|
|
|
|
2017-02-19 15:45:06 +00:00
|
|
|
void pop_front() { p_range.pop_back(); }
|
|
|
|
void pop_back() { p_range.pop_front(); }
|
2015-04-16 01:07:32 +00:00
|
|
|
|
2017-02-19 15:45:06 +00:00
|
|
|
void push_front() { p_range.push_back(); }
|
|
|
|
void push_back() { p_range.push_front(); }
|
2015-05-29 18:52:20 +00:00
|
|
|
|
2017-02-19 15:45:06 +00:00
|
|
|
void pop_front_n(size_type n) { p_range.pop_front_n(n); }
|
|
|
|
void pop_back_n(size_type n) { p_range.pop_back_n(n); }
|
2015-05-23 16:36:26 +00:00
|
|
|
|
2017-02-19 15:45:06 +00:00
|
|
|
void push_front_n(size_type n) { p_range.push_front_n(n); }
|
|
|
|
void push_back_n(size_type n) { p_range.push_back_n(n); }
|
2015-04-16 01:07:32 +00:00
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
reference front() const { return p_range.back(); }
|
|
|
|
reference back() const { return p_range.front(); }
|
2015-04-16 01:07:32 +00:00
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
reference operator[](size_type i) const { return p_range[size() - i - 1]; }
|
2015-04-16 01:07:32 +00:00
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
reverse_range slice(size_type start, size_type end) const {
|
|
|
|
size_type len = p_range.size();
|
|
|
|
return reverse_range{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>
|
2017-02-16 19:02:55 +00:00
|
|
|
struct move_range: input_range<move_range<T>> {
|
|
|
|
using range_category = std::common_type_t<
|
|
|
|
range_category_t<T>, finite_random_access_range_tag
|
2017-02-13 22:04:02 +00:00
|
|
|
>;
|
2017-02-16 19:02:55 +00:00
|
|
|
using value_type = range_value_t <T>;
|
|
|
|
using reference = range_value_t <T> &&;
|
|
|
|
using size_type = range_size_t <T>;
|
|
|
|
using difference_type = range_difference_t<T>;
|
2015-04-28 17:48:58 +00:00
|
|
|
|
2017-02-13 22:04:02 +00:00
|
|
|
private:
|
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:
|
2017-02-16 19:02:55 +00:00
|
|
|
move_range() = delete;
|
|
|
|
move_range(T const &range): p_range(range) {}
|
|
|
|
move_range(move_range const &it): p_range(it.p_range) {}
|
|
|
|
move_range(move_range &&it): p_range(std::move(it.p_range)) {}
|
2015-04-16 22:06:39 +00:00
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
move_range &operator=(move_range const &v) {
|
2015-06-03 22:55:11 +00:00
|
|
|
p_range = v.p_range;
|
|
|
|
return *this;
|
|
|
|
}
|
2017-02-16 19:02:55 +00:00
|
|
|
move_range &operator=(move_range &&v) {
|
2017-01-25 00:44:22 +00:00
|
|
|
p_range = std::move(v.p_range);
|
2015-06-03 22:55:11 +00:00
|
|
|
return *this;
|
|
|
|
}
|
2017-02-16 19:02:55 +00:00
|
|
|
move_range &operator=(T const &v) {
|
2015-06-03 22:55:11 +00:00
|
|
|
p_range = v;
|
|
|
|
return *this;
|
|
|
|
}
|
2017-02-16 19:02:55 +00:00
|
|
|
move_range &operator=(T &&v) {
|
2017-01-25 00:44:22 +00:00
|
|
|
p_range = std::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(); }
|
2017-02-16 19:02:55 +00:00
|
|
|
size_type size() const { return p_range.size(); }
|
2015-05-29 22:32:25 +00:00
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
bool equals_front(move_range const &r) const {
|
2015-06-03 22:55:11 +00:00
|
|
|
return p_range.equals_front(r.p_range);
|
|
|
|
}
|
2017-02-16 19:02:55 +00:00
|
|
|
bool equals_back(move_range 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
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
difference_type distance_front(move_range const &r) const {
|
2015-06-03 22:55:11 +00:00
|
|
|
return p_range.distance_front(r.p_range);
|
|
|
|
}
|
2017-02-16 19:02:55 +00:00
|
|
|
difference_type distance_back(move_range 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
|
|
|
|
2017-02-19 15:45:06 +00:00
|
|
|
void pop_front() { p_range.pop_front(); }
|
|
|
|
void pop_back() { p_range.pop_back(); }
|
2015-05-29 18:52:20 +00:00
|
|
|
|
2017-02-19 15:45:06 +00:00
|
|
|
void push_front() { p_range.push_front(); }
|
|
|
|
void push_back() { p_range.push_back(); }
|
2015-05-23 16:36:26 +00:00
|
|
|
|
2017-02-19 15:45:06 +00:00
|
|
|
void pop_front_n(size_type n) { p_range.pop_front_n(n); }
|
|
|
|
void pop_back_n(size_type n) { p_range.pop_back_n(n); }
|
2015-04-16 22:06:39 +00:00
|
|
|
|
2017-02-19 15:45:06 +00:00
|
|
|
void push_front_n(size_type n) { p_range.push_front_n(n); }
|
|
|
|
void push_back_n(size_type n) { p_range.push_back_n(n); }
|
2015-04-16 22:06:39 +00:00
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
reference front() const { return std::move(p_range.front()); }
|
|
|
|
reference back() const { return std::move(p_range.back()); }
|
2015-04-18 21:05:24 +00:00
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
reference operator[](size_type i) const { return std::move(p_range[i]); }
|
2015-04-16 22:26:10 +00:00
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
move_range slice(size_type start, size_type end) const {
|
|
|
|
return move_range{p_range.slice(start, end)};
|
2015-04-16 22:26:10 +00:00
|
|
|
}
|
2015-04-16 23:55:50 +00:00
|
|
|
|
2017-02-19 15:45:06 +00:00
|
|
|
void put(value_type const &v) { p_range.put(v); }
|
|
|
|
void put(value_type &&v) { p_range.put(std::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>
|
2017-02-16 19:02:55 +00:00
|
|
|
struct number_range: input_range<number_range<T>> {
|
|
|
|
using range_category = forward_range_tag;
|
|
|
|
using value_type = T;
|
|
|
|
using reference = T;
|
|
|
|
using size_type = size_t;
|
|
|
|
using difference_type = ptrdiff_t;
|
|
|
|
|
|
|
|
number_range() = delete;
|
|
|
|
number_range(T a, T b, T step = T(1)):
|
2016-07-31 19:40:25 +00:00
|
|
|
p_a(a), p_b(b), p_step(step)
|
|
|
|
{}
|
2017-02-16 19:02:55 +00:00
|
|
|
number_range(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
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
bool equals_front(number_range 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
|
|
|
|
2017-02-19 15:45:06 +00:00
|
|
|
void pop_front() { p_a += p_step; }
|
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>
|
2017-02-16 19:02:55 +00:00
|
|
|
inline number_range<T> range(T a, T b, T step = T(1)) {
|
|
|
|
return number_range<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>
|
2017-02-16 19:02:55 +00:00
|
|
|
inline number_range<T> range(T v) {
|
|
|
|
return number_range<T>(v);
|
2015-06-03 22:55:11 +00:00
|
|
|
}
|
2015-05-23 16:36:26 +00:00
|
|
|
|
2015-06-04 21:57:06 +00:00
|
|
|
template<typename T, typename S>
|
2017-02-16 19:02:55 +00:00
|
|
|
struct enumerated_value_t {
|
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>
|
2017-02-16 19:02:55 +00:00
|
|
|
struct enumerated_range: input_range<enumerated_range<T>> {
|
|
|
|
using range_category = std::common_type_t<
|
|
|
|
range_category_t<T>, forward_range_tag
|
|
|
|
>;
|
|
|
|
using value_type = range_value_t<T>;
|
|
|
|
using reference = enumerated_value_t<
|
|
|
|
range_reference_t<T>, range_size_t<T>
|
|
|
|
>;
|
|
|
|
using size_type = range_size_t <T>;
|
|
|
|
using difference_type = range_difference_t<T>;
|
2015-04-21 16:58:36 +00:00
|
|
|
|
2017-02-13 22:04:02 +00:00
|
|
|
private:
|
2015-06-04 21:57:06 +00:00
|
|
|
T p_range;
|
2017-02-16 19:02:55 +00:00
|
|
|
size_type p_index;
|
2015-04-28 17:48:58 +00:00
|
|
|
|
2015-06-03 22:55:11 +00:00
|
|
|
public:
|
2017-02-16 19:02:55 +00:00
|
|
|
enumerated_range() = delete;
|
2015-04-21 16:58:36 +00:00
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
enumerated_range(T const &range): p_range(range), p_index(0) {}
|
2015-04-21 16:58:36 +00:00
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
enumerated_range(enumerated_range 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
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
enumerated_range(enumerated_range &&it):
|
2017-01-25 00:44:22 +00:00
|
|
|
p_range(std::move(it.p_range)), p_index(it.p_index)
|
2016-07-31 19:40:25 +00:00
|
|
|
{}
|
2015-04-21 16:58:36 +00:00
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
enumerated_range &operator=(enumerated_range const &v) {
|
2015-06-03 22:55:11 +00:00
|
|
|
p_range = v.p_range;
|
|
|
|
p_index = v.p_index;
|
|
|
|
return *this;
|
|
|
|
}
|
2017-02-16 19:02:55 +00:00
|
|
|
enumerated_range &operator=(enumerated_range &&v) {
|
2017-01-25 00:44:22 +00:00
|
|
|
p_range = std::move(v.p_range);
|
2015-06-03 22:55:11 +00:00
|
|
|
p_index = v.p_index;
|
|
|
|
return *this;
|
|
|
|
}
|
2017-02-16 19:02:55 +00:00
|
|
|
enumerated_range &operator=(T const &v) {
|
2015-06-03 22:55:11 +00:00
|
|
|
p_range = v;
|
|
|
|
p_index = 0;
|
|
|
|
return *this;
|
|
|
|
}
|
2017-02-16 19:02:55 +00:00
|
|
|
enumerated_range &operator=(T &&v) {
|
2017-01-25 00:44:22 +00:00
|
|
|
p_range = std::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
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
bool equals_front(enumerated_range 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
|
|
|
|
2017-02-19 15:45:06 +00:00
|
|
|
void pop_front() {
|
|
|
|
p_range.pop_front();
|
|
|
|
++p_index;
|
2015-06-03 22:55:11 +00:00
|
|
|
}
|
2015-05-27 19:45:34 +00:00
|
|
|
|
2017-02-19 15:45:06 +00:00
|
|
|
void pop_front_n(size_type n) {
|
|
|
|
p_range.pop_front_n(n);
|
|
|
|
p_index += n;
|
2015-06-03 22:55:11 +00:00
|
|
|
}
|
2015-05-27 19:45:34 +00:00
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
reference front() const {
|
|
|
|
return reference{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>
|
2017-02-16 19:02:55 +00:00
|
|
|
struct take_range: input_range<take_range<T>> {
|
|
|
|
using range_category = std::common_type_t<
|
|
|
|
range_category_t<T>, forward_range_tag
|
|
|
|
>;
|
|
|
|
using value_type = range_value_t <T>;
|
|
|
|
using reference = range_reference_t <T>;
|
|
|
|
using size_type = range_size_t <T>;
|
|
|
|
using difference_type = range_difference_t<T>;
|
2017-02-13 22:04:02 +00:00
|
|
|
|
2015-06-03 22:55:11 +00:00
|
|
|
private:
|
2015-06-04 21:57:06 +00:00
|
|
|
T p_range;
|
2017-02-16 19:02:55 +00:00
|
|
|
size_type p_remaining;
|
2017-02-13 22:04:02 +00:00
|
|
|
|
2015-06-03 22:55:11 +00:00
|
|
|
public:
|
2017-02-16 19:02:55 +00:00
|
|
|
take_range() = delete;
|
|
|
|
take_range(T const &range, range_size_t<T> rem):
|
2016-07-31 19:40:25 +00:00
|
|
|
p_range(range), p_remaining(rem)
|
|
|
|
{}
|
2017-02-16 19:02:55 +00:00
|
|
|
take_range(take_range const &it):
|
2016-07-31 19:40:25 +00:00
|
|
|
p_range(it.p_range), p_remaining(it.p_remaining)
|
|
|
|
{}
|
2017-02-16 19:02:55 +00:00
|
|
|
take_range(take_range &&it):
|
2017-01-25 00:44:22 +00:00
|
|
|
p_range(std::move(it.p_range)), p_remaining(it.p_remaining)
|
2016-07-31 19:40:25 +00:00
|
|
|
{}
|
2015-06-03 22:55:11 +00:00
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
take_range &operator=(take_range const &v) {
|
2015-06-03 22:55:11 +00:00
|
|
|
p_range = v.p_range; p_remaining = v.p_remaining; return *this;
|
|
|
|
}
|
2017-02-16 19:02:55 +00:00
|
|
|
take_range &operator=(take_range &&v) {
|
2017-01-25 00:44:22 +00:00
|
|
|
p_range = std::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
|
|
|
|
2017-02-19 15:45:06 +00:00
|
|
|
void pop_front() {
|
|
|
|
p_range.pop_front();
|
|
|
|
if (p_remaining >= 1) {
|
2015-06-03 22:55:11 +00:00
|
|
|
--p_remaining;
|
2015-05-27 19:45:34 +00:00
|
|
|
}
|
|
|
|
}
|
2015-05-27 19:56:44 +00:00
|
|
|
|
2017-02-19 15:45:06 +00:00
|
|
|
void pop_front_n(size_type n) {
|
|
|
|
p_range.pop_front_n(n);
|
|
|
|
p_remaining -= std::min(n, p_remaining);
|
2015-06-03 22:55:11 +00:00
|
|
|
}
|
2015-05-29 22:32:25 +00:00
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
reference front() const { return p_range.front(); }
|
2015-05-27 19:56:44 +00:00
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
bool equals_front(take_range 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>
|
2017-02-16 19:02:55 +00:00
|
|
|
struct chunks_range: input_range<chunks_range<T>> {
|
|
|
|
using range_category = std::common_type_t<
|
|
|
|
range_category_t<T>, forward_range_tag
|
|
|
|
>;
|
|
|
|
using value_type = take_range <T>;
|
|
|
|
using reference = take_range <T>;
|
|
|
|
using size_type = range_size_t <T>;
|
|
|
|
using difference_type = range_difference_t<T>;
|
2017-02-13 22:04:02 +00:00
|
|
|
|
2015-06-03 22:55:11 +00:00
|
|
|
private:
|
2015-06-04 21:57:06 +00:00
|
|
|
T p_range;
|
2017-02-16 19:02:55 +00:00
|
|
|
size_type p_chunksize;
|
2017-02-13 22:04:02 +00:00
|
|
|
|
2015-06-03 22:55:11 +00:00
|
|
|
public:
|
2017-02-16 19:02:55 +00:00
|
|
|
chunks_range() = delete;
|
|
|
|
chunks_range(T const &range, range_size_t<T> chs):
|
2016-07-31 19:40:25 +00:00
|
|
|
p_range(range), p_chunksize(chs)
|
|
|
|
{}
|
2017-02-16 19:02:55 +00:00
|
|
|
chunks_range(chunks_range const &it):
|
2016-07-31 19:40:25 +00:00
|
|
|
p_range(it.p_range), p_chunksize(it.p_chunksize)
|
|
|
|
{}
|
2017-02-16 19:02:55 +00:00
|
|
|
chunks_range(chunks_range &&it):
|
2017-01-25 00:44:22 +00:00
|
|
|
p_range(std::move(it.p_range)), p_chunksize(it.p_chunksize)
|
2016-07-31 19:40:25 +00:00
|
|
|
{}
|
2015-06-03 22:55:11 +00:00
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
chunks_range &operator=(chunks_range const &v) {
|
2015-06-03 22:55:11 +00:00
|
|
|
p_range = v.p_range; p_chunksize = v.p_chunksize; return *this;
|
|
|
|
}
|
2017-02-16 19:02:55 +00:00
|
|
|
chunks_range &operator=(chunks_range &&v) {
|
2017-01-25 00:44:22 +00:00
|
|
|
p_range = std::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(); }
|
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
bool equals_front(chunks_range 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
|
|
|
}
|
|
|
|
|
2017-02-19 15:45:06 +00:00
|
|
|
void pop_front() { p_range.pop_front_n(p_chunksize); }
|
|
|
|
void pop_front_n(size_type n) {
|
|
|
|
p_range.pop_front_n(p_chunksize * n);
|
2015-06-03 22:55:11 +00:00
|
|
|
}
|
2015-05-29 22:32:25 +00:00
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
reference 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 {
|
2017-02-10 20:06:08 +00:00
|
|
|
template<size_t I, size_t N, typename T>
|
2017-02-19 15:45:06 +00:00
|
|
|
inline void join_range_pop(T &tup) {
|
2017-02-10 20:06:08 +00:00
|
|
|
if constexpr(I != N) {
|
2017-01-28 17:30:31 +00:00
|
|
|
if (!std::get<I>(tup).empty()) {
|
2017-02-19 15:45:06 +00:00
|
|
|
std::get<I>(tup).pop_front();
|
|
|
|
return;
|
2016-03-27 20:06:00 +00:00
|
|
|
}
|
2017-02-19 15:45:06 +00:00
|
|
|
join_range_pop<I + 1, N>(tup);
|
2016-03-27 20:06:00 +00:00
|
|
|
}
|
2017-02-10 20:06:08 +00:00
|
|
|
}
|
2016-03-27 20:06:00 +00:00
|
|
|
|
2017-01-30 18:11:39 +00:00
|
|
|
template<size_t I, size_t N, typename T>
|
2017-02-10 20:06:08 +00:00
|
|
|
inline auto join_range_front(T &tup) {
|
|
|
|
if constexpr(I != N) {
|
2017-01-28 17:30:31 +00:00
|
|
|
if (!std::get<I>(tup).empty()) {
|
|
|
|
return std::get<I>(tup).front();
|
2016-03-27 20:06:00 +00:00
|
|
|
}
|
2017-02-10 20:06:08 +00:00
|
|
|
return join_range_front<I + 1, N>(tup);
|
2016-03-27 20:06:00 +00:00
|
|
|
}
|
2017-02-19 15:45:06 +00:00
|
|
|
/* fallback, will probably throw */
|
2017-02-10 20:06:08 +00:00
|
|
|
return std::get<0>(tup).front();
|
|
|
|
}
|
2016-03-27 20:06:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
template<typename ...R>
|
2017-02-16 19:02:55 +00:00
|
|
|
struct join_range: input_range<join_range<R...>> {
|
|
|
|
using range_category = std::common_type_t<
|
|
|
|
forward_range_tag, range_category_t<R>...
|
|
|
|
>;
|
|
|
|
using value_type = std::common_type_t<range_value_t<R>...>;
|
|
|
|
using reference = std::common_type_t<range_reference_t<R>...>;
|
|
|
|
using size_type = std::common_type_t<range_size_t<R>...>;
|
|
|
|
using difference_type = std::common_type_t<range_difference_t<R>...>;
|
2017-02-13 22:04:02 +00:00
|
|
|
|
2016-03-27 20:06:00 +00:00
|
|
|
private:
|
2017-01-28 17:30:31 +00:00
|
|
|
std::tuple<R...> p_ranges;
|
2017-02-13 22:04:02 +00:00
|
|
|
|
2016-03-27 20:06:00 +00:00
|
|
|
public:
|
2017-02-16 19:02:55 +00:00
|
|
|
join_range() = delete;
|
|
|
|
join_range(R const &...ranges): p_ranges(ranges...) {}
|
|
|
|
join_range(R &&...ranges): p_ranges(std::forward<R>(ranges)...) {}
|
|
|
|
join_range(join_range const &v): p_ranges(v.p_ranges) {}
|
|
|
|
join_range(join_range &&v): p_ranges(std::move(v.p_ranges)) {}
|
2016-03-27 20:06:00 +00:00
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
join_range &operator=(join_range const &v) {
|
2016-03-27 20:06:00 +00:00
|
|
|
p_ranges = v.p_ranges;
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
join_range &operator=(join_range &&v) {
|
2017-01-25 00:44:22 +00:00
|
|
|
p_ranges = std::move(v.p_ranges);
|
2016-03-27 20:06:00 +00:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool empty() const {
|
2017-02-10 19:26:13 +00:00
|
|
|
return std::apply([](auto const &...args) {
|
|
|
|
return (... && args.empty());
|
|
|
|
}, p_ranges);
|
2016-03-27 20:06:00 +00:00
|
|
|
}
|
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
bool equals_front(join_range const &r) const {
|
2017-02-18 13:30:00 +00:00
|
|
|
return std::apply([&r](auto const &...r1) mutable {
|
|
|
|
return std::apply([&](auto const &...r2) mutable {
|
2017-02-10 19:26:13 +00:00
|
|
|
return (... && r1.equals_front(r2));
|
|
|
|
}, r);
|
|
|
|
}, p_ranges);
|
2016-03-27 20:06:00 +00:00
|
|
|
}
|
|
|
|
|
2017-02-19 15:45:06 +00:00
|
|
|
void pop_front() {
|
|
|
|
detail::join_range_pop<0, sizeof...(R)>(p_ranges);
|
2016-03-27 20:06:00 +00:00
|
|
|
}
|
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
reference front() const {
|
2017-02-10 20:06:08 +00:00
|
|
|
return detail::join_range_front<0, sizeof...(R)>(p_ranges);
|
2016-03-27 20:06:00 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2016-03-27 22:49:27 +00:00
|
|
|
namespace detail {
|
|
|
|
template<typename ...T>
|
2017-02-16 19:02:55 +00:00
|
|
|
struct zip_value_type {
|
|
|
|
using type = std::tuple<T...>;
|
2016-03-27 22:49:27 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
template<typename T, typename U>
|
2017-02-16 19:02:55 +00:00
|
|
|
struct zip_value_type<T, U> {
|
|
|
|
using type = std::pair<T, U>;
|
2016-03-27 22:49:27 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
template<typename ...T>
|
2017-02-16 19:02:55 +00:00
|
|
|
using zip_value_t = typename detail::zip_value_type<T...>::type;
|
2016-03-27 22:49:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
template<typename ...R>
|
2017-02-16 19:02:55 +00:00
|
|
|
struct zip_range: input_range<zip_range<R...>> {
|
|
|
|
using range_category = std::common_type_t<
|
|
|
|
forward_range_tag, range_category_t<R>...
|
|
|
|
>;
|
|
|
|
using value_type = detail::zip_value_t<range_value_t<R>...>;
|
|
|
|
using reference = detail::zip_value_t<range_reference_t<R>...>;
|
|
|
|
using size_type = std::common_type_t<range_size_t<R>...>;
|
|
|
|
using difference_type = std::common_type_t<range_difference_t<R>...>;
|
2017-02-13 22:04:02 +00:00
|
|
|
|
2016-03-27 22:49:27 +00:00
|
|
|
private:
|
2017-01-28 17:30:31 +00:00
|
|
|
std::tuple<R...> p_ranges;
|
2017-02-13 22:04:02 +00:00
|
|
|
|
2016-03-27 22:49:27 +00:00
|
|
|
public:
|
2017-02-16 19:02:55 +00:00
|
|
|
zip_range() = delete;
|
|
|
|
zip_range(R const &...ranges): p_ranges(ranges...) {}
|
|
|
|
zip_range(R &&...ranges): p_ranges(std::forward<R>(ranges)...) {}
|
|
|
|
zip_range(zip_range const &v): p_ranges(v.p_ranges) {}
|
|
|
|
zip_range(zip_range &&v): p_ranges(std::move(v.p_ranges)) {}
|
2016-03-27 22:49:27 +00:00
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
zip_range &operator=(zip_range const &v) {
|
2016-03-27 22:49:27 +00:00
|
|
|
p_ranges = v.p_ranges;
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
zip_range &operator=(zip_range &&v) {
|
2017-01-25 00:44:22 +00:00
|
|
|
p_ranges = std::move(v.p_ranges);
|
2016-03-27 22:49:27 +00:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool empty() const {
|
2017-02-10 19:26:13 +00:00
|
|
|
return std::apply([](auto const &...args) {
|
|
|
|
return (... || args.empty());
|
|
|
|
}, p_ranges);
|
2016-03-27 22:49:27 +00:00
|
|
|
}
|
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
bool equals_front(zip_range const &r) const {
|
2017-02-18 13:30:00 +00:00
|
|
|
return std::apply([&r](auto const &...r1) mutable {
|
|
|
|
return std::apply([&](auto const &...r2) mutable {
|
2017-02-10 19:26:13 +00:00
|
|
|
return (... && r1.equals_front(r2));
|
|
|
|
}, r);
|
|
|
|
}, p_ranges);
|
2016-03-27 22:49:27 +00:00
|
|
|
}
|
|
|
|
|
2017-02-19 15:45:06 +00:00
|
|
|
void pop_front() {
|
|
|
|
std::apply([](auto &...args) {
|
|
|
|
(args.pop_front(), ...);
|
2017-02-10 19:26:13 +00:00
|
|
|
}, p_ranges);
|
2016-03-27 22:49:27 +00:00
|
|
|
}
|
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
reference front() const {
|
2017-02-10 19:26:13 +00:00
|
|
|
return std::apply([](auto &&...args) {
|
2017-02-16 19:02:55 +00:00
|
|
|
return reference{args.front()...};
|
2017-02-10 19:26:13 +00:00
|
|
|
}, p_ranges);
|
2016-03-27 22:49:27 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2015-07-04 20:09:07 +00:00
|
|
|
template<typename T>
|
2017-02-16 19:02:55 +00:00
|
|
|
struct appender_range: output_range<appender_range<T>> {
|
|
|
|
using value_type = typename T::value_type;
|
|
|
|
using reference = typename T::reference;
|
|
|
|
using size_type = typename T::size_type;
|
|
|
|
using difference_type = typename T::difference_type;
|
|
|
|
|
|
|
|
appender_range(): p_data() {}
|
|
|
|
appender_range(T const &v): p_data(v) {}
|
|
|
|
appender_range(T &&v): p_data(std::move(v)) {}
|
|
|
|
appender_range(appender_range const &v): p_data(v.p_data) {}
|
|
|
|
appender_range(appender_range &&v): p_data(std::move(v.p_data)) {}
|
|
|
|
|
|
|
|
appender_range &operator=(appender_range const &v) {
|
2015-07-04 20:09:07 +00:00
|
|
|
p_data = v.p_data;
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
appender_range &operator=(appender_range &&v) {
|
2017-01-25 00:44:22 +00:00
|
|
|
p_data = std::move(v.p_data);
|
2015-07-04 20:09:07 +00:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
appender_range &operator=(T const &v) {
|
2015-07-04 20:09:07 +00:00
|
|
|
p_data = v;
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
appender_range &operator=(T &&v) {
|
2017-01-25 00:44:22 +00:00
|
|
|
p_data = std::move(v);
|
2015-07-04 20:09:07 +00:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
void clear() { p_data.clear(); }
|
2017-03-02 17:12:00 +00:00
|
|
|
bool empty() const { return p_data.empty(); }
|
2015-07-04 20:09:07 +00:00
|
|
|
|
2017-01-29 23:54:06 +00:00
|
|
|
void reserve(typename T::size_type cap) { p_data.reserve(cap); }
|
|
|
|
void resize(typename T::size_type len) { p_data.resize(len); }
|
2015-07-04 20:09:07 +00:00
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
size_type size() const { return p_data.size(); }
|
|
|
|
size_type capacity() const { return p_data.capacity(); }
|
2015-07-04 20:09:07 +00:00
|
|
|
|
2017-02-19 15:45:06 +00:00
|
|
|
void put(typename T::const_reference v) {
|
2017-01-29 23:54:06 +00:00
|
|
|
p_data.push_back(v);
|
2015-07-04 20:09:07 +00:00
|
|
|
}
|
|
|
|
|
2017-02-19 15:45:06 +00:00
|
|
|
void put(typename T::value_type &&v) {
|
2017-01-29 23:54:06 +00:00
|
|
|
p_data.push_back(std::move(v));
|
2015-07-04 20:09:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
T &get() { return p_data; }
|
|
|
|
private:
|
|
|
|
T p_data;
|
|
|
|
};
|
|
|
|
|
2017-02-18 18:05:03 +00:00
|
|
|
template<typename T>
|
|
|
|
inline appender_range<T> appender() {
|
|
|
|
return appender_range<T>();
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename T>
|
|
|
|
inline appender_range<T> appender(T &&v) {
|
|
|
|
return appender_range<T>(std::forward<T>(v));
|
|
|
|
}
|
|
|
|
|
2017-01-30 21:07:12 +00:00
|
|
|
namespace detail {
|
|
|
|
template<typename>
|
2017-02-16 19:02:55 +00:00
|
|
|
struct iterator_range_tag_base {
|
2017-01-30 21:07:12 +00:00
|
|
|
/* fallback, the most basic range */
|
2017-02-16 19:39:05 +00:00
|
|
|
using type = input_range_tag;
|
2017-01-30 21:07:12 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
template<>
|
2017-02-16 19:02:55 +00:00
|
|
|
struct iterator_range_tag_base<std::output_iterator_tag> {
|
2017-02-16 19:39:05 +00:00
|
|
|
using type = output_range_tag;
|
2017-01-30 21:07:12 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
template<>
|
2017-02-16 19:02:55 +00:00
|
|
|
struct iterator_range_tag_base<std::forward_iterator_tag> {
|
2017-02-16 19:39:05 +00:00
|
|
|
using type = forward_range_tag;
|
2017-01-30 21:07:12 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
template<>
|
2017-02-16 19:02:55 +00:00
|
|
|
struct iterator_range_tag_base<std::bidirectional_iterator_tag> {
|
2017-02-16 19:39:05 +00:00
|
|
|
using type = bidirectional_range_tag;
|
2017-01-30 21:07:12 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
template<>
|
2017-02-16 19:02:55 +00:00
|
|
|
struct iterator_range_tag_base<std::random_access_iterator_tag> {
|
2017-02-16 19:39:05 +00:00
|
|
|
using type = finite_random_access_range_tag;
|
2017-01-30 21:07:12 +00:00
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename T>
|
2017-02-16 19:39:05 +00:00
|
|
|
using iterator_range_tag = typename detail::iterator_range_tag_base<T>::type;
|
2017-01-30 21:07:12 +00:00
|
|
|
|
|
|
|
template<typename T>
|
2017-02-16 19:02:55 +00:00
|
|
|
struct iterator_range: input_range<iterator_range<T>> {
|
|
|
|
using range_category = std::conditional_t<
|
2017-02-09 22:37:31 +00:00
|
|
|
std::is_pointer_v<T>,
|
2017-02-16 19:39:05 +00:00
|
|
|
contiguous_range_tag,
|
2017-02-16 19:02:55 +00:00
|
|
|
iterator_range_tag<typename std::iterator_traits<T>::iterator_category>
|
2017-02-13 22:04:02 +00:00
|
|
|
>;
|
2017-02-16 19:02:55 +00:00
|
|
|
using value_type = typename std::iterator_traits<T>::value_type;
|
|
|
|
using reference = typename std::iterator_traits<T>::reference;
|
|
|
|
using size_type = std::make_unsigned_t<
|
2017-02-13 22:04:02 +00:00
|
|
|
typename std::iterator_traits<T>::difference_type
|
|
|
|
>;
|
2017-02-16 19:02:55 +00:00
|
|
|
using difference_type = typename std::iterator_traits<T>::difference_type;
|
2017-01-30 21:07:12 +00:00
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
iterator_range(T beg = T{}, T end = T{}): p_beg(beg), p_end(end) {}
|
2017-01-30 21:07:12 +00:00
|
|
|
|
2017-02-09 22:37:31 +00:00
|
|
|
template<typename U, typename = std::enable_if_t<
|
|
|
|
std::is_pointer_v<T> && std::is_pointer_v<U> &&
|
|
|
|
std::is_convertible_v<U, T>
|
|
|
|
>>
|
2017-02-16 19:02:55 +00:00
|
|
|
iterator_range(iterator_range<U> const &v): p_beg(&v[0]), p_end(&v[v.size()]) {}
|
2017-02-09 22:37:31 +00:00
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
iterator_range(iterator_range const &v): p_beg(v.p_beg), p_end(v.p_end) {}
|
|
|
|
iterator_range(iterator_range &&v):
|
2017-01-30 21:07:12 +00:00
|
|
|
p_beg(std::move(v.p_beg)), p_end(std::move(v.p_end))
|
|
|
|
{}
|
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
iterator_range &operator=(iterator_range const &v) {
|
2017-01-30 21:07:12 +00:00
|
|
|
p_beg = v.p_beg;
|
|
|
|
p_end = v.p_end;
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
iterator_range &operator=(iterator_range &&v) {
|
2017-01-30 21:07:12 +00:00
|
|
|
p_beg = std::move(v.p_beg);
|
|
|
|
p_end = std::move(v.p_end);
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
/* satisfy input_range / forward_range */
|
2017-01-30 21:07:12 +00:00
|
|
|
bool empty() const { return p_beg == p_end; }
|
|
|
|
|
2017-02-19 15:45:06 +00:00
|
|
|
void pop_front() {
|
2017-01-30 21:07:12 +00:00
|
|
|
++p_beg;
|
2017-02-19 15:45:06 +00:00
|
|
|
/* rely on iterators to do their own checks */
|
|
|
|
if constexpr(std::is_pointer_v<T>) {
|
|
|
|
if (p_beg > p_end) {
|
|
|
|
throw std::out_of_range{"pop_front on empty range"};
|
|
|
|
}
|
|
|
|
}
|
2017-01-30 21:07:12 +00:00
|
|
|
}
|
2017-02-19 15:45:06 +00:00
|
|
|
void push_front() {
|
|
|
|
--p_beg;
|
2017-01-30 21:07:12 +00:00
|
|
|
}
|
|
|
|
|
2017-02-19 15:45:06 +00:00
|
|
|
void pop_front_n(size_type n) {
|
2017-02-09 22:37:31 +00:00
|
|
|
using IC = typename std::iterator_traits<T>::iterator_category;
|
|
|
|
if constexpr(std::is_convertible_v<IC, std::random_access_iterator_tag>) {
|
|
|
|
p_beg += n;
|
2017-02-19 15:45:06 +00:00
|
|
|
/* rely on iterators to do their own checks */
|
|
|
|
if constexpr(std::is_pointer_v<T>) {
|
|
|
|
if (p_beg > p_end) {
|
|
|
|
throw std::out_of_range{"pop_front_n of too many elements"};
|
|
|
|
}
|
2017-02-09 22:37:31 +00:00
|
|
|
}
|
|
|
|
} else {
|
2017-02-19 15:45:06 +00:00
|
|
|
detail::pop_front_n(*this, n);
|
2017-02-09 22:37:31 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-19 15:45:06 +00:00
|
|
|
void push_front_n(size_type n) {
|
2017-02-09 22:37:31 +00:00
|
|
|
using IC = typename std::iterator_traits<T>::iterator_category;
|
|
|
|
if constexpr(std::is_convertible_v<IC, std::random_access_iterator_tag>) {
|
|
|
|
p_beg -= n;
|
|
|
|
} else {
|
2017-02-19 15:45:06 +00:00
|
|
|
detail::push_front_n(*this, n);
|
2017-02-09 22:37:31 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
reference front() const { return *p_beg; }
|
2017-01-30 21:07:12 +00:00
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
bool equals_front(iterator_range const &range) const {
|
2017-01-30 21:07:12 +00:00
|
|
|
return p_beg == range.p_beg;
|
|
|
|
}
|
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
difference_type distance_front(iterator_range const &range) const {
|
2017-01-30 21:07:12 +00:00
|
|
|
return range.p_beg - p_beg;
|
|
|
|
}
|
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
/* satisfy bidirectional_range */
|
2017-02-19 15:45:06 +00:00
|
|
|
void pop_back() {
|
|
|
|
/* rely on iterators to do their own checks */
|
|
|
|
if constexpr(std::is_pointer_v<T>) {
|
|
|
|
if (p_end == p_beg) {
|
|
|
|
throw std::out_of_range{"pop_back on empty range"};
|
|
|
|
}
|
2017-01-30 21:07:12 +00:00
|
|
|
}
|
|
|
|
--p_end;
|
|
|
|
}
|
2017-02-19 15:45:06 +00:00
|
|
|
void push_back() {
|
|
|
|
++p_end;
|
2017-01-30 21:07:12 +00:00
|
|
|
}
|
|
|
|
|
2017-02-19 15:45:06 +00:00
|
|
|
void pop_back_n(size_type n) {
|
2017-02-09 22:37:31 +00:00
|
|
|
using IC = typename std::iterator_traits<T>::iterator_category;
|
|
|
|
if constexpr(std::is_convertible_v<IC, std::random_access_iterator_tag>) {
|
|
|
|
p_end -= n;
|
2017-02-19 15:45:06 +00:00
|
|
|
/* rely on iterators to do their own checks */
|
|
|
|
if constexpr(std::is_pointer_v<T>) {
|
|
|
|
if (p_end < p_beg) {
|
|
|
|
throw std::out_of_range{"pop_back_n of too many elements"};
|
|
|
|
}
|
2017-02-09 22:37:31 +00:00
|
|
|
}
|
|
|
|
} else {
|
2017-02-19 15:45:06 +00:00
|
|
|
detail::pop_back_n(*this, n);
|
2017-02-09 22:37:31 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-19 15:45:06 +00:00
|
|
|
void push_back_n(size_type n) {
|
2017-02-09 22:37:31 +00:00
|
|
|
using IC = typename std::iterator_traits<T>::iterator_category;
|
|
|
|
if constexpr(std::is_convertible_v<IC, std::random_access_iterator_tag>) {
|
|
|
|
p_end += n;
|
|
|
|
} else {
|
2017-02-19 15:45:06 +00:00
|
|
|
detail::push_back_n(*this, n);
|
2017-02-09 22:37:31 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
reference back() const { return *(p_end - 1); }
|
2017-01-30 21:07:12 +00:00
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
bool equals_back(iterator_range const &range) const {
|
2017-01-30 21:07:12 +00:00
|
|
|
return p_end == range.p_end;
|
|
|
|
}
|
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
ptrdiff_t distance_back(iterator_range const &range) const {
|
2017-01-30 21:07:12 +00:00
|
|
|
return range.p_end - p_end;
|
|
|
|
}
|
|
|
|
|
2017-02-16 19:39:05 +00:00
|
|
|
/* satisfy finite_random_access_range */
|
2017-02-16 19:02:55 +00:00
|
|
|
size_type size() const { return size_type(p_end - p_beg); }
|
2017-01-30 21:07:12 +00:00
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
iterator_range slice(size_type start, size_type end) const {
|
|
|
|
return iterator_range(p_beg + start, p_beg + end);
|
2017-01-30 21:07:12 +00:00
|
|
|
}
|
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
reference operator[](size_type i) const { return p_beg[i]; }
|
2017-01-30 21:07:12 +00:00
|
|
|
|
2017-02-18 15:21:03 +00:00
|
|
|
/* statisfy contiguous_range */
|
|
|
|
value_type *data() { return p_beg; }
|
|
|
|
value_type const *data() const { return p_beg; }
|
|
|
|
|
2017-02-16 19:02:55 +00:00
|
|
|
/* satisfy output_range */
|
2017-02-19 15:45:06 +00:00
|
|
|
void put(value_type const &v) {
|
2017-02-19 17:31:08 +00:00
|
|
|
/* rely on iterators to do their own checks */
|
|
|
|
if constexpr(std::is_pointer_v<T>) {
|
|
|
|
if (p_beg == p_end) {
|
|
|
|
throw std::out_of_range{"put into an empty range"};
|
|
|
|
}
|
|
|
|
}
|
2017-01-30 21:07:12 +00:00
|
|
|
*(p_beg++) = v;
|
|
|
|
}
|
2017-02-19 15:45:06 +00:00
|
|
|
void put(value_type &&v) {
|
2017-02-19 17:31:08 +00:00
|
|
|
if constexpr(std::is_pointer_v<T>) {
|
|
|
|
if (p_beg == p_end) {
|
|
|
|
throw std::out_of_range{"put into an empty range"};
|
|
|
|
}
|
|
|
|
}
|
2017-01-30 21:07:12 +00:00
|
|
|
*(p_beg++) = std::move(v);
|
2017-02-09 22:37:31 +00:00
|
|
|
}
|
|
|
|
|
2017-01-30 21:07:12 +00:00
|
|
|
private:
|
|
|
|
T p_beg, p_end;
|
|
|
|
};
|
|
|
|
|
|
|
|
template<typename T>
|
2017-02-16 19:02:55 +00:00
|
|
|
iterator_range<T> make_range(T beg, T end) {
|
|
|
|
return iterator_range<T>{beg, end};
|
2017-01-30 21:07:12 +00:00
|
|
|
}
|
|
|
|
|
2017-02-15 18:13:52 +00:00
|
|
|
template<typename T>
|
|
|
|
struct ranged_traits<std::initializer_list<T>> {
|
2017-02-16 19:02:55 +00:00
|
|
|
using range = iterator_range<T const *>;
|
2017-02-15 18:13:52 +00:00
|
|
|
|
|
|
|
static range iter(std::initializer_list<T> il) {
|
|
|
|
return range{il.begin(), il.end()};
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
/* ranged_traits for initializer lists is not enough; we need to be able to
|
|
|
|
* call ostd::iter({initializer list}) and that won't match against a generic
|
|
|
|
* template, so we also need to define that here explicitly...
|
|
|
|
*/
|
2017-02-14 16:44:24 +00:00
|
|
|
template<typename T>
|
2017-02-16 19:02:55 +00:00
|
|
|
iterator_range<T const *> iter(std::initializer_list<T> init) noexcept {
|
|
|
|
return iterator_range<T const *>(init.begin(), init.end());
|
2017-02-14 16:44:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
template<typename T>
|
2017-02-16 19:02:55 +00:00
|
|
|
iterator_range<T const *> citer(std::initializer_list<T> init) noexcept {
|
|
|
|
return iterator_range<T const *>(init.begin(), init.end());
|
2017-02-14 16:44:24 +00:00
|
|
|
}
|
|
|
|
|
2017-02-14 16:39:03 +00:00
|
|
|
template<typename T, size_t N>
|
|
|
|
struct ranged_traits<T[N]> {
|
2017-02-16 19:02:55 +00:00
|
|
|
using range = iterator_range<T *>;
|
2017-02-15 18:13:52 +00:00
|
|
|
|
|
|
|
static range iter(T (&array)[N]) {
|
|
|
|
return range{array, array + N};
|
2017-02-14 16:39:03 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2017-02-15 18:38:27 +00:00
|
|
|
template<typename T>
|
2017-02-16 19:02:55 +00:00
|
|
|
inline iterator_range<T *> iter(T *a, T *b) {
|
|
|
|
return iterator_range<T *>(a, b);
|
2017-02-14 16:39:03 +00:00
|
|
|
}
|
|
|
|
|
2017-02-14 17:32:51 +00:00
|
|
|
/* iter on standard containers */
|
|
|
|
|
|
|
|
namespace detail {
|
2017-02-18 13:30:00 +00:00
|
|
|
/* std iter is available, but at the same time direct iter is not */
|
2017-02-14 17:32:51 +00:00
|
|
|
template<typename C>
|
2017-02-18 13:30:00 +00:00
|
|
|
struct ranged_traits_core<C, false, true> {
|
2017-02-16 19:02:55 +00:00
|
|
|
using range = iterator_range<decltype(std::begin(std::declval<C &>()))>;
|
2017-02-15 18:13:52 +00:00
|
|
|
|
|
|
|
static range iter(C &r) {
|
|
|
|
return range{r.begin(), r.end()};
|
2017-02-14 17:32:51 +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
|