This repository was archived by the owner on Oct 29, 2020. It is now read-only.
forked from ryanhaining/cppitertools
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathzip_longest.hpp
More file actions
118 lines (95 loc) · 3.34 KB
/
Copy pathzip_longest.hpp
File metadata and controls
118 lines (95 loc) · 3.34 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
#ifndef ITER_ZIP_LONGEST_HPP_
#define ITER_ZIP_LONGEST_HPP_
#include "internal/iter_tuples.hpp"
#include "internal/iterbase.hpp"
#include <boost/optional.hpp>
#include <iterator>
#include <tuple>
#include <utility>
namespace iter {
namespace impl {
template <typename TupleType, std::size_t... Is>
class ZippedLongest;
template <typename TupleType, std::size_t... Is>
ZippedLongest<TupleType, Is...> zip_longest_impl(
TupleType&&, std::index_sequence<Is...>);
}
template <typename... Containers>
auto zip_longest(Containers&&... containers);
}
template <typename TupleType, std::size_t... Is>
class iter::impl::ZippedLongest {
private:
TupleType containers_;
friend ZippedLongest zip_longest_impl<TupleType, Is...>(
TupleType&&, std::index_sequence<Is...>);
template <std::size_t I>
using OptType =
boost::optional<iterator_deref<std::tuple_element_t<I, TupleType>>>;
using ZipIterDeref = std::tuple<OptType<Is>...>;
ZippedLongest(TupleType&& containers) : containers_(std::move(containers)) {}
public:
ZippedLongest(ZippedLongest&&) = default;
class Iterator : public std::iterator<std::input_iterator_tag, ZipIterDeref> {
private:
iterator_tuple_type<TupleType> iters_;
iterator_tuple_type<TupleType> ends_;
public:
Iterator(iterator_tuple_type<TupleType>&& iters,
iterator_tuple_type<TupleType>&& ends)
: iters_(std::move(iters)), ends_(std::move(ends)) {}
Iterator& operator++() {
// increment every iterator that's not already at
// the end
absorb(((std::get<Is>(iters_) != std::get<Is>(ends_))
? (++std::get<Is>(iters_), 0)
: 0)...);
return *this;
}
Iterator operator++(int) {
auto ret = *this;
++*this;
return ret;
}
bool operator!=(const Iterator& other) const {
if (sizeof...(Is) == 0) return false;
bool results[] = {
false, (std::get<Is>(iters_) != std::get<Is>(other.iters_))...};
return std::any_of(
get_begin(results), get_end(results), [](bool b) { return b; });
}
bool operator==(const Iterator& other) const {
return !(*this != other);
}
ZipIterDeref operator*() {
return ZipIterDeref{((std::get<Is>(iters_) != std::get<Is>(ends_))
? OptType<Is>{*std::get<Is>(iters_)}
: OptType<Is>{})...};
}
auto operator-> () -> ArrowProxy<decltype(**this)> {
return {**this};
}
};
Iterator begin() {
return {
iterator_tuple_type<TupleType>{get_begin(std::get<Is>(containers_))...},
iterator_tuple_type<TupleType>{get_end(std::get<Is>(containers_))...}};
}
Iterator end() {
return {
iterator_tuple_type<TupleType>{get_end(std::get<Is>(containers_))...},
iterator_tuple_type<TupleType>{get_end(std::get<Is>(containers_))...}};
}
};
template <typename TupleType, std::size_t... Is>
iter::impl::ZippedLongest<TupleType, Is...> iter::impl::zip_longest_impl(
TupleType&& containers, std::index_sequence<Is...>) {
return {std::move(containers)};
}
template <typename... Containers>
auto iter::zip_longest(Containers&&... containers) {
return impl::zip_longest_impl(
std::tuple<Containers...>{std::forward<Containers>(containers)...},
std::index_sequence_for<Containers...>{});
}
#endif