|
P-E-R-R-Y
Utilitaires, contrats et vendors du moteur, en une seule doc
|
La meme table que ModuleManager, mais dont les DEUX axes sont des chaines connues seulement au chargement. More...
#include <IModuleManager.hpp>


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. | |
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.
| using IModuleManager::Span = typename Stride<IModule *>::Span |
Une ligne ou une colonne de la table. Contient les cases vides.
|
inlineoverride |
|
inline |
|
inline |
Declarer un detenteur de plus sur ce module.
| module |
|
inline |
Comme add(key, vector<...>), pour un seul module.
|
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.
| key | le nom de la colonne |
| modules | au moins un |
|
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, avec son vrai type.
Parcourt T::accepts : demander un IGraphic2Module trouve aussi un vendor qui ne declare que "graphic3".
| 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.
|
inline |
Une case : ce contrat, chez ce fournisseur.
| type | |
| key |
|
inlineoverride |
La case : ce type, chez ce fournisseur. O(1).
| type | |
| key |
|
inline |
Toute la table, cases vides comprises.
|
inlineoverride |
Toute la table, colonne par colonne.
|
inline |
La colonne : une case par contrat, pour ce fournisseur.
Les contrats qu'il ne remplit pas rendent nullptr.
| key |
|
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, avec leur vrai type.
Rend un vecteur, et non un Span : plusieurs lignes (T::accepts) sont agregees en une.
|
inline |
Tous ceux qui remplissent ce contrat, ou mieux.
|
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; }
| 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.
| type |
|
inline |
Les origines chargees, dans l'ordre d'arrivee.
|
inline |
Les colonnes, dans l'ordre de chargement.
|
inline |
Les contrats presents, dans l'ordre de decouverte.
|
inline |
Lignes, dans l'ordre de decouverte.
|
inline |
Ouvre une bibliotheque et ajoute les modules qu'elle exporte.
| path | |
| key | le nom de la colonne |
|
inline |
Ouvre la dll, appelle getModules(), ajoute une colonne.
| path | |
| key | le nom de la colonne |
|
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.
|
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.
|
inline |
Un detenteur de moins. Libere ses claims() au dernier.
| module |
|
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 : ses detenteurs doivent lacher.
Ne ferme rien. Tout ce que ces modules ont fabrique reste valide jusqu'a Reconcile().
| 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.
| key |
|
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.
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.
Un IModule ** termine par nullptr : deux pointeurs traversent un dlopen sans rien supposer de l'ABI d'en face.