imodule 1.0.0
The contract every loadable module answers to
Loading...
Searching...
No Matches
Stride.hpp
Go to the documentation of this file.
1
10#ifndef STRIDE_HPP
11#define STRIDE_HPP
12
13#include <iterator>
14#include <string>
15#include <unordered_map>
16#include <vector>
17
31template <typename T>
32class Stride {
33
34 public:
42 class Span {
43 public:
44 class Iterator {
45 public:
46 using iterator_category = std::forward_iterator_tag;
47 using difference_type = std::ptrdiff_t;
48 using value_type = T;
49 using pointer = const T *;
50 using reference = const T &;
51
52 Iterator(const T *at, size_t step) : _at(at), _step(step) {}
53
54 const T &operator*() const { return *_at; }
55 Iterator &operator++() { _at += _step; return *this; }
56 bool operator==(const Iterator &o) const { return _at == o._at; }
57 bool operator!=(const Iterator &o) const { return _at != o._at; }
58
59 private:
60 const T *_at;
61 size_t _step;
62 };
63
64 Span() = default;
65 Span(const T *base, size_t step, size_t count)
66 : _base(base), _step(step), _count(count) {}
67
68 const T &operator[](size_t at) const { return _base[at * _step]; }
69
71 size_t size() const { return _count; }
72 bool empty() const { return _count == 0; }
73
74 Iterator begin() const { return Iterator(_base, _step); }
75 Iterator end() const { return Iterator(_base + _count * _step, _step); }
76
77 private:
78 const T *_base = nullptr;
79 size_t _step = 1;
80 size_t _count = 0;
81 };
82
84 T at(const std::string &row, const std::string &column) const {
85 const auto r = _rowOf.find(row);
86 const auto c = _columnOf.find(column);
87
88 if (r == _rowOf.end() || c == _columnOf.end())
89 return T{};
90 return _cells[c->second * _rows.size() + r->second];
91 }
92
94 Span row(const std::string &row) const {
95 const auto r = _rowOf.find(row);
96
97 if (r == _rowOf.end())
98 return Span();
99 return Span(_cells.data() + r->second, _rows.size(), _columnNames.size());
100 }
101
103 Span column(const std::string &column) const {
104 const auto c = _columnOf.find(column);
105
106 if (c == _columnOf.end())
107 return Span();
108 return columnAt(c->second);
109 }
110
112 Span all() const {
113 return Span(_cells.data(), 1, _cells.size());
114 }
115
117 bool hasColumn(const std::string &column) const {
118 return _columnOf.count(column) != 0;
119 }
120
127 bool addColumn(const std::string &column) {
128 if (_columnOf.count(column))
129 return false;
130
131 _columnOf.emplace(column, _columnNames.size());
132 _columnNames.push_back(column);
133 _cells.resize(_cells.size() + _rows.size(), T{});
134 return true;
135 }
136
145 bool set(const std::string &row, const std::string &column, T value) {
146 const auto c = _columnOf.find(column);
147
148 if (c == _columnOf.end())
149 return false;
150
151 /* La ligne avant l'indice de case : la creer decale la table. */
152 const size_t at = rowOf(row);
153
154 _cells[c->second * _rows.size() + at] = value;
155 return true;
156 }
157
164 template <typename Predicate>
166 size_t erased = 0;
167
168 for (size_t column = 0; column < _columnNames.size(); ) {
169 if (!should(_columnNames[column], columnAt(column))) {
170 column++;
171 continue;
172 }
173
174 const auto begin = _cells.begin() + column * _rows.size();
175
176 _cells.erase(begin, begin + _rows.size());
177 _columnNames.erase(_columnNames.begin() + column);
178 reindex();
179 erased++;
180 }
181 return erased;
182 }
183
185 const std::vector<std::string> &rows() const { return _rows; }
186
188 const std::vector<std::string> &columnNames() const { return _columnNames; }
189
190 private:
192 Span columnAt(size_t column) const {
193 return Span(_cells.data() + column * _rows.size(), 1, _rows.size());
194 }
195
202 size_t rowOf(const std::string &row) {
203 const auto found = _rowOf.find(row);
204
205 if (found != _rowOf.end())
206 return found->second;
207
208 const size_t oldRows = _rows.size();
209 const size_t newRows = oldRows + 1;
210 const size_t columns = _columnNames.size();
211
212 std::vector<T> grown(columns * newRows, T{});
213 for (size_t column = 0; column < columns; column++)
214 for (size_t r = 0; r < oldRows; r++)
215 grown[column * newRows + r] = _cells[column * oldRows + r];
216 _cells = std::move(grown);
217
218 _rowOf.emplace(row, oldRows);
219 _rows.push_back(row);
220 return oldRows;
221 }
222
224 void reindex() {
225 _columnOf.clear();
226 for (size_t at = 0; at < _columnNames.size(); at++)
227 _columnOf.emplace(_columnNames[at], at);
228 }
229
230 /* La table, colonne-majeure : _cells[colonne * _rows.size() + ligne]. */
231 std::vector<T> _cells;
232
233 std::vector<std::string> _rows;
234 std::vector<std::string> _columnNames;
235 std::unordered_map<std::string, size_t> _rowOf;
236 std::unordered_map<std::string, size_t> _columnOf;
237};
238
241#endif /* !STRIDE_HPP */
Definition Stride.hpp:44
std::forward_iterator_tag iterator_category
Definition Stride.hpp:46
const T & operator*() const
Definition Stride.hpp:54
Iterator(const T *at, size_t step)
Definition Stride.hpp:52
bool operator==(const Iterator &o) const
Definition Stride.hpp:56
bool operator!=(const Iterator &o) const
Definition Stride.hpp:57
const T & reference
Definition Stride.hpp:50
T value_type
Definition Stride.hpp:48
std::ptrdiff_t difference_type
Definition Stride.hpp:47
Iterator & operator++()
Definition Stride.hpp:55
const T * pointer
Definition Stride.hpp:49
Une ligne ou une colonne : un depart, un pas, une longueur.
Definition Stride.hpp:42
Iterator end() const
Definition Stride.hpp:75
bool empty() const
Definition Stride.hpp:72
Span()=default
Iterator begin() const
Definition Stride.hpp:74
size_t size() const
Le nombre de cases, vides comprises.
Definition Stride.hpp:71
const T & operator[](size_t at) const
Definition Stride.hpp:68
Span(const T *base, size_t step, size_t count)
Definition Stride.hpp:65
Une table ligne x colonne, nommee des deux cotes, rangee a plat.
Definition Stride.hpp:32
Span column(const std::string &column) const
La colonne : une case par ligne. Vide si la colonne est inconnue.
Definition Stride.hpp:103
T at(const std::string &row, const std::string &column) const
La case, T{} si l'une des deux chaines est inconnue.
Definition Stride.hpp:84
Span row(const std::string &row) const
La ligne : une case par colonne. Vide si la ligne est inconnue.
Definition Stride.hpp:94
bool hasColumn(const std::string &column) const
Cette colonne existe-t-elle deja ?
Definition Stride.hpp:117
const std::vector< std::string > & columnNames() const
Les colonnes, dans l'ordre d'ajout.
Definition Stride.hpp:188
size_t eraseColumnsIf(Predicate should)
Retire les colonnes que should accepte.
Definition Stride.hpp:165
bool addColumn(const std::string &column)
Ajoute une colonne vide.
Definition Stride.hpp:127
const std::vector< std::string > & rows() const
Les lignes, dans l'ordre de decouverte.
Definition Stride.hpp:185
Span all() const
Toute la table, colonne par colonne.
Definition Stride.hpp:112
bool set(const std::string &row, const std::string &column, T value)
Ecrit une case. La ligne est creee si elle est nouvelle.
Definition Stride.hpp:145