P-E-R-R-Y
Utilitaires, contrats et vendors du moteur, en une seule doc
Loading...
Searching...
No Matches
IModuleManager Class Reference

La meme table que ModuleManager, mais dont les DEUX axes sont des chaines connues seulement au chargement. More...

#include <IModuleManager.hpp>

Inheritance diagram for IModuleManager:
Collaboration diagram for IModuleManager:

Public Types

using Span = typename Stride<IModule *>::Span
 Une ligne ou une colonne de la table. Contient les cases vides.

Public Member Functions

 ~IModuleManager () override
bool Load (const std::string &path, const std::string &key)
 Ouvre la dll, appelle getModules(), ajoute une colonne.
IModule * Get (const std::string &type, const std::string &key) override
 La case : ce type, chez ce fournisseur. O(1).
std::vector< IModule * > GetAllByType (const std::string &type) override
 La LIGNE : tous ceux qui declarent ce type.
std::vector< IModule * > GetAllByKey (const std::string &key) override
 La COLONNE : tout ce que ce fournisseur apporte.
std::vector< IModule * > GetAll () override
 Toute la table, colonne par colonne.
void Unload (const std::string &key)
 Condamne une colonne. NE FERME RIEN.
size_t Reconcile ()
 Ferme ce qui est condamne et que plus personne ne tient.
IModule * Current (const std::string &type) override
 Le module en service pour ce contrat, ou nullptr.
void Select (const std::string &type, IModule *module) override
 L'hote declare son choix. Un seul par type.
template<typename T>
T * Get (const std::string &key)
 Ce contrat chez ce fournisseur, ou tout ce qui le satisfait.
template<typename T>
std::vector< T * > GetAllByType ()
 Tous ceux qui remplissent ce contrat, ou mieux.
template<typename T>
T * Current ()
 Le module en service pour ce contrat, vu comme un T.
template<typename T>
void Select (T *module)
 L'hote declare son choix pour le contrat de T.
const std::vector< std::string > & GetTypes () const
 Lignes, dans l'ordre de decouverte.
const std::vector< std::string > & GetKeys () const
 Les colonnes, dans l'ordre de chargement.
 ~IModuleManager ()
bool Load (const std::string &path, const std::string &key)
 Ouvre une bibliotheque et ajoute les modules qu'elle exporte.
bool add (const std::string &key, std::vector< std::unique_ptr< IModule > > modules)
 Ajoute une colonne sans bibliotheque. Le manager prend possession des modules.
bool add (const std::string &key, std::unique_ptr< IModule > module)
 Comme add(key, vector<...>), pour un seul module.
IModule * Get (const std::string &type, const std::string &key)
 Une case : ce contrat, chez ce fournisseur.
Span GetAllByType (const std::string &type)
 La ligne : une case par fournisseur, pour ce contrat.
Span GetAllByKey (const std::string &key)
 La colonne : une case par contrat, pour ce fournisseur.
Span GetAll ()
 Toute la table, cases vides comprises.
bool acquire (IModule *module)
 Declarer un detenteur de plus sur ce module.
void release (IModule *module)
 Un detenteur de moins. Libere ses claims() au dernier.
void Unload (const std::string &key)
 Condamne une colonne : ses detenteurs doivent lacher.
size_t Reconcile ()
 Ferme les colonnes condamnees que plus personne ne tient.
template<typename T>
T * Get (const std::string &key)
 Ce contrat chez ce fournisseur, avec son vrai type.
template<typename T>
std::vector< T * > GetAllByType ()
 Tous ceux qui remplissent ce contrat, avec leur vrai type.
const std::vector< std::string > & GetTypes () const
 Les contrats presents, dans l'ordre de decouverte.
const std::vector< std::string > & GetKeys () const
 Les origines chargees, dans l'ordre d'arrivee.

Static Public Attributes

static constexpr const char * entry = "getModules"
 Le seul symbole que la dll doit exporter.

Detailed Description

La meme table que ModuleManager, mais dont les DEUX axes sont des chaines connues seulement au chargement.

Une ligne par contrat, une colonne par origine.

ModuleManager<Ts...> est plus agreable : ses colonnes sont des types, donc Get<IGraphic2Module>() est verifie par le compilateur. Son prix est qu'il ne charge que ce qu'on a su nommer. Une dll qui fournit un contrat que l'hote ignore reste muette - aucun Discover<T> ne lui correspond, donc rien n'est construit.

Ici, la ligne vient de IModule::type() et la colonne est la cle de chargement :

           | raylib             | sfml              | asio
-----------|--------------------|-------------------|-------------------
 graphic   | RayGraphicModule   | SfmlGraphicModule |
 audio     | RayAudioModule     | SfmlAudioModule   |
 network   |                    |                   | AsioNetworkModule

MEME DISCIPLINE DE RANGEMENT QUE STRIDE, et donc le meme nom : le stockage est colonne par colonne, chacune contigue et indexee par le numero de ligne. Une case est deux resolutions de chaine puis un calcul d'indice.

Get(type, cle)   O(1)
GetAllByKey(cle) la colonne entiere, deja contigue - rien a rebatir
GetAllByType(type)  la ligne : un pas de colonne en colonne, a offset fixe

Ce n'est PAS un Stride<Identity, Columns...> : celui-la range un std::vector par TYPE de colonne, via std::get sur un tuple, resolu a la compilation. Des colonnes decouvertes au runtime ne peuvent pas s'y ranger - seule la disposition memoire est reprise.

Une table de hachage imbriquee donnerait la meme reponse, mais parcourir une ligne obligerait a visiter la table de chaque colonne. Ici c'est un pas d'indice.

           | raylib             | sfml              | asio
-----------|--------------------|-------------------|-------------------
 graphic   | RayGraphicModule   | SfmlGraphicModule |
 audio     | RayAudioModule     | SfmlAudioModule   |
 network   |                    |                   | AsioNetworkModule

Une colonne vient d'une bibliotheque (Load()) ou de l'hote lui-meme (add()). Elle se lit par contrat, par origine, ou case par case.

Aucun choix n'est impose : chaque invite lit la table et tente d'acquerir ce qu'il veut. La seule chose qui puisse le refuser est une ressource materielle deja prise (IModule::claims()).

C'est ce que bind() pose sur chaque module : de la ou il est, un module peut trouver ses voisins, jamais fermer une bibliotheque.

Member Typedef Documentation

◆ Span

using IModuleManager::Span = typename Stride<IModule *>::Span

Une ligne ou une colonne de la table. Contient les cases vides.

Constructor & Destructor Documentation

◆ ~IModuleManager() [1/2]

IModuleManager::~IModuleManager ( )
inlineoverride

◆ ~IModuleManager() [2/2]

IModuleManager::~IModuleManager ( )
inline

Member Function Documentation

◆ acquire()

bool IModuleManager::acquire ( IModule * module)
inline

Declarer un detenteur de plus sur ce module.

Parameters
module
Returns
false si une de ses claims() est deja prise

◆ add() [1/2]

bool IModuleManager::add ( const std::string & key,
std::unique_ptr< IModule > module )
inline

Comme add(key, vector<...>), pour un seul module.

◆ add() [2/2]

bool IModuleManager::add ( const std::string & key,
std::vector< std::unique_ptr< IModule > > modules )
inline

Ajoute une colonne sans bibliotheque. Le manager prend possession des modules.

Pour un module compile dans l'hote. L'appelant lache son unique_ptr : il ne peut plus le detruire lui-meme.

Parameters
keyle nom de la colonne
modulesau moins un
Returns
false si la cle est prise ou si modules est vide

◆ Current() [1/2]

template<typename T>
T * IModuleManager::Current ( )
inline

Le module en service pour ce contrat, vu comme un T.

◆ Current() [2/2]

IModule * IModuleManager::Current ( const std::string & type)
inlineoverride

Le module en service pour ce contrat, ou nullptr.

◆ Get() [1/4]

template<typename T>
T * IModuleManager::Get ( const std::string & key)
inline

Ce contrat chez ce fournisseur, avec son vrai type.

Parcourt T::accepts : demander un IGraphic2Module trouve aussi un vendor qui ne declare que "graphic3".

Parameters
key
Returns
T* nullptr si absent

◆ Get() [2/4]

template<typename T>
T * IModuleManager::Get ( const std::string & key)
inline

Ce contrat chez ce fournisseur, ou tout ce qui le satisfait.

Parcourt T::accepts : demander un IGraphic2Module trouve aussi un vendor qui ne declare que "graphic3", puisqu'il en est un.

◆ Get() [3/4]

IModule * IModuleManager::Get ( const std::string & type,
const std::string & key )
inline

Une case : ce contrat, chez ce fournisseur.

Parameters
type
key
Returns
IModule* nullptr si ce fournisseur ne remplit pas ce contrat

◆ Get() [4/4]

IModule * IModuleManager::Get ( const std::string & type,
const std::string & key )
inlineoverride

La case : ce type, chez ce fournisseur. O(1).

Parameters
type
key
Returns
IModule* nullptr si la case est vide

◆ GetAll() [1/2]

Span IModuleManager::GetAll ( )
inline

Toute la table, cases vides comprises.

◆ GetAll() [2/2]

std::vector< IModule * > IModuleManager::GetAll ( )
inlineoverride

Toute la table, colonne par colonne.

Returns
std::vector<IModule *>

◆ GetAllByKey() [1/2]

Span IModuleManager::GetAllByKey ( const std::string & key)
inline

La colonne : une case par contrat, pour ce fournisseur.

Les contrats qu'il ne remplit pas rendent nullptr.

Parameters
key
Returns
Span

◆ GetAllByKey() [2/2]

std::vector< IModule * > IModuleManager::GetAllByKey ( const std::string & key)
inlineoverride

La COLONNE : tout ce que ce fournisseur apporte.

GetAllByKey("raylib")  ->  RayGraphicModule, RayAudioModule

Deja contigue en memoire, rien a rebatir.

Parameters
key
Returns
std::vector<IModule *>

◆ GetAllByType() [1/4]

template<typename T>
std::vector< T * > IModuleManager::GetAllByType ( )
inline

Tous ceux qui remplissent ce contrat, avec leur vrai type.

Rend un vecteur, et non un Span : plusieurs lignes (T::accepts) sont agregees en une.

Returns
std::vector<T *>

◆ GetAllByType() [2/4]

template<typename T>
std::vector< T * > IModuleManager::GetAllByType ( )
inline

Tous ceux qui remplissent ce contrat, ou mieux.

◆ GetAllByType() [3/4]

Span IModuleManager::GetAllByType ( const std::string & type)
inline

La ligne : une case par fournisseur, pour ce contrat.

Les fournisseurs qui ne le remplissent pas rendent nullptr.

for (IModule *m : modules.GetAllByType("graphic2"))
    if (m && m->acquire()) { ...; break; }
Parameters
type
Returns
Span

◆ GetAllByType() [4/4]

std::vector< IModule * > IModuleManager::GetAllByType ( const std::string & type)
inlineoverride

La LIGNE : tous ceux qui declarent ce type.

GetAllByType("audio")  ->  RayAudioModule, SfmlAudioModule

Un pas de colonne en colonne, a offset fixe. C'est la lecture qui donne son nom au motif.

Parameters
type
Returns
std::vector<IModule *>

◆ GetKeys() [1/2]

const std::vector< std::string > & IModuleManager::GetKeys ( ) const
inline

Les origines chargees, dans l'ordre d'arrivee.

◆ GetKeys() [2/2]

const std::vector< std::string > & IModuleManager::GetKeys ( ) const
inline

Les colonnes, dans l'ordre de chargement.

◆ GetTypes() [1/2]

const std::vector< std::string > & IModuleManager::GetTypes ( ) const
inline

Les contrats presents, dans l'ordre de decouverte.

◆ GetTypes() [2/2]

const std::vector< std::string > & IModuleManager::GetTypes ( ) const
inline

Lignes, dans l'ordre de decouverte.

◆ Load() [1/2]

bool IModuleManager::Load ( const std::string & path,
const std::string & key )
inline

Ouvre une bibliotheque et ajoute les modules qu'elle exporte.

Parameters
path
keyle nom de la colonne
Returns
false si la cle est prise, si getModules() manque, ou si la bibliotheque ne fournit rien

◆ Load() [2/2]

bool IModuleManager::Load ( const std::string & path,
const std::string & key )
inline

Ouvre la dll, appelle getModules(), ajoute une colonne.

Parameters
path
keyle nom de la colonne
Returns
false si la cle est prise, si getModules() manque, ou si la dll ne fournit rien

◆ Reconcile() [1/2]

size_t IModuleManager::Reconcile ( )
inline

Ferme les colonnes condamnees que plus personne ne tient.

A appeler a chaque tick. Une colonne encore tenue est laissee telle quelle : on repassera.

Returns
combien ont ete fermees

◆ Reconcile() [2/2]

size_t IModuleManager::Reconcile ( )
inline

Ferme ce qui est condamne et que plus personne ne tient.

A appeler a chaque tick. Une colonne dont un seul module a encore un detenteur est laissee telle quelle : on repassera au tick suivant. C'est toute l'attente du mecanisme - il n'y a ni blocage ni thread, seulement une fermeture qui n'a pas lieu ce tour-ci.

Returns
le nombre de dll effectivement fermees

◆ release()

void IModuleManager::release ( IModule * module)
inline

Un detenteur de moins. Libere ses claims() au dernier.

Parameters
module

◆ Select() [1/2]

void IModuleManager::Select ( const std::string & type,
IModule * module )
inlineoverride

L'hote declare son choix. Un seul par type.

◆ Select() [2/2]

template<typename T>
void IModuleManager::Select ( T * module)
inline

L'hote declare son choix pour le contrat de T.

◆ Unload() [1/2]

void IModuleManager::Unload ( const std::string & key)
inline

Condamne une colonne : ses detenteurs doivent lacher.

Ne ferme rien. Tout ce que ces modules ont fabrique reste valide jusqu'a Reconcile().

Parameters
key

◆ Unload() [2/2]

void IModuleManager::Unload ( const std::string & key)
inline

Condamne une colonne. NE FERME RIEN.

Chaque module de la dll passe a mustClose(). Ses detenteurs le verront a leur prochain tick, detruiront ce qu'ils tiennent et appelleront release(). La fermeture, elle, revient a Reconcile().

Entre les deux, la dll reste ouverte et tout ce qu'elle a fabrique reste valide - c'est precisement ce qui laisse le temps de lacher proprement.

Parameters
key

Member Data Documentation

◆ entry

constexpr const char * IModuleManager::entry = "getModules"
staticconstexpr

Le seul symbole que la dll doit exporter.

Le seul symbole qu'une bibliotheque doit exporter.

Un nom unique, le meme partout, connu sans connaitre le contrat - c'est ce qui rend le chargement anonyme possible. Avec un symbole par contrat, il faudrait deja savoir quoi chercher.

extern "C" IModule **getModules() {
static IModule *list[] = { &graphic, &audio, nullptr };
return list;
}
Ce que tout module chargeable sait dire de lui-meme.
Definition IModule.hpp:24
sfml has no explicit audio device init/close step (unlike raylib), nothing to do at construction/dest...
Definition SfmlAudioModule.hpp:26
Sfml only implements IGraphic2Module - no IGraphic3Module, sfml has no native 3D. No fake IModel here...
Definition SfmlGraphicModule.hpp:34
IModule ** getModules()
Tout ce que cette dll fournit, sans avoir a nommer un contrat.
Definition raylib.cpp:90
Definition IMusic.hpp:17
Definition IGamepad.hpp:14

Un IModule ** termine par nullptr, et pas un std::vector : un vecteur ne traverse pas un dlopen sans supposer que la dll et l'hote partagent exactement la meme ABI de bibliotheque standard et le meme allocateur. Deux pointeurs ne supposent rien.

Le tableau appartient a la dll et vit aussi longtemps qu'elle.

extern "C" IModule **getModules() {
static IModule *list[] = { &graphic, &audio, nullptr };
return list;
}

Un IModule ** termine par nullptr : deux pointeurs traversent un dlopen sans rien supposer de l'ABI d'en face.


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