imodule 1.0.0
The contract every loadable module answers to
Loading...
Searching...
No Matches
IModuleManager Class Reference

Une ligne par contrat, une colonne par origine. 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 ()
 
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 qu'une bibliotheque doit exporter.
 

Detailed Description

Une ligne par contrat, une colonne par origine.

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

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

◆ Get() [1/2]

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

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

◆ GetAll()

Span IModuleManager::GetAll ( )
inline

Toute la table, cases vides comprises.

◆ GetAllByKey()

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

◆ GetAllByType() [1/2]

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

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

◆ GetKeys()

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

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

◆ GetTypes()

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

Les contrats presents, dans l'ordre de decouverte.

◆ Load()

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

◆ Reconcile()

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

◆ release()

void IModuleManager::release ( IModule *  module)
inline

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

Parameters
module

◆ Unload()

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

Member Data Documentation

◆ entry

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

Le seul symbole qu'une bibliotheque doit exporter.

extern "C" IModule **getModules() {
static SfmlGraphicModule graphic;
static SfmlAudioModule audio;
static IModule *list[] = { &graphic, &audio, nullptr };
return list;
}
Ce que tout module chargeable sait dire de lui-meme.
Definition IModule.hpp:24

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 file: