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 pathcombinations.hpp
More file actions
132 lines (111 loc) · 3.13 KB
/
Copy pathcombinations.hpp
File metadata and controls
132 lines (111 loc) · 3.13 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
130
131
132
#ifndef ITER_COMBINATIONS_HPP_
#define ITER_COMBINATIONS_HPP_
#include "internal/iteratoriterator.hpp"
#include "internal/iterbase.hpp"
#include <iterator>
#include <type_traits>
#include <vector>
namespace iter {
namespace impl {
template <typename Container>
class Combinator;
using CombinationsFn = IterToolFnBindSizeTSecond<Combinator>;
}
constexpr impl::CombinationsFn combinations{};
}
template <typename Container>
class iter::impl::Combinator {
private:
Container container_;
std::size_t length_;
friend CombinationsFn;
Combinator(Container&& container, std::size_t length)
: container_(std::forward<Container>(container)), length_{length} {}
using IndexVector = std::vector<iterator_type<Container>>;
using CombIteratorDeref = IterIterWrapper<IndexVector>;
public:
Combinator(Combinator&&) = default;
class Iterator
: public std::iterator<std::input_iterator_tag, CombIteratorDeref> {
private:
constexpr static const int COMPLETE = -1;
std::remove_reference_t<Container>* container_p_;
CombIteratorDeref indices_;
int steps_{};
public:
Iterator(Container& container, std::size_t n)
: container_p_{&container}, indices_{n} {
if (n == 0) {
steps_ = COMPLETE;
return;
}
size_t inc = 0;
for (auto& iter : indices_.get()) {
auto it = get_begin(*container_p_);
dumb_advance(it, get_end(*container_p_), inc);
if (it != get_end(*container_p_)) {
iter = it;
++inc;
} else {
steps_ = COMPLETE;
break;
}
}
}
CombIteratorDeref& operator*() {
return indices_;
}
CombIteratorDeref* operator->() {
return &indices_;
}
Iterator& operator++() {
for (auto iter = indices_.get().rbegin(); iter != indices_.get().rend();
++iter) {
++(*iter);
// what we have to check here is if the distance between
// the index and the end of indices_ is >= the distance
// between the item and end of item
auto dist = std::distance(indices_.get().rbegin(), iter);
if (!(dumb_next(*iter, dist) != get_end(*container_p_))) {
if ((iter + 1) != indices_.get().rend()) {
size_t inc = 1;
for (auto down = iter; down != indices_.get().rbegin() - 1;
--down) {
(*down) = dumb_next(*(iter + 1), 1 + inc);
++inc;
}
} else {
steps_ = COMPLETE;
break;
}
} else {
break;
}
// we break because none of the rest of the items need
// to be incremented
}
if (steps_ != COMPLETE) {
++steps_;
}
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 steps_ == other.steps_;
}
};
Iterator begin() {
return {container_, length_};
}
Iterator end() {
return {container_, 0};
}
};
#endif