1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
|
// ==============
// CoGITaNT 5
// ==============
/** \file cs/client.h
* Fonctionnalités de client (accès à un serveur).
* Déclaration de la classe cogitantcs::Client.
* \author David Genest.
*/
#ifndef CogitantCS_Client_h
#define CogitantCS_Client_h
#include "cogitant/common.h"
#include "cogitant/cs/base.h"
#include "cogitant/xmldocument.h"
#include "cogitant/support.h"
#include "cogitant/supportobject.h"
#include "cogitant/graph.h"
#include "cogitant/rule.h"
#include "cogitant/environment.h"
#include "cogitant/partialorder.h"
#include "cogitant/allocator.h"
#include "cogitant/propertyset.h"
namespace cogitantcs {
class EnvironmentAllocatorClient;
template <class SetContent> class SetClient;
/// Diverses vérifications sur les fonctionnalités de client.
#define CGA_CLIENT_MISC 1
/** \class Client cs/client.h "cogitant/cs/client.h"
* %Client.
* Un client est connecté à un serveur et permet d'interroger ce dernier pour fournir un accès aux environnements présents sur le serveur comme s'il s'agissait d'environnements locaux au client.
* Un client ouvre la connexion vers le serveur dès le constructeur (OperationCSIO::open()) et ferme la connexion dans le destructeur. Donc les méthodes open() et close() ne doivent être utilisées que dans le cas ou on désire explicitement couper la communication avec le serveur pour la réouvrir plus tard.
* \see \ref prog_cs.
*/
class CGTDLLEXPORT_CS Client: public Base
{
private:
/// Environnement géré par le client.
cogitant::Environment* m_environment;
/// Identificateur de l'environnement dans le serveur.
cogitant::iSet m_idenv;
/// Stockage des requêtes en attente.
cogitant::XmlDocument m_pendingqueries;
/// Stockage de la dernière réponse reçue du serveur.
cogitant::XmlDocument m_answer;
/// Informations sur le serveur.
cogitant::PropertySet m_serverinfo;
/// Stockage du dernier résultat de la requête de comparaison.
cogitant::PartialOrder::Comparison m_comparisonresult;
/// Les environnements créés dans ce client ont un support local.
bool m_localsupport;
/// Les environnements créés dans ce client ont des graphes locaux.
bool m_localobjects;
public:
/** @name Constructeurs - destructeur. */
//@{
/** Constructeur par défaut.
* \param opeio opérations d'entrées/sorties utilisées par le client pour communiquer avec le serveur.
* \param localsupport si \c true le support est local au client, et le serveur n'est jamais interrogé pour obtenir le support. Si \c false il ne faut pas charger un support dans l'environnement associé au client, car le support de l'environnement est celui du serveur.
* \param localobjects si \c true les objets de l'environnement sont locaux, et le serveur n'est jamais interrogé pour obtenir les objets. */
Client(OperationCSIO * opeio, bool localsupport, bool localobjects);
/** Destructeur.
* \warning La destruction du client ne provoque pas la destruction de l'environnement (de cette façon, il est possible de couper la connexion avec le server et de conserver l'environnement obtenu, dans ce cas, il est toutefois impossible d'obtenir de nouvelles informations du serveur). */
virtual ~Client();
//@}
protected:
/** Efface l'ensemble des requêtes en attente. */
void clearPendingQueries();
/** Retourne l'identificateur d'ensemble correspondant à l'ordre partiel passé. */
cogitant::iSet partialOrderToISet(cogitant::PartialOrder const * po);
/** Prise en compte de la réponse reçue du serveur.
* Le noeud \e node de la réponse \e m_answer est interprété et l'action correspondante est exécutée, à condition que ce noeud correponde à une opération standard. Il est donc possible de redéfir cette méthode dans les sous-classes pour gérer des réponses particulières ou effectuer des traitements spéciaux sur les réponses standard. */
virtual void execAnswer(cogitant::XmlDocument::Element const * node);
/** Prise en compte d'une réponse environment. */
virtual void execAnswerEnvironment(cogitant::XmlDocument::Element const * node);
/** Prise en compte d'une réponse setcontent. */
virtual void execAnswerSetContent(cogitant::XmlDocument::Element const * node);
/** Prise en compte d'une réponse graph. */
virtual void execAnswerGraph(cogitant::XmlDocument::Element const * node);
/** Prise en compte d'une réponse rule. */
virtual void execAnswerRule(cogitant::XmlDocument::Element const * node);
/** Prise en compte des réponses immediateless, immediategreater et comparison. */
virtual void execAnswerPartialOrder(cogitant::XmlDocument::Element const * node);
/** Prise en compte d'une réponse bannedtypes. */
virtual void execAnswerBannedTypes(cogitant::XmlDocument::Element const * node);
/** Envoi d'une requête au serveur. */
virtual void sendQuery(cogitant::XmlDocument const & query);
/** Lecture d'une réponse envoyée par le serveur. */
virtual void readAnswer(cogitant::XmlDocument & answer);
/** Ouverture de la communication avec le serveur. */
virtual void open();
/** Création d'un allocateur pour un environnement. */
virtual EnvironmentAllocatorClient * newEnvironmentAllocator();
public:
/** @name Modifications */
//@{
/** Choix de l'environnement parmi ceux offerts par le serveur.
* Cette méthode (ou l'autre de même nom) doit être obligatoirement appelée avant tout accès au serveur.
* \param ie identificateur de l'environnement offert par le serveur.
* \exception cogitantcs::ExceptionClient si aucun environnement de cet identificateur n'est offert par le serveur. */
void setServerEnvironment(cogitant::iSet ie);
/** Choix de l'environnement parmi ceux offerts par le serveur.
* Cette méthode (ou l'autre de même nom) doit être obligatoirement appelée avant tout accès au serveur.
* \param en nom de l'environnement offert par le serveur.
* \exception cogitantcs::ExceptionClient s'il n'existe aucun environnement de ce nom.
* \sa OpeServerEnvironment. */
void setServerEnvironment(std::string const & en);
/** Fermeture de la connexion avec le serveur.
* \warning Cette méthode doit être utilisée avec précaution car après appel à cette méthode, le lien avec le serveur est interrompu, ce qui signifie que si le client a besoin de faire un accès au serveur pour transférer un objet ou le résultat d'une opération, un exception sera levée car la connexion ne sera plus active. Cette méthode ne doit donc être utilisée que dans le cas où il est certain que plus aucune requête ne sera adressée au serveur. Dans ce cas, le serveur peut être libéré de la gestion de cette connextion (dans le cas d'un lien en mode connecté tel que Client_TCP). */
virtual void close();
/** Ajoute une requête à l'ensemble des requêtes en attente.
* \return le noeud (Element) ajouté à la requête en attente. */
cogitant::XmlDocument::Element * createPendingQuery(std::string const & name);
/** Ajoute une requête à l'ensemble des requêtes en attente.
* \param name nom de l'ordre.
* \param p1 nom du premier paramètre.
* \param v1 valeur du premier paramètre.
* \param p2 nom du deuxième paramètre.
* \param v2 valeur du second paramètre.
* \param p3 nom du troisième paramètre.
* \param v3 valeur du troisième paramètre. */
cogitant::XmlDocument::Element * createPendingQuery(std::string const & name, std::string const & p1, std::string const & v1, std::string const & p2="", std::string const & v2="", std::string const & p3="", std::string const & v3="");
/** Environnement géré. */
cogitant::Environment * environment();
//@}
/** @name Accesseurs */
//@{
/** Environnement géré. */
cogitant::Environment const * environment() const;
/** Réponse reçue du serveur. */
cogitant::XmlDocument const & answer() const;
/** Informations sur le serveur. */
cogitant::PropertySet const & serverProperties() const;
/** Identificateur de l'environnement côté serveur. */
cogitant::iSet serverEnvironmentISet() const;
/** Nombre d'environnements gérés par le serveur. */
cogitant::nSet serverEnvironments() const;
//@}
/** @name Requêtes.
* Les requêtes peuvent être effectuées en mode bloquant ou différé. Toutes les requêtes ont un paramètre \a imm (\e true par défaut) qui détermine le caractère "bloquant" de la requête. Si la valeur \e true est passée, l'appel à la méthode ne se termine pas tant que la réponse n'a pas été reçue par le serveur et l'action correspondante effectuée (création d'un type de concept, d'un graphe, etc.). Au contraire, si la valeur \e false est passée, la requête est mémorisée et n'est envoyée au serveur que quand la méthode executePendingQueries() est appelée, cette méthode attend aussi la réception de la réponse du serveur et execute les opérations correspondantes. Il est évidemment préférable d'utiliser cette deuxième méthode d'accès quand le serveur est disponible à travers un réseau et qu'un grand nombre de requêtes doivent être transmises. Par contre, pour les méthodes qui ont une valeur de retour, cette valeur de retour n'a de sens que dans le cas où la requête est exécutée immédiatement. <p>
* Ces méthodes peuvent lever l'exception cogitantcs::ExceptionClient dans le cas d'un problème de communication avec le serveur. A noter que les versions "non bloquantes" des requêtes ne peuvent provoquer une telle exception car la requête est simplement stockée.<p>
* La valeur de retour de la plupart de ces méthodes est l'identifiant du noeud ajouté à la requête en cours de construction. Évidemment, cette valeur n'a aucun intérêt si la requête est bloquante (imm = true). Dans ce cas, la requête est aussitot transmise au serveur et la réponse est attendue. Par contre, si la requête est mémorisée, la valeur de retour peut servir à rajouter des attributs à l'élément correspondant à la requête.<p>
* Une requête ne peut être exécutée sur le serveur que dans le cas où il connait une opération (cogitantcs::OpeServer) qui est capable de traiter cette requête. Selon la configuration du serveur, il est donc possible que certaines des requêtes ne soient pas utilisables. */
//@{
/** Requête d'interrogation d'un élément d'un ensemble (dans l'environnement courant).
* \param n type de requête (<tt>qconcepttype</tt>, etc.).
* \param i identificateur de l'élément devant être transféré ou ISET_NULL pour transférer tous les éléments.
* \param imm exécution immédiate.
* \return Elément XML codant la requête.
* \sa OpeServerSetContent. */
cogitant::XmlDocument::Element * getSetContent(std::string const & n, cogitant::iSet i, bool imm = true);
cogitant::XmlDocument::Element * getSupportObject(SetClient<cogitant::ConceptType*> const * s, cogitant::iSet i, bool imm = true);
cogitant::XmlDocument::Element * getSupportObject(SetClient<cogitant::RelationType*> const * s, cogitant::iSet i, bool imm = true);
cogitant::XmlDocument::Element * getSupportObject(SetClient<cogitant::NestingType*> const * s, cogitant::iSet i, bool imm = true);
cogitant::XmlDocument::Element * getSupportObject(SetClient<cogitant::Individual*> const * s, cogitant::iSet i, bool imm = true);
/** Interrogation de l'ensemble des éléments d'un ensemble du support.
* Demande le transfert vers le client du contenu complet d'un ensemble d'éléments du support. Cette méthode ne sert qu'à optimiser les échanges d'information : plutot que de demander un par un les objets du support, l'exécution de cette méthode les demande tous en une seule opération, ce qui est beaucoup plus rapide.
* \param s 0 : tous les ensembles, 1 : types de concepts, 2 : types de relations, 3 : types d'emboîtement, 4 : marqueurs individuels.
* \param imm exécution immédiate.
* \return Element XML codant la requête.
* \sa OpeServerSetContent, getEnvironmentObjects(). */
cogitant::XmlDocument::Element * getSupportObjects(int s=0, bool imm=true);
/** Transfert d'un objet de l'environnement du serveur vers le client.
* \param i identificateur de l'objet à transférer dans le serveur.
* \param dest identificateur de l'objet à la réception. La valeur ISET_NULL repère qu'à la réception, l'objet est stocké à la même position que dans le serveur.
* \param imm exécution immédiate.
* \return Element XML codant la requête.
* \sa OpeServerSetContent, getEnvironmentObjects(). */
cogitant::XmlDocument::Element * getEnvironmentObject(cogitant::iSet i, cogitant::iSet dest=cogitant::ISET_NULL, bool imm = true);
/** Interrogation de l'ensemble des objets de l'environnement.
* \param imm exécution immédiate.
* \return Element XML codant la requête.
* \sa OpeServerSetContent, getSupportObjects(). */
cogitant::XmlDocument::Element * getEnvironmentObjects(bool imm = true);
/** Requête d'interrogation des éléments immédiatement inférieurs.
* \param s ordre partiel interrogé.
* \param i identificateur de l'élément devant être interrogé ou ISET_NULL pour recevoir les éléments immédiatement plus petits de tous les éléments de l'ordre partiel.
* \param imm exécution immédiate.
* \return Element XML codant la requête.
* \sa OpeServerImmediateLG, getImmediateLess(). */
cogitant::XmlDocument::Element * getImmediateLess(cogitant::PartialOrder const * s, cogitant::iSet i, bool imm = true);
/** Requête d'interrogation des éléments immédiatement inférieurs.
* \see getImmediateLess(). */
cogitant::XmlDocument::Element * getImmediateGreater(cogitant::PartialOrder const * s, cogitant::iSet i, bool imm = true);
/** Requête d'interrogation de l'ordre existant entre deux éléments d'un ordre partie.
* \param s ordre partiel interrogé.
* \param i identificateur à comparer.
* \param j identificateur à comparer.
* \return résultat de la comparaison.
* \sa OpeServerComparison. */
cogitant::PartialOrder::Comparison getComparison(cogitant::PartialOrder const * s, cogitant::iSet i, cogitant::iSet j);
/** Requête d'interrogation des propriétés du serveur.
* Habituellement, il n'est pas nécessaire d'appeler explicitement cette méthode.
* \sa serverProperties(), serverEnvironments, OpeServerServer. */
void getServerInfo(bool imm=true);
/** Met à jour l'objet du serveur avec l'objet local.
* \param i identificateur local de l'objet.
* \param dest identificateur de l'objet pour le serveur (ISET_NULL pour transférer l'objet avec le même identificateur que dans le client).
* \param imm exécution immédiate.
* \sa OpeServerCommitEnvironmentObject. */
void commitEnvironmentObject(cogitant::iSet i, cogitant::iSet dest=cogitant::ISET_NULL, bool imm = true);
/** Création d'un nouvel environnement dans le serveur.
* \param optorderc Optimisation automatique de l'ordre sur les types de concepts (après un chargement à partir d'un fichier). Si true, l'ensemble des types de concepts (et l'ordre) ne peut être modifié après un chargement.
* \param optorderr Optimisation automatique de l'ordre sur les types de relations (après un chargement à partir d'un fichier). Si true, l'ensemble des types de relations (et l'ordre) ne peut être modifié après un chargement.
* \param optordern Optimisation automatique de l'ordre sur les types d'emboîtements (après un chargement à partir d'un fichier). Si true, l'ensemble des types d'emboîtements (et l'ordre) ne peut être modifié après un chargement.
* \param imm exécution immédiate.
* \return identificateur de l'environnement créé (dans le cas où \a imm = <tt>true</tt>).
* \sa OpeServerNewEnvironment. */
cogitant::iSet newEnvironment(bool optorderc=true, bool optorderr=true, bool optordern=true, bool imm=true);
/** Création d'un nouvel objet d'environnement dans le serveur.
* \param ot type d'objet à créer : graphe (par défaut) ou règle.
* \param imm exécution immédiate.
* \result identificateur de l'objet créé (dans le cas où \a imm = <tt>true</tt>).
* \warning Habituellement, l'appel à cette méthode devrait être suivi d'un appel à refreshEnvironment().
* \sa OpeServerNewEnvironmentObject. */
cogitant::iSet newEnvironmentObject(cogitant::EnvironmentObject::Type ot = cogitant::EnvironmentObject::OT_GRAPH, bool imm=true);
/** Destruction d'un objet de l'environnement.
* \param i Identificateur de l'objet à détruire.
* \param imm Exécution immédiate.
* \result \c true si l'objet a été correctement détruit et \c false si l'objet n'a pu être détruit. Attention, la méthode retourne \c false si \a imm vaut \c false. En effet, si l'exécution n'est pas immédiate, la requête de destruction est stockée dans le document contenant les requêtes en attentes, mais elle n'est pas expédiée immédiatement au serveur. Il est donc impossible de connaître à ce moment le résultat que retournera le serveur.
* \sa OpeServerDeleteEnvironmentObject. */
bool deleteEnvironmentObject(cogitant::iSet i, bool imm=true);
/** Création d'un nouveau type ou marqueur.
* \param ot type d'objet à créer ('c' type de concept, 'r' relation, 'n' emboîtement, 'i' marqueur individuel).
* \param imm exécution immédiate.
* \return identificateur du nouvel objet (dans le cas où \a imm = <tt>true</tt>).
* \warning Habituellement, l'appel à cette méthode devrait être suivi d'un appel à refreshEnvironment().
* \sa OpeServerNewSupportObject. */
cogitant::iSet newSupportObject(char ot, bool imm=true);
/** Mise à jour de l'objet du serveur avec l'objet local.
* \param ot type d'objet à mettre à jour ('c' type de concept, 'r' relation, 'n' emboîtement, 'i' marqueur individuel).
* \param i identificateur de l'objet à mettre à jour.
* \param imm exécution immédiate.
* \sa OpeServerCommitSupportObject. */
void commitSupportObject(char ot, cogitant::iSet i, bool imm=true);
/** Mise à jour d'un ordre partiel du serveur avec celui du client.
* \param ot ordre partiel à mettre à jour ('c' type de concept, 'r' relation, 'n' emboîtement).
* \param i1 identificateur d'un type dans l'ordre partiel.
* \param i2 identificateur d'un type dans l'ordre partiel. L'appel à cette méthode modifie l'information <code>i1 > i2</code>. L'ordre qui est envoyé au serveur dépend de la valeur locale de <code>i1 > i2</code>.
* \param imm exécution immédiate.
* \sa OpeServerCommitImmediateLess. */
void commitImmediateLess(char ot, cogitant::iSet i1, cogitant::iSet i2, bool imm=true);
/** Chargement d'un support dans le serveur.
* \param sn nom du fichier support. Ce fichier est chargé par le serveur, il doit donc être accessible sur le poste qui execute le serveur.
* \param env identificateur de l'environnement (serveur) qui doit charger le support. Si ISET_NULL est passé (par défaut), c'est l'environnement sélectionné par le client (par setServerEnvironment()) qui charge le support.
* \param imm exécution immédiate.
* \return <code>""</code> si le support a été correctement chargé ou l'intitulé de l'erreur si une erreur a été rencontrée par le serveur lors du chargement (dans le cas où \a imm = <tt>true</tt>).
* \warning Dans le cas où l'environnement sélectionné par le client charge le support, l'appel à cette méthode devrait être suivi d'un appel à refreshEnvironment().
* \sa OpeServerLoadSupport. */
std::string loadSupport(std::string const & sn, cogitant::iSet env=cogitant::ISET_NULL, bool imm=true);
/** Sauvegarde d'un support côté serveur.
* \param sn nom du fichier support.
* \param imm exécution immédiate ou pas.
* \return <code>""</code> si le support a été correctement sauvé ou l'intitulé de l'erreur.
* \sa OpeServerSaveSupport. */
std::string saveSupport(std::string const & sn, bool imm=true);
/** Chargement d'un support dans le serveur à partir du support du client.
* \result <code>""</code> si le support a été correctement chargé ou l'intitulé de l'erreur si une erreur a été rencontrée par le serveur lors de l'analyse du support envoyé par le client.
* \warning Si le support du client est issu du serveur, un grand nombre de requêtes peuvent être envoyées au serveur pour récupérer entièrement le support... afin de lui renvoyer. Il est donc raisonnable d'utiliser cette méthode dans le cas où le support est local au client, mais pas dans le cas où le support est issu du serveur. */
std::string commitSupport(bool imm=true);
/** Chargement de graphes dans le serveur.
* \warning Habituellement, l'appel à cette méthode devrait être suivi d'un appel à refreshEnvironment().
* \result identificateurs des graphes chargés.
* \sa OpeServerLoadGraphs. */
std::vector<cogitant::iSet> loadGraphs(std::string const & gn, bool imm=true);
/** Sauvegarde d'un graphe (ou d'un règle) côté serveur.
* \param gn nom du fichier (il s'agit du nom du fichier pour le serveur, si un nom relatif est donné, ce sera relativement au répertoire courant du serveur).
* \param i identificateur du graphe dans l'environnement courant du client.
* \param imm exécution immédiate ou pas.
* \result <code>""</code> si le graphe a été correctement sauvegardé, ou l'intitulé de l'erreur. (toujours "" si \a imm vaut faux).
* \sa OpeServerSaveEnvironmentObjects. */
std::string saveEnvironmentObject(std::string const & gn, cogitant::iSet i, bool imm=true);
/** Sauvegarde de graphes (ou règles) côté serveur.
* \param gn nom du fichier (il s'agit du nom du fichier pour le serveur, si un nom relatif est donné, ce sera relativement au répertoire courant du serveur).
* \param ids identificateur du graphe dans l'environnement courant du client.
* \param imm exécutoin immédiate ou pas.
* \result <code>""</code> si le graphe a été correctement sauvegardé, ou l'intitulé de l'erreur. (toujours "" si \a imm vaut faux).
* \sa OpeServerSaveEnvironmentObjects. */
std::string saveEnvironmentObjects(std::string const & gn, std::vector<cogitant::iSet> const & ids, bool imm=true);
/** Destruction d'un environnement.
* \warning Plus aucun autre accès à l'environnement ne doit être fait après appel à cette méthode.
* \result \c true si l'environnement a été correctement détruit et \c false si l'environnement n'a pu être détruit. Attention, la méthode retourne \c false si \a imm vaut \c false.
* \sa OpeServerDeleteEnvironment. */
bool deleteEnvironment(cogitant::iSet i=cogitant::ISET_NULL, bool imm=true);
/** Force un rafraichissement de l'environnement depuis le serveur.
* Cette méthode doit être appelée pour prendre en compte de nouveaux objets de l'environnement créés dans le serveur ainsi qu'une éventuelle mise à jour de la taille du support. Après appel à cette méthode, le nombre d'objets de l'environnement est à nouveau synchronisé avec le serveur. */
void refreshEnvironment(bool imm=true);
/** Force un rafraichissement depuis le serveur d'un élément de l'environnement.
* Le rafraichissement n'est pas effectué immédiatement, mais uniquement lors du premier accès à l'objet en question.
* \param i identificateur de l'objet de l'environnement à refraichir, ou ISET_NULL, si tous les objets doivent être rafraichis.
* \warning Si des modifications ont été effectuées sur l'objet local, et que ces modifications n'ont pas été répercutées sur le serveur, alors ces modifications sont perdues car l'objet local est supprimé. */
void refreshEnvironmentObject(cogitant::iSet i = cogitant::ISET_NULL);
//@}
/** Envoi des requêtes en attente au serveur et attente de la réponse. */
void executePendingQueries();
};
/** \class SupportAllocatorClient cs/client.h "cogitant/cs/client.h"
* Allocateur pour les membres de Support dans un client.
* Cette classe diffère de cogitant::SupportAllocator par le fait que les ensembles (de types de concepts, de types de relations, de types d'emboîtements, de marqueurs individuels) et les ordres partiels alloués sont les versions "client" des classes, afin de permettre la communication avec le serveur. */
class CGTDLLEXPORT_CS SupportAllocatorClient: public cogitant::SupportAllocator
{
private:
/** %Client auquel est rattaché l'allocateur. */
Client * m_client;
public:
/** Constructeur.
* \param client %Client auquel est rattaché l'allocator.
* Cette information doit être connue au moment de l'exécution des méthodes d'allocation afin de créer des \e Set reliés au serveur par l'intermédiaire de ce client.*/
SupportAllocatorClient(Client * client);
/** @name Allocation. */
//@{
cogitant::Set<cogitant::ConceptType*>* allocCTypes() const;
cogitant::Set<cogitant::RelationType*>* allocRTypes() const;
cogitant::Set<cogitant::NestingType*>* allocNTypes() const;
cogitant::Set<cogitant::Individual*>* allocIndividuals() const;
cogitant::PartialOrder* allocCOrder() const;
cogitant::PartialOrder* allocROrder() const;
cogitant::PartialOrder* allocNOrder() const;
//@}
/** @name Effacement. */
//@{
void clearCTypes(cogitant::Set<cogitant::ConceptType*> * s) const;
void clearRTypes(cogitant::Set<cogitant::RelationType*> * s) const;
void clearNTypes(cogitant::Set<cogitant::NestingType*> * s) const;
void clearIndividuals(cogitant::Set<cogitant::Individual*> * s) const;
//@}
};
/** \class EnvironmentAllocatorClient cs/client.h "cogitant/cs/client.h"
* Allocateur pour les membres de Environment dans un client.
* Cette classe diffère de cogitant::EnvironmentAllocator par le fait que le support créé est muni d'un allocateur de type SupportAllocatorClient. */
class CGTDLLEXPORT_CS EnvironmentAllocatorClient: public cogitant::EnvironmentAllocator
{
private:
/** %Client auquel est rattaché l'allocateur. */
Client * m_client;
/** %Support local.
* Si vrai, le support est créé localement, et son allocateur est celui par défaut. Sinon (par défaut), le support est distant est récupéré dynamiquement sur le serveur, et l'allocateur des supports créés est m_supportallocator. */
bool m_supportlocal;
/** Objets locaux.
* Si vrai, seul le support est récupéré sur le serveur : les objets sont locaux (faux par défaut). */
bool m_objectslocal;
public:
/** Constructeur.
* \param client %Client auquel est rattaché l'allocator.
* Cette information doit être connue au moment de l'exécution des méthodes d'allocation afin de créer un cogitant::Support muni d'un SupportAllocatorClient relié au bon client. */
EnvironmentAllocatorClient(Client * client);
/** Destructeur. */
~EnvironmentAllocatorClient();
protected:
/** Construction d'un nouveau allocateur de support pour un environnement créé par l'objet courant. */
virtual SupportAllocatorClient * newSupportAllocator() const;
public:
/** @name Allocation. */
//@{
cogitant::Support* allocSupport() const;
cogitant::Set<cogitant::EnvironmentObject*>* allocObjects() const;
//@}
/** @name Effacement. */
//@{
void clearObjects(cogitant::Set<cogitant::EnvironmentObject*>* s) const;
void replaceObject(cogitant::Set<cogitant::EnvironmentObject*>* s, cogitant::iSet i, cogitant::EnvironmentObject* o) const;
//@}
/** Stockage des objets.
* Si \c true les objets (graphes et règles) sont stockés sur le client, sinon (ou si cette méthode n'est pas appelée) les objets accessibles sont ceux du serveur.
* \warning Cette méthode doit être appelée avant l'allocation de l'ensemble d'objets. */
void localObjects(bool local=true);
/** Stockage du support.
* Si \c true le support est stocké sur le client, sinon (ou si cette méthode n'est pas appelée) le support est celui du serveur.
* \warning Cette méthode doit être appelée avant l'allocation du support. */
void localSupport(bool local=true);
};
}
#endif
Merci |
