|
modulemanager 1.0.0
Finds, loads and keeps track of modules at runtime
|
La meme table que ModuleManager, mais dont les DEUX axes sont des chaines connues seulement au chargement. More...
#include <IModuleManager.hpp>


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. | |
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.
|
inlineoverride |
|
inline |
Le module en service pour ce contrat, vu comme un T.
|
inlineoverride |
Le module en service pour ce contrat, ou nullptr.
|
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.
|
inlineoverride |
La case : ce type, chez ce fournisseur. O(1).
| type | |
| key |
|
inlineoverride |
Toute la table, colonne par colonne.
|
inlineoverride |
La COLONNE : tout ce que ce fournisseur apporte.
GetAllByKey("raylib") -> RayGraphicModule, RayAudioModule
Deja contigue en memoire, rien a rebatir.
| key |
|
inline |
Tous ceux qui remplissent ce contrat, ou mieux.
|
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.
| type |
|
inline |
Les colonnes, dans l'ordre de chargement.
|
inline |
Lignes, dans l'ordre de decouverte.
|
inline |
Ouvre la dll, appelle getModules(), ajoute une colonne.
| path | |
| key | le nom de la colonne |
|
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.
|
inlineoverride |
L'hote declare son choix. Un seul par type.
|
inline |
L'hote declare son choix pour le contrat de T.
|
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.
| key |
|
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.
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.