P-E-R-R-Y
Utilitaires, contrats et vendors du moteur, en une seule doc
Loading...
Searching...
No Matches
IModuleManager.hpp
Go to the documentation of this file.
1
7
8#ifndef IMODULE_MANAGER_HPP
9#define IMODULE_MANAGER_HPP
10
11#include <map>
12#include <memory>
13#include <string>
14#include <unordered_map>
15#include <vector>
16
17#include "IModule.hpp"
18#include "IModuleRegistry.hpp"
19#include "SharedLibrary.hpp"
20
58class IModuleManager : public IModuleRegistry {
59
60 public:
84 static constexpr const char *entry = "getModules";
85
86 ~IModuleManager() override {
87 /* Les modules vivent dans les bibliotheques : on vide la table
88 * avant de les fermer, sinon on garderait des pointeurs vers du
89 * code demappe le temps de la destruction. */
90 _cells.clear();
91 _columns.clear();
92 }
93
102 bool Load(const std::string &path, const std::string &key) {
103 /* Une cle condamnee n'est pas reutilisable tant qu'elle n'a pas
104 * ferme : la ressusciter obligerait a distinguer "condamnee mais
105 * revenue" de "jamais condamnee", pour un cas qui n'arrive que si
106 * on recharge dans le meme souffle qu'on decharge. */
107 if (_columnOf.count(key))
108 return false;
109
110 auto library = std::make_unique<SharedLibrary>(path);
111 auto get = library->symbol<IModule **(*)()>(entry);
112
113 if (!get)
114 return false; // pas un fournisseur de modules
115
116 IModule **modules = get();
117
118 if (!modules || !*modules)
119 return false;
120
121 const size_t column = _cells.size();
122
123 _cells.emplace_back(_rows.size(), nullptr);
124 for (IModule **it = modules; *it; it++) {
125 /* rowOf() peut agrandir toutes les colonnes : on resout la
126 * ligne AVANT d'indexer, plutot que de dependre de l'ordre
127 * d'evaluation d'un operator[]. */
128 const size_t row = rowOf((*it)->type());
129
130 /* Le registre AVANT la mise en table : le module doit
131 * pouvoir chercher ses voisins des l'instant ou il devient
132 * atteignable, pas un appel plus tard. */
133 (*it)->bind(*this);
134
135 /* A neuf, meme si l'objet a deja vecu : sur macOS dlclose ne
136 * decharge souvent pas, donc ce module peut etre exactement
137 * celui qu'on a condamne tout a l'heure. */
138 (*it)->reset();
139 _cells[column][row] = *it;
140 }
141
142 _columnOf.emplace(key, column);
143 _columnNames.push_back(key);
144 _columns.push_back(std::move(library));
145 _condemned.push_back(false);
146 return true;
147 }
148
156 IModule *Get(const std::string &type, const std::string &key) override {
157 const auto row = _rowOf.find(type);
158 const auto column = _columnOf.find(key);
159
160 if (row == _rowOf.end() || column == _columnOf.end())
161 return nullptr;
162 return _cells[column->second][row->second];
163 }
164
176 std::vector<IModule *> GetAllByType(const std::string &type) override {
177 std::vector<IModule *> found;
178 const auto row = _rowOf.find(type);
179
180 if (row == _rowOf.end())
181 return found;
182 for (const std::vector<IModule *> &column : _cells)
183 if (IModule *module = column[row->second])
184 found.push_back(module);
185 return found;
186 }
187
198 std::vector<IModule *> GetAllByKey(const std::string &key) override {
199 std::vector<IModule *> found;
200 const auto column = _columnOf.find(key);
201
202 if (column == _columnOf.end())
203 return found;
204 for (IModule *module : _cells[column->second])
205 if (module)
206 found.push_back(module);
207 return found;
208 }
209
215 std::vector<IModule *> GetAll() override {
216 std::vector<IModule *> found;
217
218 for (const std::vector<IModule *> &column : _cells)
219 for (IModule *module : column)
220 if (module)
221 found.push_back(module);
222 return found;
223 }
224
238 void Unload(const std::string &key) {
239 const auto column = _columnOf.find(key);
240
241 if (column == _columnOf.end())
242 return;
243
244 _condemned[column->second] = true;
245 for (IModule *module : _cells[column->second])
246 if (module)
247 module->condemn();
248 }
249
260 size_t Reconcile() {
261 size_t closed = 0;
262
263 for (size_t column = 0; column < _cells.size(); ) {
264 if (!_condemned[column] || !isFree(column)) {
265 column++;
266 continue;
267 }
268
269 /* Les cellules d'abord, la bibliotheque ensuite : elles
270 * pointent dedans, et detruire l'unique_ptr appelle dlclose. */
271 /* Une selection qui pointe dans cette colonne devient
272 * caduque : elle designerait du code demappe. */
273 for (auto it = _current.begin(); it != _current.end(); )
274 it = contains(column, it->second) ? _current.erase(it) : std::next(it);
275
276 _cells.erase(_cells.begin() + column);
277 _columnNames.erase(_columnNames.begin() + column);
278 _condemned.erase(_condemned.begin() + column);
279 _columns.erase(_columns.begin() + column);
280
281 reindex();
282 closed++;
283 }
284 return closed;
285 }
286
288 IModule *Current(const std::string &type) override {
289 const auto found = _current.find(type);
290
291 return found == _current.end() ? nullptr : found->second;
292 }
293
295 void Select(const std::string &type, IModule *module) override {
296 if (module)
297 _current[type] = module;
298 else
299 _current.erase(type);
300 }
301
302 /* ---- les memes questions, posees avec un type ---------------- *
303 *
304 * C'est tout ce que ModuleManager<Ts...> apportait de plus, sans sa
305 * contrainte : lui devait connaitre ses colonnes a la compilation
306 * et faisait un dlsym par contrat. Ici la table reste decouverte au
307 * chargement, et le type ne sert qu'a nommer la ligne et a rendre
308 * le cast.
309 *
310 * static_cast et pas dynamic_cast : sous RTLD_LOCAL le typeinfo
311 * n'est pas partage entre la dll et l'hote, donc dynamic_cast
312 * repondrait faux. Le static_cast est sur parce que les deux cotes
313 * ont compile les memes en-tetes - la disposition des classes et
314 * l'ajustement vers la base sont resolus a la compilation. Ce a
315 * quoi il fait confiance, c'est la chaine rendue par type().
316 */
317
324 template <typename T>
325 T *Get(const std::string &key) {
326 for (const char *const *type = T::accepts; *type; type++)
327 if (IModule *module = Get(*type, key))
328 return static_cast<T *>(module);
329 return nullptr;
330 }
331
333 template <typename T>
334 std::vector<T *> GetAllByType() {
335 std::vector<T *> found;
336
337 for (const char *const *type = T::accepts; *type; type++)
338 for (IModule *module : GetAllByType(*type))
339 found.push_back(static_cast<T *>(module));
340 return found;
341 }
342
344 template <typename T>
345 T *Current() {
346 return static_cast<T *>(Current(T::contract));
347 }
348
350 template <typename T>
351 void Select(T *module) {
352 Select(T::contract, module);
353 }
354
356 const std::vector<std::string> &GetTypes() const { return _rows; }
357
359 const std::vector<std::string> &GetKeys() const { return _columnNames; }
360
361 private:
363 bool contains(size_t column, IModule *module) const {
364 for (IModule *cell : _cells[column])
365 if (cell && cell == module)
366 return true;
367 return false;
368 }
369
371 bool isFree(size_t column) const {
372 for (IModule *module : _cells[column])
373 if (module && !module->isClosed())
374 return false;
375 return true;
376 }
377
379 void reindex() {
380 _columnOf.clear();
381 for (size_t column = 0; column < _columnNames.size(); column++)
382 _columnOf.emplace(_columnNames[column], column);
383 }
384
392 size_t rowOf(const std::string &type) {
393 const auto found = _rowOf.find(type);
394
395 if (found != _rowOf.end())
396 return found->second;
397
398 const size_t row = _rows.size();
399
400 _rowOf.emplace(type, row);
401 _rows.push_back(type);
402 for (std::vector<IModule *> &column : _cells)
403 column.resize(row + 1, nullptr);
404 return row;
405 }
406
407 /* Rangement colonne par colonne, comme Stride : _cells[colonne][ligne].
408 * Une colonne est contigue, une ligne se parcourt a offset fixe. */
409 std::vector<std::vector<IModule *>> _cells;
410 std::vector<std::unique_ptr<SharedLibrary>> _columns;
411 std::vector<bool> _condemned;
412 std::map<std::string, IModule *> _current;
413
414 std::vector<std::string> _rows;
415 std::vector<std::string> _columnNames;
416 std::unordered_map<std::string, size_t> _rowOf;
417 std::unordered_map<std::string, size_t> _columnOf;
418};
419
421
422#endif /* !IMODULE_MANAGER_HPP */
Ce qu'un module dit de lui-meme, et l'etat de sa bibliotheque.
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
IModule * Current(const std::string &type) override
Le module en service pour ce contrat, ou nullptr.
Definition IModuleManager.hpp:288
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
const std::vector< std::string > & GetTypes() const
Lignes, dans l'ordre de decouverte.
Definition IModuleManager.hpp:356
std::vector< IModule * > GetAllByKey(const std::string &key) override
La COLONNE : tout ce que ce fournisseur apporte.
Definition IModuleManager.hpp:198
void Select(T *module)
L'hote declare son choix pour le contrat de T.
Definition IModuleManager.hpp:351
const std::vector< std::string > & GetKeys() const
Les colonnes, dans l'ordre de chargement.
Definition IModuleManager.hpp:359
std::vector< T * > GetAllByType()
Tous ceux qui remplissent ce contrat, ou mieux.
Definition IModuleManager.hpp:334
~IModuleManager() override
Definition IModuleManager.hpp:86
std::vector< IModule * > GetAll() override
Toute la table, colonne par colonne.
Definition IModuleManager.hpp:215
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
static constexpr const char * entry
Le seul symbole que la dll doit exporter.
Definition IModuleManager.hpp:84
T * Get(const std::string &key)
Ce contrat chez ce fournisseur, ou tout ce qui le satisfait.
Definition IModuleManager.hpp:325
void Select(const std::string &type, IModule *module) override
L'hote declare son choix. Un seul par type.
Definition IModuleManager.hpp:295
T * Current()
Le module en service pour ce contrat, vu comme un T.
Definition IModuleManager.hpp:345
Ce que tout module chargeable sait dire de lui-meme.
Definition IModule.hpp:24
bool isClosed() const
Plus aucun detenteur.
Definition IModule.hpp:77