modulemanager 1.0.0
Finds, loads and keeps track of modules at runtime
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 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.
 

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.

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.

Constructor & Destructor Documentation

◆ ~IModuleManager()

IModuleManager::~IModuleManager ( )
inlineoverride

Member Function Documentation

◆ 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/2]

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() [2/2]

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()

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

Toute la table, colonne par colonne.

Returns
std::vector<IModule *>

◆ GetAllByKey()

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/2]

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

Tous ceux qui remplissent ce contrat, ou mieux.

◆ GetAllByType() [2/2]

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()

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

Les colonnes, dans l'ordre de chargement.

◆ GetTypes()

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

Lignes, dans l'ordre de decouverte.

◆ Load()

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()

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

◆ 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()

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.

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 SfmlGraphicModule graphic;
static SfmlAudioModule audio;
static IModule *list[] = { &graphic, &audio, nullptr };
return list;
}

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.


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