forked from ryanhaining/cppitertools
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathchunked.hpp
More file actions
129 lines (105 loc) · 3.1 KB
/
Copy pathchunked.hpp
File metadata and controls
129 lines (105 loc) · 3.1 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
119
120
121
122
123
124
125
126
127
128
129
#ifndef ITER_CHUNKED_HPP_
#define ITER_CHUNKED_HPP_
#include "internal/iterbase.hpp"
#include "internal/iteratoriterator.hpp"
#include <vector>
#include <algorithm>
#include <type_traits>
#include <functional>
#include <utility>
#include <iterator>
#include <initializer_list>
namespace iter {
namespace impl {
template <typename Container>
class Chunker;
}
template <typename Container>
impl::Chunker<Container> chunked(Container&&, std::size_t);
template <typename T>
impl::Chunker<std::initializer_list<T>> chunked(
std::initializer_list<T>, std::size_t);
}
template <typename Container>
class iter::impl::Chunker {
private:
Container container;
std::size_t chunk_size;
Chunker(Container&& c, std::size_t sz)
: container(std::forward<Container>(c)), chunk_size{sz} {}
friend Chunker iter::chunked<Container>(Container&&, std::size_t);
template <typename T>
friend Chunker<std::initializer_list<T>> iter::chunked(
std::initializer_list<T>, std::size_t);
using IndexVector = std::vector<iterator_type<Container>>;
using DerefVec = IterIterWrapper<IndexVector>;
public:
Chunker(Chunker&&) = default;
class Iterator : public std::iterator<std::input_iterator_tag, DerefVec> {
private:
iterator_type<Container> sub_iter;
iterator_type<Container> sub_end;
DerefVec chunk;
std::size_t chunk_size = 0;
bool done() const {
return this->chunk.empty();
}
void refill_chunk() {
this->chunk.get().clear();
std::size_t i{0};
while (i < chunk_size && this->sub_iter != this->sub_end) {
chunk.get().push_back(this->sub_iter);
++this->sub_iter;
++i;
}
}
public:
Iterator(iterator_type<Container>&& in_iter,
iterator_type<Container>&& in_end, std::size_t s)
: sub_iter{std::move(in_iter)},
sub_end{std::move(in_end)},
chunk_size{s} {
this->chunk.get().reserve(this->chunk_size);
this->refill_chunk();
}
Iterator& operator++() {
this->refill_chunk();
return *this;
}
Iterator operator++(int) {
auto ret = *this;
++*this;
return ret;
}
bool operator!=(const Iterator& other) const {
return !(*this == other);
}
bool operator==(const Iterator& other) const {
return this->done() == other.done()
&& (this->done() || !(this->sub_iter != other.sub_iter));
}
DerefVec& operator*() {
return this->chunk;
}
DerefVec* operator->() {
return &this->chunk;
}
};
Iterator begin() {
return {std::begin(this->container), std::end(this->container), chunk_size};
}
Iterator end() {
return {std::end(this->container), std::end(this->container), chunk_size};
}
};
template <typename Container>
iter::impl::Chunker<Container> iter::chunked(
Container&& container, std::size_t chunk_size) {
return {std::forward<Container>(container), chunk_size};
}
template <typename T>
iter::impl::Chunker<std::initializer_list<T>> iter::chunked(
std::initializer_list<T> il, std::size_t chunk_size) {
return {std::move(il), chunk_size};
}
#endif