P-E-R-R-Y
Utilitaires, contrats et vendors du moteur, en une seule doc
Loading...
Searching...
No Matches
imodule
Collaboration diagram for imodule:

Classes

interface  IModule
 Ce que tout module chargeable sait dire de lui-meme. More...
class  IModuleManager
 La meme table que ModuleManager, mais dont les DEUX axes sont des chaines connues seulement au chargement. More...
class  SharedLibrary
 Encapsule le handle d'une bibliotheque dynamique. Rien de plus. More...
class  Stride< Identity, Columns >
 A two-axis table : rows are a dense index (0,1,2... reused, like ecs Entity), columns are Columns... (fixed, known at compile time, one vector<optional<T>> per type — no hashing). Each row also carries an Identity, whatever the caller wants a row to own or be keyed by — a SharedLibrary, a string, anything. Stride does not know or care what Identity is. More...

Functions

bool IModule::acquire ()
 Se declarer detenteur.
void IModule::release ()
 Rendre ce qu'on tenait. A appeler apres l'avoir detruit.

Detailed Description

imodule

🔌 P-E-R-R-Y imodule

The contract every loadable module answers to, and the table that holds them.

Build Docs C++20


✨ Overview

P-E-R-R-Y imodule is a header-only library for programs whose parts are discovered at runtime rather than linked at build time.

It holds two things:

  • IModule — what a module says about itself: its contract, its name, and the hardware it needs exclusively.
  • IModuleManager — a type × key table of every module currently loaded, filled by dlopen or by hand, and emptied without ever blocking.

Core goals:

  • 🔎 Anonymous loading — one exported symbol, getModules(), whatever the contract
  • 🧩 No central arbiter — every guest reads the table and picks for itself
  • ⛔ Real exclusivity only — claims() refuses two vendors on the same device, nothing else is forbidden
  • ⏳ Closing never waits — a condemned library closes once nobody holds it
  • ✅ Unit-tested with GoogleTest
  • 🚀 Header-only, one dependency (dl)

🧱 Features

  • One row per contract, one column per origin — read either way, in place
  • Load() for a shared library, add() for a module compiled into the host
  • acquire() / release() — refused up front when a claims() collides
  • Unload() condemns, Reconcile() closes what nobody holds anymore
  • Get<T>() / GetAllByType<T>() hand modules back with their real type

🧩 Example Usage

#include "IModuleManager.hpp"
/* ---- the vendor side : one library, any number of modules -------- */
class SfmlGraphic : public IModule {
public:
const char *type() const override { return "graphic2"; }
const char *name() const override { return "sfml"; }
/* Exclusive : no other OpenGL vendor can be held at the same time. */
const char *const *claims() const override {
static const char *claimed[] = {"opengl", nullptr};
return claimed;
}
};
extern "C" IModule **getModules() {
static SfmlGraphic graphic;
static IModule *list[] = {&graphic, nullptr};
return list;
}
/* ---- the host side ----------------------------------------------- */
int main() {
IModuleManager modules;
modules.Load("./sfml_impl.dylib", "sfml"); // a shared library
modules.add("built-in", std::make_unique<SfmlGraphic>()); // or compiled in
/* One cell : this contract, from that vendor. */
IModule *sfml = modules.Get("graphic2", "sfml");
/* One row : every vendor answering the contract. Empty cells come back
* as nullptr — that vendor simply does not provide it. */
for (IModule *module : modules.GetAllByType("graphic2")) {
if (!module || !module->acquire())
continue; // refused : something already claims "opengl"
//... use it, then hand it back
module->release();
break;
}
/* Retiring a library : condemn it, then close it once it is free. */
modules.Unload("sfml");
while (modules.Reconcile() == 0)
; // in a real program : once per tick, never a wait loop
return 0;
}
La meme table que ModuleManager, mais dont les DEUX axes sont des chaines connues seulement au charge...
Definition IModuleManager.hpp:58
void Unload(const std::string &key)
Condamne une colonne. NE FERME RIEN.
Definition IModuleManager.hpp:238
bool add(const std::string &key, std::vector< std::unique_ptr< IModule > > modules)
Ajoute une colonne sans bibliotheque. Le manager prend possession des modules.
Definition IModuleManager.hpp:118
size_t Reconcile()
Ferme ce qui est condamne et que plus personne ne tient.
Definition IModuleManager.hpp:260
bool Load(const std::string &path, const std::string &key)
Ouvre la dll, appelle getModules(), ajoute une colonne.
Definition IModuleManager.hpp:102
IModule * Get(const std::string &type, const std::string &key) override
La case : ce type, chez ce fournisseur. O(1).
Definition IModuleManager.hpp:156
std::vector< IModule * > GetAllByType(const std::string &type) override
La LIGNE : tous ceux qui declarent ce type.
Definition IModuleManager.hpp:176
Ce que tout module chargeable sait dire de lui-meme.
Definition IModule.hpp:24
virtual const char * name() const =0
Le fournisseur : "raylib", "sfml", "console"...
virtual const char *const * claims() const
Les ressources qu'il tient pour lui seul : "opengl"...
Definition IModule.hpp:43
virtual const char * type() const =0
Le contrat qu'il remplit : "graphic2", "audio", "game"...
IModule ** getModules()
Tout ce que cette dll fournit, sans avoir a nommer un contrat.
Definition raylib.cpp:90
Definition IGamepad.hpp:14

Function Documentation

◆ acquire()

bool IModule::acquire ( )
inline

Se declarer detenteur.

Returns
false si une de ses claims() est deja prise ailleurs ; rien n'est alors modifie

◆ release()

void IModule::release ( )
inline

Rendre ce qu'on tenait. A appeler apres l'avoir detruit.