|
| Entity | add (Identity identity) |
| | A new row, owning identity. Every column grows (or a freed index is reused).
|
| void | remove (Entity e) |
| | Clears every column at this row and its identity. The index becomes reusable.
|
| std::optional< Identity > & | identity (Entity e) |
| | The Identity owning this row.
|
| template<typename T> |
| void | set (Entity e, T value) |
| | Writes the T value of this row.
|
| template<typename T> |
| std::optional< T > & | at (Entity e) |
| | The T value of this row, or nullopt.
|
| template<typename T> |
| std::vector< std::optional< T > > & | column () |
| | The WHOLE T column — a vector already there, nothing to rebuild.
|
| template<typename F> |
| void | row (Entity e, F &&f) |
| | Visits the WHOLE row, one column at a time. No copy.
|
| size_t | size () const |
| | The number of live rows.
|
| T | at (const std::string &row, const std::string &column) const |
| | La case, T{} si l'une des deux chaines est inconnue.
|
| Span | row (const std::string &row) const |
| | La ligne : une case par colonne. Vide si la ligne est inconnue.
|
| Span | column (const std::string &column) const |
| | La colonne : une case par ligne. Vide si la colonne est inconnue.
|
| Span | all () const |
| | Toute la table, colonne par colonne.
|
| bool | hasColumn (const std::string &column) const |
| | Cette colonne existe-t-elle deja ?
|
| bool | addColumn (const std::string &column) |
| | Ajoute une colonne vide.
|
| bool | set (const std::string &row, const std::string &column, T value) |
| | Ecrit une case. La ligne est creee si elle est nouvelle.
|
| template<typename Predicate> |
| size_t | eraseColumnsIf (Predicate should) |
| | Retire les colonnes que should accepte.
|
| const std::vector< std::string > & | rows () const |
| | Les lignes, dans l'ordre de decouverte.
|
| const std::vector< std::string > & | columnNames () const |
| | Les colonnes, dans l'ordre d'ajout.
|
template<typename Identity, typename... Columns>
class Stride< Identity, Columns >
A two-axis table : rows are a dense index (0,1,2... reused, like ecs Entity), columns are Columns... (fixed, known at compile time, one vector<optional<T>> per type — no hashing). Each row also carries an Identity, whatever the caller wants a row to own or be keyed by — a SharedLibrary, a string, anything. Stride does not know or care what Identity is.
Une table ligne x colonne, nommee des deux cotes, rangee a plat.
- Template Parameters
-
| Identity | |
| Columns | Stride<Identity, A, B, C, D> t;
auto e = t.add(Identity{...}); // a new row, owning this identity
t.set<B>(e, B{...}); // fill column B for this row
t.column<B>(); // the WHOLE B column — no copy, no rebuild
t.row(e, visitor); // the WHOLE row e — a fold over Columns..., no copy
t.identity(e); // the Identity of this row
|
The index is hidden behind Entity : private construction, Stride is the only friend. No way to fabricate an Entity by hand, and an Entity from Stride<X,A,B> is NOT the same type as one from Stride<Y,C,D> — passing it to the wrong Stride is a COMPILE error, not a runtime bug.
Une ligne ou une colonne se lit en place : un depart, un pas, une longueur. Rien n'est recopie dans un sens ni dans l'autre.
Les deux axes sont des chaines. Les numeros de ligne et de colonne restent internes.
Les cases vides valent T{} et sont rendues telles quelles - Stride ne filtre rien et ne sait pas ce que T{} signifie.