P-E-R-R-Y
Utilitaires, contrats et vendors du moteur, en une seule doc
Loading...
Searching...
No Matches
Stride< Identity, Columns > Class Template Reference

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. More...

#include <Stride.hpp>

Classes

class  Entity
 A row handle. Only Stride can create one. More...
class  Span
 Une ligne ou une colonne : un depart, un pas, une longueur. More...

Public Member Functions

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.

Detailed Description

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.

Member Function Documentation

◆ add()

template<typename Identity, typename... Columns>
Entity Stride< Identity, Columns >::add ( Identity identity)
inline

A new row, owning identity. Every column grows (or a freed index is reused).

Parameters
identity
Returns
Entity

◆ addColumn()

template<typename Identity, typename... Columns>
bool Stride< Identity, Columns >::addColumn ( const std::string & column)
inline

Ajoute une colonne vide.

Parameters
column
Returns
false si le nom est deja pris

◆ all()

template<typename Identity, typename... Columns>
Span Stride< Identity, Columns >::all ( ) const
inline

Toute la table, colonne par colonne.

◆ at() [1/2]

template<typename Identity, typename... Columns>
T Stride< Identity, Columns >::at ( const std::string & row,
const std::string & column ) const
inline

La case, T{} si l'une des deux chaines est inconnue.

◆ at() [2/2]

template<typename Identity, typename... Columns>
template<typename T>
std::optional< T > & Stride< Identity, Columns >::at ( Entity e)
inline

The T value of this row, or nullopt.

Template Parameters
T
Parameters
e
Returns
std::optional<T>&

◆ column() [1/2]

template<typename Identity, typename... Columns>
template<typename T>
std::vector< std::optional< T > > & Stride< Identity, Columns >::column ( )
inline

The WHOLE T column — a vector already there, nothing to rebuild.

Template Parameters
T
Returns
std::vector<std::optional<T>>&

◆ column() [2/2]

template<typename Identity, typename... Columns>
Span Stride< Identity, Columns >::column ( const std::string & column) const
inline

La colonne : une case par ligne. Vide si la colonne est inconnue.

◆ columnNames()

template<typename Identity, typename... Columns>
const std::vector< std::string > & Stride< Identity, Columns >::columnNames ( ) const
inline

Les colonnes, dans l'ordre d'ajout.

◆ eraseColumnsIf()

template<typename Identity, typename... Columns>
template<typename Predicate>
size_t Stride< Identity, Columns >::eraseColumnsIf ( Predicate should)
inline

Retire les colonnes que should accepte.

Parameters
shouldrecoit (nom, Span de la colonne)
Returns
combien ont ete retirees

◆ hasColumn()

template<typename Identity, typename... Columns>
bool Stride< Identity, Columns >::hasColumn ( const std::string & column) const
inline

Cette colonne existe-t-elle deja ?

◆ identity()

template<typename Identity, typename... Columns>
std::optional< Identity > & Stride< Identity, Columns >::identity ( Entity e)
inline

The Identity owning this row.

Parameters
e
Returns
std::optional<Identity>&

◆ remove()

template<typename Identity, typename... Columns>
void Stride< Identity, Columns >::remove ( Entity e)
inline

Clears every column at this row and its identity. The index becomes reusable.

Parameters
e

◆ row() [1/2]

template<typename Identity, typename... Columns>
Span Stride< Identity, Columns >::row ( const std::string & row) const
inline

La ligne : une case par colonne. Vide si la ligne est inconnue.

◆ row() [2/2]

template<typename Identity, typename... Columns>
template<typename F>
void Stride< Identity, Columns >::row ( Entity e,
F && f )
inline

Visits the WHOLE row, one column at a time. No copy.

Template Parameters
F
Parameters
e
f

◆ rows()

template<typename Identity, typename... Columns>
const std::vector< std::string > & Stride< Identity, Columns >::rows ( ) const
inline

Les lignes, dans l'ordre de decouverte.

◆ set() [1/2]

template<typename Identity, typename... Columns>
bool Stride< Identity, Columns >::set ( const std::string & row,
const std::string & column,
T value )
inline

Ecrit une case. La ligne est creee si elle est nouvelle.

Parameters
row
columndoit exister (addColumn())
value
Returns
false si la colonne est inconnue

◆ set() [2/2]

template<typename Identity, typename... Columns>
template<typename T>
void Stride< Identity, Columns >::set ( Entity e,
T value )
inline

Writes the T value of this row.

Template Parameters
T
Parameters
e
value

◆ size()

template<typename Identity, typename... Columns>
size_t Stride< Identity, Columns >::size ( ) const
inline

The number of live rows.


The documentation for this class was generated from the following files: