?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Resolve "Toggle Free Look with Hotkey"
[ryzomcore.git] / ryzom / server / src / admin_modules / admin_modules_itf.h
blob8c25790e7a2a9dd3eb655edb8a14f766c5b10228
1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
2 // Copyright (C) 2010 Winch Gate Property Limited
3 //
4 // This program is free software: you can redistribute it and/or modify
5 // it under the terms of the GNU Affero General Public License as
6 // published by the Free Software Foundation, either version 3 of the
7 // License, or (at your option) any later version.
8 //
9 // This program is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 // GNU Affero General Public License for more details.
13 //
14 // You should have received a copy of the GNU Affero General Public License
15 // along with this program. If not, see <http://www.gnu.org/licenses/>.
16
17 /////////////////////////////////////////////////////////////////
18 // WARNING : this is a generated file, don't change it !
19 /////////////////////////////////////////////////////////////////
20
21 #ifndef ADMIN_MODULES_ITF
22 #define ADMIN_MODULES_ITF
23 #include "nel/misc/types_nl.h"
24 #include <memory>
25 #include "nel/misc/hierarchical_timer.h"
26 #include "nel/misc/string_conversion.h"
27 #include "nel/net/message.h"
28 #include "nel/net/module.h"
29 #include "nel/net/module_builder_parts.h"
30 #include "nel/net/module_message.h"
31 #include "nel/net/module_gateway.h"
32
33 #include "game_share/callback_adaptor.h"
34
35 #include "nel/misc/time_nl.h"
36
37 namespace ADMIN
38 {
39
40 class TGraphData;
41
42 class TGraphDatas;
43
44 class THighRezData;
45
46 class THighRezDatas;
47
48 class TServiceStatus;
49
50 // This is the interface used by PHP to call methods
51 // on the Admin service module
52
53 class CAdminServiceWebItf
54 {
55 protected:
56
57 /// the callback server adaptor
58 CUniquePtr<ICallbackServerAdaptor> _CallbackServer;
59
60 void getCallbakArray(NLNET::TCallbackItem *&arrayPtr, uint32 &arraySize)
61 {
62 static NLNET::TCallbackItem callbackArray[] =
63 {
64 { "GCMD", CAdminServiceWebItf::cb_globalCmd },
65 { "CCMD", CAdminServiceWebItf::cb_controlCmd },
66 { "SCMD", CAdminServiceWebItf::cb_serviceCmd },
67 { "GSO", CAdminServiceWebItf::cb_getShardOrders },
68 { "GS", CAdminServiceWebItf::cb_getStates },
69 { "GHRGI", CAdminServiceWebItf::cb_getHighRezGraphInfo },
70 { "GHRG", CAdminServiceWebItf::cb_getHighRezGraph },
71
72 };
73
74 arrayPtr = callbackArray;
75 arraySize = sizeofarray(callbackArray);
76 }
77
78 static void _cbConnection(NLNET::TSockId from, void *arg)
79 {
80 H_AUTO(CAdminServiceWeb__cbConnection);
81 CAdminServiceWebItf *_this = reinterpret_cast<CAdminServiceWebItf *>(arg);
82
83 _this->on_CAdminServiceWeb_Connection(from);
84 }
85
86 static void _cbDisconnection(NLNET::TSockId from, void *arg)
87 {
88 H_AUTO(CAdminServiceWeb__cbDisconnection);
89 CAdminServiceWebItf *_this = reinterpret_cast<CAdminServiceWebItf *>(arg);
90
91 _this->on_CAdminServiceWeb_Disconnection(from);
92 }
93
94
95 public:
96 /** Constructor, if you specify a replacement adaptor, then the object
97 * become owner of the adaptor (and it will be released with the
98 * interface).
99 */
100 CAdminServiceWebItf(ICallbackServerAdaptor *replacementAdaptor = NULL)
101 {
102 if (replacementAdaptor == NULL)
103 {
104 // use default callback server
105 _CallbackServer = CUniquePtr<ICallbackServerAdaptor>(new CNelCallbackServerAdaptor(this));
106 }
107 else
108 {
109 // use the replacement one
110 _CallbackServer = CUniquePtr<ICallbackServerAdaptor>(replacementAdaptor);
111 }
112 }
113
114 virtual ~CAdminServiceWebItf()
115 {
116 }
117
118 /// Open the interface socket in the specified port
119 void openItf(uint16 port)
120 {
121 NLNET::TCallbackItem *arrayPtr;
122 uint32 arraySize;
123
124
125
126 getCallbakArray(arrayPtr, arraySize);
127 _CallbackServer->addCallbackArray(arrayPtr, arraySize);
128
129 _CallbackServer->setConnectionCallback (_cbConnection, this);
130 _CallbackServer->setDisconnectionCallback (_cbDisconnection, this);
131
132 _CallbackServer->init(port);
133 }
134
135 /** Must be called evenly, update the network subclass to receive message
136 * and dispatch method invokation.
137 */
138 void update()
139 {
140 H_AUTO(CAdminServiceWeb_update);
141
142 try
143 {
144 _CallbackServer->update();
145 }
146 catch (...)
147 {
148 nlwarning("CAdminServiceWeb : Exception launch in callback server update");
149 }
150 }
151
152
153 void commandResult(NLNET::TSockId dest, const std::string &serviceAlias, const std::string &result)
154 {
155 H_AUTO(commandResult_commandResult);
156 #ifdef NL_DEBUG
157 nldebug("CAdminServiceWeb::commandResult called");
158 #endif
159 NLNET::CMessage message("CMDR");
160 nlWrite(message, serial, const_cast < std::string& > (serviceAlias));
161 nlWrite(message, serial, const_cast < std::string& > (result));
162
163 _CallbackServer->send(message, dest);
164 }
165
166 static void cb_globalCmd (NLNET::CMessage &message, NLNET::TSockId from, NLNET::CCallbackNetBase &netbase)
167 {
168 H_AUTO(globalCmd_on_globalCmd);
169 #ifdef NL_DEBUG
170 nldebug("CAdminServiceWeb::cb_globalCmd received from class '%s'", typeid(netbase).name());
171 #endif
172 ICallbackServerAdaptor *adaptor = static_cast< ICallbackServerAdaptor *>(netbase.getUserData());
173
174 CAdminServiceWebItf *callback = (CAdminServiceWebItf *)adaptor->getContainerClass();
175
176 if (callback == NULL)
177 return;
178 std::string command;
179 nlRead(message, serial, command);
180
181
182 #ifdef NL_DEBUG
183 nldebug("CAdminServiceWeb::cb_globalCmd : calling on_globalCmd");
184 #endif
185
186
187 callback->on_globalCmd(from, command);
188
189 }
190
191 static void cb_controlCmd (NLNET::CMessage &message, NLNET::TSockId from, NLNET::CCallbackNetBase &netbase)
192 {
193 H_AUTO(controlCmd_on_controlCmd);
194 #ifdef NL_DEBUG
195 nldebug("CAdminServiceWeb::cb_controlCmd received from class '%s'", typeid(netbase).name());
196 #endif
197 ICallbackServerAdaptor *adaptor = static_cast< ICallbackServerAdaptor *>(netbase.getUserData());
198
199 CAdminServiceWebItf *callback = (CAdminServiceWebItf *)adaptor->getContainerClass();
200
201 if (callback == NULL)
202 return;
203 std::string serviceAlias;
204 std::string command;
205 nlRead(message, serial, serviceAlias);
206 nlRead(message, serial, command);
207
208
209 #ifdef NL_DEBUG
210 nldebug("CAdminServiceWeb::cb_controlCmd : calling on_controlCmd");
211 #endif
212
213
214 callback->on_controlCmd(from, serviceAlias, command);
215
216 }
217
218 static void cb_serviceCmd (NLNET::CMessage &message, NLNET::TSockId from, NLNET::CCallbackNetBase &netbase)
219 {
220 H_AUTO(serviceCmd_on_serviceCmd);
221 #ifdef NL_DEBUG
222 nldebug("CAdminServiceWeb::cb_serviceCmd received from class '%s'", typeid(netbase).name());
223 #endif
224 ICallbackServerAdaptor *adaptor = static_cast< ICallbackServerAdaptor *>(netbase.getUserData());
225
226 CAdminServiceWebItf *callback = (CAdminServiceWebItf *)adaptor->getContainerClass();
227
228 if (callback == NULL)
229 return;
230 std::string serviceAlias;
231 std::string command;
232 nlRead(message, serial, serviceAlias);
233 nlRead(message, serial, command);
234
235
236 #ifdef NL_DEBUG
237 nldebug("CAdminServiceWeb::cb_serviceCmd : calling on_serviceCmd");
238 #endif
239
240
241 callback->on_serviceCmd(from, serviceAlias, command);
242
243 }
244
245 static void cb_getShardOrders (NLNET::CMessage &message, NLNET::TSockId from, NLNET::CCallbackNetBase &netbase)
246 {
247 H_AUTO(getShardOrders_on_getShardOrders);
248 #ifdef NL_DEBUG
249 nldebug("CAdminServiceWeb::cb_getShardOrders received from class '%s'", typeid(netbase).name());
250 #endif
251 ICallbackServerAdaptor *adaptor = static_cast< ICallbackServerAdaptor *>(netbase.getUserData());
252
253 CAdminServiceWebItf *callback = (CAdminServiceWebItf *)adaptor->getContainerClass();
254
255 if (callback == NULL)
256 return;
257
258
259 #ifdef NL_DEBUG
260 nldebug("CAdminServiceWeb::cb_getShardOrders : calling on_getShardOrders");
261 #endif
262
263 std::vector<std::string> retValue;
264
265 retValue = callback->on_getShardOrders(from);
266
267 NLNET::CMessage retMsg("R_GSO");
268
269 nlWrite(retMsg, serialCont, retValue);
270
271
272 callback->_CallbackServer->send(retMsg, from);
273
274 }
275
276 static void cb_getStates (NLNET::CMessage &message, NLNET::TSockId from, NLNET::CCallbackNetBase &netbase)
277 {
278 H_AUTO(getStates_on_getStates);
279 #ifdef NL_DEBUG
280 nldebug("CAdminServiceWeb::cb_getStates received from class '%s'", typeid(netbase).name());
281 #endif
282 ICallbackServerAdaptor *adaptor = static_cast< ICallbackServerAdaptor *>(netbase.getUserData());
283
284 CAdminServiceWebItf *callback = (CAdminServiceWebItf *)adaptor->getContainerClass();
285
286 if (callback == NULL)
287 return;
288
289
290 #ifdef NL_DEBUG
291 nldebug("CAdminServiceWeb::cb_getStates : calling on_getStates");
292 #endif
293
294 std::vector<std::string> retValue;
295
296 retValue = callback->on_getStates(from);
297
298 NLNET::CMessage retMsg("R_GS");
299
300 nlWrite(retMsg, serialCont, retValue);
301
302
303 callback->_CallbackServer->send(retMsg, from);
304
305 }
306
307 static void cb_getHighRezGraphInfo (NLNET::CMessage &message, NLNET::TSockId from, NLNET::CCallbackNetBase &netbase)
308 {
309 H_AUTO(getHighRezGraphInfo_on_getHighRezGraphInfo);
310 #ifdef NL_DEBUG
311 nldebug("CAdminServiceWeb::cb_getHighRezGraphInfo received from class '%s'", typeid(netbase).name());
312 #endif
313 ICallbackServerAdaptor *adaptor = static_cast< ICallbackServerAdaptor *>(netbase.getUserData());
314
315 CAdminServiceWebItf *callback = (CAdminServiceWebItf *)adaptor->getContainerClass();
316
317 if (callback == NULL)
318 return;
319 std::string varAddr;
320 nlRead(message, serial, varAddr);
321
322
323 #ifdef NL_DEBUG
324 nldebug("CAdminServiceWeb::cb_getHighRezGraphInfo : calling on_getHighRezGraphInfo");
325 #endif
326
327 std::vector<std::string> retValue;
328
329 retValue = callback->on_getHighRezGraphInfo(from, varAddr);
330
331 NLNET::CMessage retMsg("R_GHRGI");
332
333 nlWrite(retMsg, serialCont, retValue);
334
335
336 callback->_CallbackServer->send(retMsg, from);
337
338 }
339
340 static void cb_getHighRezGraph (NLNET::CMessage &message, NLNET::TSockId from, NLNET::CCallbackNetBase &netbase)
341 {
342 H_AUTO(getHighRezGraph_on_getHighRezGraph);
343 #ifdef NL_DEBUG
344 nldebug("CAdminServiceWeb::cb_getHighRezGraph received from class '%s'", typeid(netbase).name());
345 #endif
346 ICallbackServerAdaptor *adaptor = static_cast< ICallbackServerAdaptor *>(netbase.getUserData());
347
348 CAdminServiceWebItf *callback = (CAdminServiceWebItf *)adaptor->getContainerClass();
349
350 if (callback == NULL)
351 return;
352 std::string varAddr;
353 uint32 startDate;
354 uint32 endDate;
355 uint32 milliStep;
356 nlRead(message, serial, varAddr);
357 nlRead(message, serial, startDate);
358 nlRead(message, serial, endDate);
359 nlRead(message, serial, milliStep);
360
361
362 #ifdef NL_DEBUG
363 nldebug("CAdminServiceWeb::cb_getHighRezGraph : calling on_getHighRezGraph");
364 #endif
365
366 std::vector<std::string> retValue;
367
368 retValue = callback->on_getHighRezGraph(from, varAddr, startDate, endDate, milliStep);
369
370 NLNET::CMessage retMsg("R_GHRG");
371
372 nlWrite(retMsg, serialCont, retValue);
373
374
375 callback->_CallbackServer->send(retMsg, from);
376
377 }
378
379
380 /// Connection callback : a new interface client connect
381 virtual void on_CAdminServiceWeb_Connection(NLNET::TSockId from) =0;
382 /// Disconnection callback : one of the interface client disconnect
383 virtual void on_CAdminServiceWeb_Disconnection(NLNET::TSockId from) =0;
384
385
386 // Send a command to the AS.
387 // This is used to issue global commands like 'as.allStart' or 'as.allStop'.
388 // The result is returned by the return message
389 // serviceCmdResult.
390 virtual void on_globalCmd(NLNET::TSockId from, const std::string &command) =0;
391
392 // Send a service related command to the executor
393 // (not to the controled service)
394 // The result is returned by the return message
395 // controlCmdResult.
396 virtual void on_controlCmd(NLNET::TSockId from, const std::string &serviceAlias, const std::string &command) =0;
397
398 // Send a command to a service.
399 // The result is returned by the return message
400 // serviceCmdResult.
401 virtual void on_serviceCmd(NLNET::TSockId from, const std::string &serviceAlias, const std::string &command) =0;
402
403 // Get the orders of each known shard.
404 // The return value is a vector of string, one entry by shard
405 virtual std::vector<std::string> on_getShardOrders(NLNET::TSockId from) =0;
406
407 // Get the last known state of all services.
408 // The return value is a vector of string, one entry by service
409 virtual std::vector<std::string> on_getStates(NLNET::TSockId from) =0;
410
411 // Get information about a high rez graph.
412 // The return is a string array containing
413 // the name of the var, the available sample
414 // period as two unix date (start dans end)
415 // and the number of samples available
416 // If the var is not found, an empty array is returned
417 virtual std::vector<std::string> on_getHighRezGraphInfo(NLNET::TSockId from, const std::string &varAddr) =0;
418
419 // Get the data for a high resolution graph.
420 // The return is a string array, each
421 // string containing 'time:milliOffset:value
422 // Set endDate to 0 to specify a start date relative
423 // to the last sample date. In this case, start date
424 // is interpreted as the number of second before
425 // the last sample.
426 virtual std::vector<std::string> on_getHighRezGraph(NLNET::TSockId from, const std::string &varAddr, uint32 startDate, uint32 endDate, uint32 milliStep) =0;
427
428 };
429
430 // This is the interface used by PHP to call methods
431 // on the Admin service module
432
433 /** This is the client side of the interface
434 * Derive from this class to invoke method on the callback server
435 */
436
437 class CAdminServiceWebClientItf
438 {
439 protected:
440
441 /// the callback client adaptor
442 CUniquePtr < ICallbackClientAdaptor > _CallbackClient;
443
444
445 void getCallbakArray(NLNET::TCallbackItem *&arrayPtr, uint32 &arraySize)
446 {
447
448 static NLNET::TCallbackItem callbackArray[] =
449 {
450 { "CMDR", CAdminServiceWebClientItf::cb_commandResult },
451
452 };
453
454 arrayPtr = callbackArray;
455 arraySize = sizeofarray(callbackArray);
456
457 }
458
459 static void _cbDisconnection(NLNET::TSockId from, void *arg)
460 {
461 CAdminServiceWebClientItf *_this = reinterpret_cast<CAdminServiceWebClientItf *>(arg);
462
463 _this->on_CAdminServiceWebClient_Disconnection(from);
464 }
465
466
467 public:
468 /// Retreive the message name for a given callback name
469 static const std::string &getMessageName(const std::string &methodName)
470 {
471 static std::map<std::string, std::string> messageNames;
472 static bool initialized = false;
473 if (!initialized)
474 {
475 messageNames.insert(std::make_pair(std::string("on_commandResult"), std::string("CMDR")));
476
477 initialized = true;
478 }
479
480 std::map < std::string, std::string>::const_iterator it(messageNames.find(methodName));
481 if (it != messageNames.end())
482 return it->second;
483
484
485 static std::string emptyString;
486
487 return emptyString;
488
489 }
490
491 CAdminServiceWebClientItf(ICallbackClientAdaptor *adaptorReplacement = NULL)
492 {
493 if (adaptorReplacement == NULL)
494 {
495 // use the default Nel adaptor
496 _CallbackClient = CUniquePtr < ICallbackClientAdaptor >(new CNelCallbackClientAdaptor(this));
497 }
498 else
499 {
500 // use the replacement one
501 _CallbackClient = CUniquePtr < ICallbackClientAdaptor >(adaptorReplacement);
502 }
503 }
504
505 /// Connect the interface client to the callback server at the specified address and port
506 virtual void connectItf(NLNET::CInetAddress address)
507 {
508 NLNET::TCallbackItem *arrayPtr;
509 uint32 arraySize;
510
511 static bool callbackAdded = false;
512 if (!callbackAdded)
513 {
514
515 getCallbakArray(arrayPtr, arraySize);
516 _CallbackClient->addCallbackArray(arrayPtr, arraySize);
517 }
518
519 _CallbackClient->setDisconnectionCallback (_cbDisconnection, this);
520
521 _CallbackClient->connect(address);
522 }
523
524 /** Must be called evenly, update the network subclass to receive message
525 * and dispatch invokation returns.
526 */
527 virtual void update()
528 {
529 H_AUTO(CAdminServiceWeb_update);
530
531 try
532 {
533 _CallbackClient->update();
534 }
535 catch (...)
536 {
537 nlwarning("CAdminServiceWeb : Exception launch in callback client update");
538 }
539 }
540
541 // Send a command to the AS.
542 // This is used to issue global commands like 'as.allStart' or 'as.allStop'.
543 // The result is returned by the return message
544 // serviceCmdResult.
545
546 void globalCmd(const std::string &command)
547 {
548 #ifdef NL_DEBUG
549 nldebug("CAdminServiceWebClient::globalCmd called");
550 #endif
551 NLNET::CMessage message("GCMD");
552 nlWrite(message, serial, const_cast < std::string& > (command));
553
554 _CallbackClient->send(message);
555 }
556 // Send a service related command to the executor
557 // (not to the controled service)
558 // The result is returned by the return message
559 // controlCmdResult.
560
561 void controlCmd(const std::string &serviceAlias, const std::string &command)
562 {
563 #ifdef NL_DEBUG
564 nldebug("CAdminServiceWebClient::controlCmd called");
565 #endif
566 NLNET::CMessage message("CCMD");
567 nlWrite(message, serial, const_cast < std::string& > (serviceAlias));
568 nlWrite(message, serial, const_cast < std::string& > (command));
569
570 _CallbackClient->send(message);
571 }
572 // Send a command to a service.
573 // The result is returned by the return message
574 // serviceCmdResult.
575
576 void serviceCmd(const std::string &serviceAlias, const std::string &command)
577 {
578 #ifdef NL_DEBUG
579 nldebug("CAdminServiceWebClient::serviceCmd called");
580 #endif
581 NLNET::CMessage message("SCMD");
582 nlWrite(message, serial, const_cast < std::string& > (serviceAlias));
583 nlWrite(message, serial, const_cast < std::string& > (command));
584
585 _CallbackClient->send(message);
586 }
587 // Get the orders of each known shard.
588 // The return value is a vector of string, one entry by shard
589
590 void getShardOrders()
591 {
592 #ifdef NL_DEBUG
593 nldebug("CAdminServiceWebClient::getShardOrders called");
594 #endif
595 NLNET::CMessage message("GSO");
596
597 _CallbackClient->send(message);
598 }
599 // Get the last known state of all services.
600 // The return value is a vector of string, one entry by service
601
602 void getStates()
603 {
604 #ifdef NL_DEBUG
605 nldebug("CAdminServiceWebClient::getStates called");
606 #endif
607 NLNET::CMessage message("GS");
608
609 _CallbackClient->send(message);
610 }
611 // Get information about a high rez graph.
612 // The return is a string array containing
613 // the name of the var, the available sample
614 // period as two unix date (start dans end)
615 // and the number of samples available
616 // If the var is not found, an empty array is returned
617
618 void getHighRezGraphInfo(const std::string &varAddr)
619 {
620 #ifdef NL_DEBUG
621 nldebug("CAdminServiceWebClient::getHighRezGraphInfo called");
622 #endif
623 NLNET::CMessage message("GHRGI");
624 nlWrite(message, serial, const_cast < std::string& > (varAddr));
625
626 _CallbackClient->send(message);
627 }
628 // Get the data for a high resolution graph.
629 // The return is a string array, each
630 // string containing 'time:milliOffset:value
631 // Set endDate to 0 to specify a start date relative
632 // to the last sample date. In this case, start date
633 // is interpreted as the number of second before
634 // the last sample.
635
636 void getHighRezGraph(const std::string &varAddr, uint32 startDate, uint32 endDate, uint32 milliStep)
637 {
638 #ifdef NL_DEBUG
639 nldebug("CAdminServiceWebClient::getHighRezGraph called");
640 #endif
641 NLNET::CMessage message("GHRG");
642 nlWrite(message, serial, const_cast < std::string& > (varAddr));
643 nlWrite(message, serial, startDate);
644 nlWrite(message, serial, endDate);
645 nlWrite(message, serial, milliStep);
646
647 _CallbackClient->send(message);
648 }
649
650 static void cb_commandResult (NLNET::CMessage &message, NLNET::TSockId from, NLNET::CCallbackNetBase &netbase)
651 {
652 #ifdef NL_DEBUG
653 nldebug("CAdminServiceWebClient::cb_commandResult received from class '%s'", typeid(netbase).name());
654 #endif
655 ICallbackClientAdaptor *adaptor = static_cast< ICallbackClientAdaptor *>(netbase.getUserData());
656
657 CAdminServiceWebClientItf *callback = (CAdminServiceWebClientItf *)adaptor->getContainerClass();
658
659 if (callback == NULL)
660 return;
661 std::string serviceAlias;
662 std::string result;
663 nlRead(message, serial, serviceAlias);
664 nlRead(message, serial, result);
665
666
667 #ifdef NL_DEBUG
668 nldebug("CAdminServiceWebClient::cb_commandResult : calling on_commandResult");
669 #endif
670
671 callback->on_commandResult(from, serviceAlias, result);
672 }
673
674
675 /// Disconnection callback : the connection to the server is lost
676 virtual void on_CAdminServiceWebClient_Disconnection(NLNET::TSockId from) =0;
677
678
679 virtual void on_commandResult(NLNET::TSockId from, const std::string &serviceAlias, const std::string &result) =0;
680
681 };
682 /////////////////////////////////////////////////////////////////
683 // WARNING : this is a generated file, don't change it !
684 /////////////////////////////////////////////////////////////////
685 class TGraphData
686 {
687 protected:
688 //
689 std::string _ServiceAlias;
690 //
691 std::string _VarName;
692 //
693 uint32 _SamplePeriod;
694 //
695 double _Value;
696 public:
697 //
698 const std::string &getServiceAlias() const
699 {
700 return _ServiceAlias;
701 }
702
703 std::string &getServiceAlias()
704 {
705 return _ServiceAlias;
706 }
707
708
709 void setServiceAlias(const std::string &value)
710 {
711
712
713 _ServiceAlias = value;
714
715
716 }
717 //
718 const std::string &getVarName() const
719 {
720 return _VarName;
721 }
722
723 std::string &getVarName()
724 {
725 return _VarName;
726 }
727
728
729 void setVarName(const std::string &value)
730 {
731
732
733 _VarName = value;
734
735
736 }
737 //
738 uint32 getSamplePeriod() const
739 {
740 return _SamplePeriod;
741 }
742
743 void setSamplePeriod(uint32 value)
744 {
745
746 _SamplePeriod = value;
747
748 }
749 //
750 double getValue() const
751 {
752 return _Value;
753 }
754
755 void setValue(double value)
756 {
757
758 _Value = value;
759
760 }
761
762 bool operator == (const TGraphData &other) const
763 {
764 return _ServiceAlias == other._ServiceAlias
765 && _VarName == other._VarName
766 && _SamplePeriod == other._SamplePeriod
767 && _Value == other._Value;
768 }
769
770
771 // constructor
772 TGraphData()
773 {
774
775 }
776
777 void serial(NLMISC::IStream &s)
778 {
779 s.serial(_ServiceAlias);
780 s.serial(_VarName);
781 s.serial(_SamplePeriod);
782 s.serial(_Value);
783
784 }
785
786
787 private:
788
789
790 };
791
792
793 /////////////////////////////////////////////////////////////////
794 // WARNING : this is a generated file, don't change it !
795 /////////////////////////////////////////////////////////////////
796 class TGraphDatas
797 {
798 protected:
799 //
800 uint32 _CurrentTime;
801 //
802 std::vector < TGraphData > _Datas;
803 public:
804 //
805 uint32 getCurrentTime() const
806 {
807 return _CurrentTime;
808 }
809
810 void setCurrentTime(uint32 value)
811 {
812
813 _CurrentTime = value;
814
815 }
816 //
817 const std::vector < TGraphData > &getDatas() const
818 {
819 return _Datas;
820 }
821
822 std::vector < TGraphData > &getDatas()
823 {
824 return _Datas;
825 }
826
827
828 void setDatas(const std::vector < TGraphData > &value)
829 {
830
831
832 _Datas = value;
833
834
835 }
836
837 bool operator == (const TGraphDatas &other) const
838 {
839 return _CurrentTime == other._CurrentTime
840 && _Datas == other._Datas;
841 }
842
843
844 // constructor
845 TGraphDatas()
846 {
847
848 }
849
850 void serial(NLMISC::IStream &s)
851 {
852 s.serial(_CurrentTime);
853 s.serialCont(_Datas);
854
855 }
856
857
858 private:
859
860
861 };
862
863
864 /////////////////////////////////////////////////////////////////
865 // WARNING : this is a generated file, don't change it !
866 /////////////////////////////////////////////////////////////////
867 class THighRezData
868 {
869 protected:
870 //
871 NLMISC::TTime _SampleTick;
872 //
873 double _Value;
874 public:
875 //
876 NLMISC::TTime getSampleTick() const
877 {
878 return _SampleTick;
879 }
880
881 void setSampleTick(NLMISC::TTime value)
882 {
883
884 _SampleTick = value;
885
886 }
887 //
888 double getValue() const
889 {
890 return _Value;
891 }
892
893 void setValue(double value)
894 {
895
896 _Value = value;
897
898 }
899
900 bool operator == (const THighRezData &other) const
901 {
902 return _SampleTick == other._SampleTick
903 && _Value == other._Value;
904 }
905
906
907 // constructor
908 THighRezData()
909 {
910
911 }
912
913 void serial(NLMISC::IStream &s)
914 {
915 s.serial(_SampleTick);
916 s.serial(_Value);
917
918 }
919
920
921 private:
922
923
924 };
925
926
927 /////////////////////////////////////////////////////////////////
928 // WARNING : this is a generated file, don't change it !
929 /////////////////////////////////////////////////////////////////
930 class THighRezDatas
931 {
932 protected:
933 //
934 std::string _ServiceAlias;
935 //
936 std::string _VarName;
937 //
938 uint32 _CurrentTime;
939 //
940 std::vector < THighRezData > _Datas;
941 public:
942 //
943 const std::string &getServiceAlias() const
944 {
945 return _ServiceAlias;
946 }
947
948 std::string &getServiceAlias()
949 {
950 return _ServiceAlias;
951 }
952
953
954 void setServiceAlias(const std::string &value)
955 {
956
957
958 _ServiceAlias = value;
959
960
961 }
962 //
963 const std::string &getVarName() const
964 {
965 return _VarName;
966 }
967
968 std::string &getVarName()
969 {
970 return _VarName;
971 }
972
973
974 void setVarName(const std::string &value)
975 {
976
977
978 _VarName = value;
979
980
981 }
982 //
983 uint32 getCurrentTime() const
984 {
985 return _CurrentTime;
986 }
987
988 void setCurrentTime(uint32 value)
989 {
990
991 _CurrentTime = value;
992
993 }
994 //
995 const std::vector < THighRezData > &getDatas() const
996 {
997 return _Datas;
998 }
999
1000 std::vector < THighRezData > &getDatas()
1001 {
1002 return _Datas;
1003 }
1004
1005
1006 void setDatas(const std::vector < THighRezData > &value)
1007 {
1008
1009
1010 _Datas = value;
1011
1012
1013 }
1014
1015 bool operator == (const THighRezDatas &other) const
1016 {
1017 return _ServiceAlias == other._ServiceAlias
1018 && _VarName == other._VarName
1019 && _CurrentTime == other._CurrentTime
1020 && _Datas == other._Datas;
1021 }
1022
1023
1024 // constructor
1025 THighRezDatas()
1026 {
1027
1028 }
1029
1030 void serial(NLMISC::IStream &s)
1031 {
1032 s.serial(_ServiceAlias);
1033 s.serial(_VarName);
1034 s.serial(_CurrentTime);
1035 s.serialCont(_Datas);
1036
1037 }
1038
1039
1040 private:
1041
1042
1043 };
1044
1045
1046
1047
1048 struct TShardOrders
1049 {
1050 enum TValues
1051 {
1052 so_autostart_on,
1053 so_autostart_off,
1054 /// the highest valid value in the enum
1055 last_enum_item = so_autostart_off,
1056 /// a value equal to the last enum item +1
1057 end_of_enum,
1058
1059 invalid_val,
1060
1061 /// Number of enumerated values
1062 nb_enum_items = 2
1063 };
1064
1065 /// Index table to convert enum value to linear index table
1066 const std::map<TValues, uint32> &getIndexTable() const
1067 {
1068 static std::map<TValues, uint32> indexTable;
1069 static bool init = false;
1070 if (!init)
1071 {
1072 // fill the index table
1073 indexTable.insert(std::make_pair(so_autostart_on, 0));
1074 indexTable.insert(std::make_pair(so_autostart_off, 1));
1075
1076 init = true;
1077 }
1078
1079 return indexTable;
1080 }
1081
1082
1083 static const NLMISC::CStringConversion<TValues> &getConversionTable()
1084 {
1085 NL_BEGIN_STRING_CONVERSION_TABLE(TValues)
1086 NL_STRING_CONVERSION_TABLE_ENTRY(so_autostart_on)
1087 NL_STRING_CONVERSION_TABLE_ENTRY(so_autostart_off)
1088 NL_STRING_CONVERSION_TABLE_ENTRY(invalid_val)
1089 };
1090 static NLMISC::CStringConversion<TValues>
1091 conversionTable(TValues_nl_string_conversion_table, sizeof(TValues_nl_string_conversion_table)
1092 / sizeof(TValues_nl_string_conversion_table[0]), invalid_val);
1093
1094 return conversionTable;
1095 }
1096
1097 TValues _Value;
1098
1099 public:
1100 TShardOrders()
1101 : _Value(invalid_val)
1102 {
1103 }
1104 TShardOrders(TValues value)
1105 : _Value(value)
1106 {
1107 }
1108
1109 TShardOrders(const std::string &str)
1110 {
1111 _Value = getConversionTable().fromString(str);
1112 }
1113
1114 void serial(NLMISC::IStream &s)
1115 {
1116 s.serialEnum(_Value);
1117 }
1118
1119 bool operator == (const TShardOrders &other) const
1120 {
1121 return _Value == other._Value;
1122 }
1123 bool operator != (const TShardOrders &other) const
1124 {
1125 return ! (_Value == other._Value);
1126 }
1127 bool operator < (const TShardOrders &other) const
1128 {
1129 return _Value < other._Value;
1130 }
1131
1132 bool operator <= (const TShardOrders &other) const
1133 {
1134 return _Value <= other._Value;
1135 }
1136
1137 bool operator > (const TShardOrders &other) const
1138 {
1139 return !(_Value <= other._Value);
1140 }
1141 bool operator >= (const TShardOrders &other) const
1142 {
1143 return !(_Value < other._Value);
1144 }
1145
1146 const std::string &toString() const
1147 {
1148 return getConversionTable().toString(_Value);
1149 }
1150 static const std::string &toString(TValues value)
1151 {
1152 return getConversionTable().toString(value);
1153 }
1154
1155 TValues getValue() const
1156 {
1157 return _Value;
1158 }
1159
1160 // return true if the actual value of the enum is valid, otherwise false
1161 bool isValid()
1162 {
1163 if (_Value == invalid_val)
1164 return false;
1165
1166 // not invalid, check other enum value
1167 return getConversionTable().isValid(_Value);
1168 }
1169
1170
1171 uint32 asIndex()
1172 {
1173 std::map<TValues, uint32>::const_iterator it(getIndexTable().find(_Value));
1174 nlassert(it != getIndexTable().end());
1175 return it->second;
1176 }
1177
1178 };
1179
1180
1181 struct TRunningOrders
1182 {
1183 enum TValues
1184 {
1185 ro_deactivated,
1186 ro_activated,
1187 /// the highest valid value in the enum
1188 last_enum_item = ro_activated,
1189 /// a value equal to the last enum item +1
1190 end_of_enum,
1191
1192 invalid_val,
1193
1194 /// Number of enumerated values
1195 nb_enum_items = 2
1196 };
1197
1198 /// Index table to convert enum value to linear index table
1199 const std::map<TValues, uint32> &getIndexTable() const
1200 {
1201 static std::map<TValues, uint32> indexTable;
1202 static bool init = false;
1203 if (!init)
1204 {
1205 // fill the index table
1206 indexTable.insert(std::make_pair(ro_deactivated, 0));
1207 indexTable.insert(std::make_pair(ro_activated, 1));
1208
1209 init = true;
1210 }
1211
1212 return indexTable;
1213 }
1214
1215
1216 static const NLMISC::CStringConversion<TValues> &getConversionTable()
1217 {
1218 NL_BEGIN_STRING_CONVERSION_TABLE(TValues)
1219 NL_STRING_CONVERSION_TABLE_ENTRY(ro_deactivated)
1220 NL_STRING_CONVERSION_TABLE_ENTRY(ro_activated)
1221 NL_STRING_CONVERSION_TABLE_ENTRY(invalid_val)
1222 };
1223 static NLMISC::CStringConversion<TValues>
1224 conversionTable(TValues_nl_string_conversion_table, sizeof(TValues_nl_string_conversion_table)
1225 / sizeof(TValues_nl_string_conversion_table[0]), invalid_val);
1226
1227 return conversionTable;
1228 }
1229
1230 TValues _Value;
1231
1232 public:
1233 TRunningOrders()
1234 : _Value(invalid_val)
1235 {
1236 }
1237 TRunningOrders(TValues value)
1238 : _Value(value)
1239 {
1240 }
1241
1242 TRunningOrders(const std::string &str)
1243 {
1244 _Value = getConversionTable().fromString(str);
1245 }
1246
1247 void serial(NLMISC::IStream &s)
1248 {
1249 s.serialEnum(_Value);
1250 }
1251
1252 bool operator == (const TRunningOrders &other) const
1253 {
1254 return _Value == other._Value;
1255 }
1256 bool operator != (const TRunningOrders &other) const
1257 {
1258 return ! (_Value == other._Value);
1259 }
1260 bool operator < (const TRunningOrders &other) const
1261 {
1262 return _Value < other._Value;
1263 }
1264
1265 bool operator <= (const TRunningOrders &other) const
1266 {
1267 return _Value <= other._Value;
1268 }
1269
1270 bool operator > (const TRunningOrders &other) const
1271 {
1272 return !(_Value <= other._Value);
1273 }
1274 bool operator >= (const TRunningOrders &other) const
1275 {
1276 return !(_Value < other._Value);
1277 }
1278
1279 const std::string &toString() const
1280 {
1281 return getConversionTable().toString(_Value);
1282 }
1283 static const std::string &toString(TValues value)
1284 {
1285 return getConversionTable().toString(value);
1286 }
1287
1288 TValues getValue() const
1289 {
1290 return _Value;
1291 }
1292
1293 // return true if the actual value of the enum is valid, otherwise false
1294 bool isValid()
1295 {
1296 if (_Value == invalid_val)
1297 return false;
1298
1299 // not invalid, check other enum value
1300 return getConversionTable().isValid(_Value);
1301 }
1302
1303
1304 uint32 asIndex()
1305 {
1306 std::map<TValues, uint32>::const_iterator it(getIndexTable().find(_Value));
1307 nlassert(it != getIndexTable().end());
1308 return it->second;
1309 }
1310
1311 };
1312
1313
1314 struct TRunningState
1315 {
1316 enum TValues
1317 {
1318 rs_stopped,
1319 rs_running,
1320 rs_online,
1321 /// the highest valid value in the enum
1322 last_enum_item = rs_online,
1323 /// a value equal to the last enum item +1
1324 end_of_enum,
1325
1326 invalid_val,
1327
1328 /// Number of enumerated values
1329 nb_enum_items = 3
1330 };
1331
1332 /// Index table to convert enum value to linear index table
1333 const std::map<TValues, uint32> &getIndexTable() const
1334 {
1335 static std::map<TValues, uint32> indexTable;
1336 static bool init = false;
1337 if (!init)
1338 {
1339 // fill the index table
1340 indexTable.insert(std::make_pair(rs_stopped, 0));
1341 indexTable.insert(std::make_pair(rs_running, 1));
1342 indexTable.insert(std::make_pair(rs_online, 2));
1343
1344 init = true;
1345 }
1346
1347 return indexTable;
1348 }
1349
1350
1351 static const NLMISC::CStringConversion<TValues> &getConversionTable()
1352 {
1353 NL_BEGIN_STRING_CONVERSION_TABLE(TValues)
1354 NL_STRING_CONVERSION_TABLE_ENTRY(rs_stopped)
1355 NL_STRING_CONVERSION_TABLE_ENTRY(rs_running)
1356 NL_STRING_CONVERSION_TABLE_ENTRY(rs_online)
1357 NL_STRING_CONVERSION_TABLE_ENTRY(invalid_val)
1358 };
1359 static NLMISC::CStringConversion<TValues>
1360 conversionTable(TValues_nl_string_conversion_table, sizeof(TValues_nl_string_conversion_table)
1361 / sizeof(TValues_nl_string_conversion_table[0]), invalid_val);
1362
1363 return conversionTable;
1364 }
1365
1366 TValues _Value;
1367
1368 public:
1369 TRunningState()
1370 : _Value(invalid_val)
1371 {
1372 }
1373 TRunningState(TValues value)
1374 : _Value(value)
1375 {
1376 }
1377
1378 TRunningState(const std::string &str)
1379 {
1380 _Value = getConversionTable().fromString(str);
1381 }
1382
1383 void serial(NLMISC::IStream &s)
1384 {
1385 s.serialEnum(_Value);
1386 }
1387
1388 bool operator == (const TRunningState &other) const
1389 {
1390 return _Value == other._Value;
1391 }
1392 bool operator != (const TRunningState &other) const
1393 {
1394 return ! (_Value == other._Value);
1395 }
1396 bool operator < (const TRunningState &other) const
1397 {
1398 return _Value < other._Value;
1399 }
1400
1401 bool operator <= (const TRunningState &other) const
1402 {
1403 return _Value <= other._Value;
1404 }
1405
1406 bool operator > (const TRunningState &other) const
1407 {
1408 return !(_Value <= other._Value);
1409 }
1410 bool operator >= (const TRunningState &other) const
1411 {
1412 return !(_Value < other._Value);
1413 }
1414
1415 const std::string &toString() const
1416 {
1417 return getConversionTable().toString(_Value);
1418 }
1419 static const std::string &toString(TValues value)
1420 {
1421 return getConversionTable().toString(value);
1422 }
1423
1424 TValues getValue() const
1425 {
1426 return _Value;
1427 }
1428
1429 // return true if the actual value of the enum is valid, otherwise false
1430 bool isValid()
1431 {
1432 if (_Value == invalid_val)
1433 return false;
1434
1435 // not invalid, check other enum value
1436 return getConversionTable().isValid(_Value);
1437 }
1438
1439
1440 uint32 asIndex()
1441 {
1442 std::map<TValues, uint32>::const_iterator it(getIndexTable().find(_Value));
1443 nlassert(it != getIndexTable().end());
1444 return it->second;
1445 }
1446
1447 };
1448
1449
1450 struct TRunningTag
1451 {
1452 enum TValues
1453 {
1454 rt_chain_crashing,
1455 rt_locally_started,
1456 rt_locally_stopped,
1457 rt_globally_stopped,
1458 rt_stopped_for_patch,
1459 rt_externaly_started,
1460 rt_slow_to_stop,
1461 rt_slow_to_start,
1462 /// the highest valid value in the enum
1463 last_enum_item = rt_slow_to_start,
1464 /// a value equal to the last enum item +1
1465 end_of_enum,
1466
1467 invalid_val,
1468
1469 /// Number of enumerated values
1470 nb_enum_items = 8
1471 };
1472
1473 /// Index table to convert enum value to linear index table
1474 const std::map<TValues, uint32> &getIndexTable() const
1475 {
1476 static std::map<TValues, uint32> indexTable;
1477 static bool init = false;
1478 if (!init)
1479 {
1480 // fill the index table
1481 indexTable.insert(std::make_pair(rt_chain_crashing, 0));
1482 indexTable.insert(std::make_pair(rt_locally_started, 1));
1483 indexTable.insert(std::make_pair(rt_locally_stopped, 2));
1484 indexTable.insert(std::make_pair(rt_globally_stopped, 3));
1485 indexTable.insert(std::make_pair(rt_stopped_for_patch, 4));
1486 indexTable.insert(std::make_pair(rt_externaly_started, 5));
1487 indexTable.insert(std::make_pair(rt_slow_to_stop, 6));
1488 indexTable.insert(std::make_pair(rt_slow_to_start, 7));
1489
1490 init = true;
1491 }
1492
1493 return indexTable;
1494 }
1495
1496
1497 static const NLMISC::CStringConversion<TValues> &getConversionTable()
1498 {
1499 NL_BEGIN_STRING_CONVERSION_TABLE(TValues)
1500 NL_STRING_CONVERSION_TABLE_ENTRY(rt_chain_crashing)
1501 NL_STRING_CONVERSION_TABLE_ENTRY(rt_locally_started)
1502 NL_STRING_CONVERSION_TABLE_ENTRY(rt_locally_stopped)
1503 NL_STRING_CONVERSION_TABLE_ENTRY(rt_globally_stopped)
1504 NL_STRING_CONVERSION_TABLE_ENTRY(rt_stopped_for_patch)
1505 NL_STRING_CONVERSION_TABLE_ENTRY(rt_externaly_started)
1506 NL_STRING_CONVERSION_TABLE_ENTRY(rt_slow_to_stop)
1507 NL_STRING_CONVERSION_TABLE_ENTRY(rt_slow_to_start)
1508 NL_STRING_CONVERSION_TABLE_ENTRY(invalid_val)
1509 };
1510 static NLMISC::CStringConversion<TValues>
1511 conversionTable(TValues_nl_string_conversion_table, sizeof(TValues_nl_string_conversion_table)
1512 / sizeof(TValues_nl_string_conversion_table[0]), invalid_val);
1513
1514 return conversionTable;
1515 }
1516
1517 TValues _Value;
1518
1519 public:
1520 TRunningTag()
1521 : _Value(invalid_val)
1522 {
1523 }
1524 TRunningTag(TValues value)
1525 : _Value(value)
1526 {
1527 }
1528
1529 TRunningTag(const std::string &str)
1530 {
1531 _Value = getConversionTable().fromString(str);
1532 }
1533
1534 void serial(NLMISC::IStream &s)
1535 {
1536 s.serialEnum(_Value);
1537 }
1538
1539 bool operator == (const TRunningTag &other) const
1540 {
1541 return _Value == other._Value;
1542 }
1543 bool operator != (const TRunningTag &other) const
1544 {
1545 return ! (_Value == other._Value);
1546 }
1547 bool operator < (const TRunningTag &other) const
1548 {
1549 return _Value < other._Value;
1550 }
1551
1552 bool operator <= (const TRunningTag &other) const
1553 {
1554 return _Value <= other._Value;
1555 }
1556
1557 bool operator > (const TRunningTag &other) const
1558 {
1559 return !(_Value <= other._Value);
1560 }
1561 bool operator >= (const TRunningTag &other) const
1562 {
1563 return !(_Value < other._Value);
1564 }
1565
1566 const std::string &toString() const
1567 {
1568 return getConversionTable().toString(_Value);
1569 }
1570 static const std::string &toString(TValues value)
1571 {
1572 return getConversionTable().toString(value);
1573 }
1574
1575 TValues getValue() const
1576 {
1577 return _Value;
1578 }
1579
1580 // return true if the actual value of the enum is valid, otherwise false
1581 bool isValid()
1582 {
1583 if (_Value == invalid_val)
1584 return false;
1585
1586 // not invalid, check other enum value
1587 return getConversionTable().isValid(_Value);
1588 }
1589
1590
1591 uint32 asIndex()
1592 {
1593 std::map<TValues, uint32>::const_iterator it(getIndexTable().find(_Value));
1594 nlassert(it != getIndexTable().end());
1595 return it->second;
1596 }
1597
1598 };
1599 /////////////////////////////////////////////////////////////////
1600 // WARNING : this is a generated file, don't change it !
1601 /////////////////////////////////////////////////////////////////
1602 class TServiceStatus
1603 {
1604 protected:
1605 //
1606 std::string _ShardName;
1607 //
1608 std::string _ServiceLongName;
1609 //
1610 std::string _ServiceShortName;
1611 //
1612 std::string _ServiceAliasName;
1613 //
1614 TRunningState _RunningState;
1615 //
1616 TRunningOrders _RunningOrders;
1617 //
1618 std::set < TRunningTag > _RunningTags;
1619 //
1620 std::string _Status;
1621 public:
1622 //
1623 const std::string &getShardName() const
1624 {
1625 return _ShardName;
1626 }
1627
1628 std::string &getShardName()
1629 {
1630 return _ShardName;
1631 }
1632
1633
1634 void setShardName(const std::string &value)
1635 {
1636
1637
1638 _ShardName = value;
1639
1640
1641 }
1642 //
1643 const std::string &getServiceLongName() const
1644 {
1645 return _ServiceLongName;
1646 }
1647
1648 std::string &getServiceLongName()
1649 {
1650 return _ServiceLongName;
1651 }
1652
1653
1654 void setServiceLongName(const std::string &value)
1655 {
1656
1657
1658 _ServiceLongName = value;
1659
1660
1661 }
1662 //
1663 const std::string &getServiceShortName() const
1664 {
1665 return _ServiceShortName;
1666 }
1667
1668 std::string &getServiceShortName()
1669 {
1670 return _ServiceShortName;
1671 }
1672
1673
1674 void setServiceShortName(const std::string &value)
1675 {
1676
1677
1678 _ServiceShortName = value;
1679
1680
1681 }
1682 //
1683 const std::string &getServiceAliasName() const
1684 {
1685 return _ServiceAliasName;
1686 }
1687
1688 std::string &getServiceAliasName()
1689 {
1690 return _ServiceAliasName;
1691 }
1692
1693
1694 void setServiceAliasName(const std::string &value)
1695 {
1696
1697
1698 _ServiceAliasName = value;
1699
1700
1701 }
1702 //
1703 TRunningState getRunningState() const
1704 {
1705 return _RunningState;
1706 }
1707
1708 void setRunningState(TRunningState value)
1709 {
1710
1711 _RunningState = value;
1712
1713 }
1714 //
1715 TRunningOrders getRunningOrders() const
1716 {
1717 return _RunningOrders;
1718 }
1719
1720 void setRunningOrders(TRunningOrders value)
1721 {
1722
1723 _RunningOrders = value;
1724
1725 }
1726 //
1727 const std::set < TRunningTag > &getRunningTags() const
1728 {
1729 return _RunningTags;
1730 }
1731
1732 std::set < TRunningTag > &getRunningTags()
1733 {
1734 return _RunningTags;
1735 }
1736
1737
1738 void setRunningTags(const std::set < TRunningTag > &value)
1739 {
1740
1741
1742 _RunningTags = value;
1743
1744
1745 }
1746 //
1747 const std::string &getStatus() const
1748 {
1749 return _Status;
1750 }
1751
1752 std::string &getStatus()
1753 {
1754 return _Status;
1755 }
1756
1757
1758 void setStatus(const std::string &value)
1759 {
1760
1761
1762 _Status = value;
1763
1764
1765 }
1766
1767 bool operator == (const TServiceStatus &other) const
1768 {
1769 return _ShardName == other._ShardName
1770 && _ServiceLongName == other._ServiceLongName
1771 && _ServiceShortName == other._ServiceShortName
1772 && _ServiceAliasName == other._ServiceAliasName
1773 && _RunningState == other._RunningState
1774 && _RunningOrders == other._RunningOrders
1775 && _RunningTags == other._RunningTags
1776 && _Status == other._Status;
1777 }
1778
1779
1780 // constructor
1781 TServiceStatus()
1782 {
1783
1784 }
1785
1786 void serial(NLMISC::IStream &s)
1787 {
1788 s.serial(_ShardName);
1789 s.serial(_ServiceLongName);
1790 s.serial(_ServiceShortName);
1791 s.serial(_ServiceAliasName);
1792 s.serial(_RunningState);
1793 s.serial(_RunningOrders);
1794 s.serialCont(_RunningTags);
1795 s.serial(_Status);
1796
1797 }
1798
1799
1800 private:
1801
1802
1803 };
1804
1805
1806
1807 /////////////////////////////////////////////////////////////////
1808 // WARNING : this is a generated file, don't change it !
1809 /////////////////////////////////////////////////////////////////
1810 class CAdminServiceSkel
1811 {
1812 public:
1813 /// the interceptor type
1814 typedef NLNET::CInterceptorForwarder < CAdminServiceSkel> TInterceptor;
1815 protected:
1816 CAdminServiceSkel()
1817 {
1818 // do early run time check for message table
1819 getMessageHandlers();
1820 }
1821 virtual ~CAdminServiceSkel()
1822 {
1823 }
1824
1825 void init(NLNET::IModule *module)
1826 {
1827 _Interceptor.init(this, module);
1828 }
1829
1830 // unused interceptors
1831 std::string fwdBuildModuleManifest() const { return std::string(); }
1832 void fwdOnModuleUp(NLNET::IModuleProxy *moduleProxy) {}
1833 void fwdOnModuleDown(NLNET::IModuleProxy *moduleProxy) {}
1834 void fwdOnModuleSecurityChange(NLNET::IModuleProxy *moduleProxy) {}
1835
1836 // process module message interceptor
1837 bool fwdOnProcessModuleMessage(NLNET::IModuleProxy *sender, const NLNET::CMessage &message);
1838 private:
1839
1840 typedef void (CAdminServiceSkel::*TMessageHandler)(NLNET::IModuleProxy *sender, const NLNET::CMessage &message);
1841 typedef std::map<std::string, TMessageHandler> TMessageHandlerMap;
1842
1843 const TMessageHandlerMap &getMessageHandlers() const;
1844
1845
1846 void upServiceUpdate_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
1847
1848 void graphUpdate_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
1849
1850 void highRezGraphUpdate_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
1851
1852 void commandResult_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
1853
1854 // declare one interceptor member of the skeleton
1855 TInterceptor _Interceptor;
1856
1857 // declare the interceptor forwarder as friend of this class
1858 friend class NLNET::CInterceptorForwarder < CAdminServiceSkel>;
1859 public:
1860 /////////////////////////////////////////////////////////////////
1861 // WARNING : this is a generated file, don't change it !
1862 /////////////////////////////////////////////////////////////////
1863
1864 // An AES send an update of the list of service up
1865 virtual void upServiceUpdate(NLNET::IModuleProxy *sender, const std::vector < TServiceStatus > &serviceStatus) =0;
1866 // An AES send graph data update
1867 virtual void graphUpdate(NLNET::IModuleProxy *sender, const TGraphDatas &graphDatas) =0;
1868 // An AES send high rez graph data update
1869 virtual void highRezGraphUpdate(NLNET::IModuleProxy *sender, const THighRezDatas &graphDatas) =0;
1870 // AES send back the result of execution of a command
1871 virtual void commandResult(NLNET::IModuleProxy *sender, uint32 commandId, const std::string &serviceAlias, const std::string &result) =0;
1872
1873
1874 };
1875
1876 /////////////////////////////////////////////////////////////////
1877 // WARNING : this is a generated file, don't change it !
1878 /////////////////////////////////////////////////////////////////
1879 class CAdminServiceProxy
1880 {
1881 /// Smart pointer on the module proxy
1882 NLNET::TModuleProxyPtr _ModuleProxy;
1883
1884 // Pointer on the local module that implement the interface (if the proxy is for a local module)
1885 NLNET::TModulePtr _LocalModule;
1886 // Direct pointer on the server implementation interface for collocated module
1887 CAdminServiceSkel *_LocalModuleSkel;
1888
1889
1890 public:
1891 CAdminServiceProxy(NLNET::IModuleProxy *proxy)
1892 {
1893
1894 _ModuleProxy = proxy;
1895
1896 // initialize collocated servant interface
1897 if (proxy->getModuleDistance() == 0)
1898 {
1899 _LocalModule = proxy->getLocalModule();
1900 nlassert(_LocalModule != NULL);
1901 CAdminServiceSkel::TInterceptor *interceptor = NULL;
1902 interceptor = static_cast < NLNET::CModuleBase* >(_LocalModule.getPtr())->getInterceptor(interceptor);
1903 nlassert(interceptor != NULL);
1904
1905 _LocalModuleSkel = interceptor->getParent();
1906 nlassert(_LocalModuleSkel != NULL);
1907 }
1908 else
1909 _LocalModuleSkel = 0;
1910
1911 }
1912 virtual ~CAdminServiceProxy()
1913 {
1914 }
1915
1916 NLNET::IModuleProxy *getModuleProxy()
1917 {
1918 return _ModuleProxy;
1919 }
1920
1921 // An AES send an update of the list of service up
1922 void upServiceUpdate(NLNET::IModule *sender, const std::vector < TServiceStatus > &serviceStatus);
1923 // An AES send graph data update
1924 void graphUpdate(NLNET::IModule *sender, const TGraphDatas &graphDatas);
1925 // An AES send high rez graph data update
1926 void highRezGraphUpdate(NLNET::IModule *sender, const THighRezDatas &graphDatas);
1927 // AES send back the result of execution of a command
1928 void commandResult(NLNET::IModule *sender, uint32 commandId, const std::string &serviceAlias, const std::string &result);
1929
1930 // Message serializer. Return the message received in reference for easier integration
1931 static const NLNET::CMessage &buildMessageFor_upServiceUpdate(NLNET::CMessage &__message, const std::vector < TServiceStatus > &serviceStatus);
1932
1933 // Message serializer. Return the message received in reference for easier integration
1934 static const NLNET::CMessage &buildMessageFor_graphUpdate(NLNET::CMessage &__message, const TGraphDatas &graphDatas);
1935
1936 // Message serializer. Return the message received in reference for easier integration
1937 static const NLNET::CMessage &buildMessageFor_highRezGraphUpdate(NLNET::CMessage &__message, const THighRezDatas &graphDatas);
1938
1939 // Message serializer. Return the message received in reference for easier integration
1940 static const NLNET::CMessage &buildMessageFor_commandResult(NLNET::CMessage &__message, uint32 commandId, const std::string &serviceAlias, const std::string &result);
1941
1942
1943
1944
1945 };
1946
1947 /////////////////////////////////////////////////////////////////
1948 // WARNING : this is a generated file, don't change it !
1949 /////////////////////////////////////////////////////////////////
1950 class CAdminExecutorServiceSkel
1951 {
1952 public:
1953 /// the interceptor type
1954 typedef NLNET::CInterceptorForwarder < CAdminExecutorServiceSkel> TInterceptor;
1955 protected:
1956 CAdminExecutorServiceSkel()
1957 {
1958 // do early run time check for message table
1959 getMessageHandlers();
1960 }
1961 virtual ~CAdminExecutorServiceSkel()
1962 {
1963 }
1964
1965 void init(NLNET::IModule *module)
1966 {
1967 _Interceptor.init(this, module);
1968 }
1969
1970 // unused interceptors
1971 std::string fwdBuildModuleManifest() const { return std::string(); }
1972 void fwdOnModuleUp(NLNET::IModuleProxy *moduleProxy) {}
1973 void fwdOnModuleDown(NLNET::IModuleProxy *moduleProxy) {}
1974 void fwdOnModuleSecurityChange(NLNET::IModuleProxy *moduleProxy) {}
1975
1976 // process module message interceptor
1977 bool fwdOnProcessModuleMessage(NLNET::IModuleProxy *sender, const NLNET::CMessage &message);
1978 private:
1979
1980 typedef void (CAdminExecutorServiceSkel::*TMessageHandler)(NLNET::IModuleProxy *sender, const NLNET::CMessage &message);
1981 typedef std::map<std::string, TMessageHandler> TMessageHandlerMap;
1982
1983 const TMessageHandlerMap &getMessageHandlers() const;
1984
1985
1986 void setShardOrders_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
1987
1988 void shutdownShard_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
1989
1990 void controlCmd_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
1991
1992 void serviceCmd_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
1993
1994 void commandResult_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
1995
1996 void graphUpdate_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
1997
1998 void highRezGraphUpdate_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
1999
2000 void serviceStatusUpdate_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
2001
2002 // declare one interceptor member of the skeleton
2003 TInterceptor _Interceptor;
2004
2005 // declare the interceptor forwarder as friend of this class
2006 friend class NLNET::CInterceptorForwarder < CAdminExecutorServiceSkel>;
2007 public:
2008 /////////////////////////////////////////////////////////////////
2009 // WARNING : this is a generated file, don't change it !
2010 /////////////////////////////////////////////////////////////////
2011
2012 // AS send orders for a shard
2013 virtual void setShardOrders(NLNET::IModuleProxy *sender, const std::string &shardName, const TShardOrders &shardOrders) =0;
2014 // AS send a command to shutdown a shard with a delay
2015 virtual void shutdownShard(NLNET::IModuleProxy *sender, const std::string &shardName, uint32 delay) =0;
2016 // AS send a control command to this AES
2017 virtual void controlCmd(NLNET::IModuleProxy *sender, uint32 commandId, const std::string &serviceAlias, const std::string &command) =0;
2018 // Send a command to a service.
2019 virtual void serviceCmd(NLNET::IModuleProxy *sender, uint32 commandId, const std::string &serviceAlias, const std::string &command) =0;
2020 // AES client send back the result of execution of a command
2021 virtual void commandResult(NLNET::IModuleProxy *sender, uint32 commandId, const std::string &serviceAlias, const std::string &result) =0;
2022 // A service send graph data update
2023 virtual void graphUpdate(NLNET::IModuleProxy *sender, const TGraphDatas &graphDatas) =0;
2024 // A service high rez graph data update
2025 virtual void highRezGraphUpdate(NLNET::IModuleProxy *sender, const THighRezDatas &graphDatas) =0;
2026 // A service send an update of of it's status string
2027 virtual void serviceStatusUpdate(NLNET::IModuleProxy *sender, const std::string &status) =0;
2028
2029
2030 };
2031
2032 /////////////////////////////////////////////////////////////////
2033 // WARNING : this is a generated file, don't change it !
2034 /////////////////////////////////////////////////////////////////
2035 class CAdminExecutorServiceProxy
2036 {
2037 /// Smart pointer on the module proxy
2038 NLNET::TModuleProxyPtr _ModuleProxy;
2039
2040 // Pointer on the local module that implement the interface (if the proxy is for a local module)
2041 NLNET::TModulePtr _LocalModule;
2042 // Direct pointer on the server implementation interface for collocated module
2043 CAdminExecutorServiceSkel *_LocalModuleSkel;
2044
2045
2046 public:
2047 CAdminExecutorServiceProxy(NLNET::IModuleProxy *proxy)
2048 {
2049
2050 _ModuleProxy = proxy;
2051
2052 // initialize collocated servant interface
2053 if (proxy->getModuleDistance() == 0)
2054 {
2055 _LocalModule = proxy->getLocalModule();
2056 nlassert(_LocalModule != NULL);
2057 CAdminExecutorServiceSkel::TInterceptor *interceptor = NULL;
2058 interceptor = static_cast < NLNET::CModuleBase* >(_LocalModule.getPtr())->getInterceptor(interceptor);
2059 nlassert(interceptor != NULL);
2060
2061 _LocalModuleSkel = interceptor->getParent();
2062 nlassert(_LocalModuleSkel != NULL);
2063 }
2064 else
2065 _LocalModuleSkel = 0;
2066
2067 }
2068 virtual ~CAdminExecutorServiceProxy()
2069 {
2070 }
2071
2072 NLNET::IModuleProxy *getModuleProxy()
2073 {
2074 return _ModuleProxy;
2075 }
2076
2077 // AS send orders for a shard
2078 void setShardOrders(NLNET::IModule *sender, const std::string &shardName, const TShardOrders &shardOrders);
2079 // AS send a command to shutdown a shard with a delay
2080 void shutdownShard(NLNET::IModule *sender, const std::string &shardName, uint32 delay);
2081 // AS send a control command to this AES
2082 void controlCmd(NLNET::IModule *sender, uint32 commandId, const std::string &serviceAlias, const std::string &command);
2083 // Send a command to a service.
2084 void serviceCmd(NLNET::IModule *sender, uint32 commandId, const std::string &serviceAlias, const std::string &command);
2085 // AES client send back the result of execution of a command
2086 void commandResult(NLNET::IModule *sender, uint32 commandId, const std::string &serviceAlias, const std::string &result);
2087 // A service send graph data update
2088 void graphUpdate(NLNET::IModule *sender, const TGraphDatas &graphDatas);
2089 // A service high rez graph data update
2090 void highRezGraphUpdate(NLNET::IModule *sender, const THighRezDatas &graphDatas);
2091 // A service send an update of of it's status string
2092 void serviceStatusUpdate(NLNET::IModule *sender, const std::string &status);
2093 // AS send orders for a shard
2094
2095 // This is the broadcast version of the method.
2096 template < class ProxyIterator >
2097 static void broadcast_setShardOrders(ProxyIterator first, ProxyIterator last, NLNET::IModule *sender, const std::string &shardName, const TShardOrders &shardOrders)
2098 {
2099 NLNET::CMessage message;
2100
2101 // create the message to send to multiple dest
2102 buildMessageFor_setShardOrders(message , shardName, shardOrders);
2103
2104 for (; first != last; ++first)
2105 {
2106 NLNET::IModuleProxy *proxy = *first;
2107
2108 proxy->sendModuleMessage(sender, message);
2109 }
2110
2111 }
2112 // AS send a command to shutdown a shard with a delay
2113
2114 // This is the broadcast version of the method.
2115 template < class ProxyIterator >
2116 static void broadcast_shutdownShard(ProxyIterator first, ProxyIterator last, NLNET::IModule *sender, const std::string &shardName, uint32 delay)
2117 {
2118 NLNET::CMessage message;
2119
2120 // create the message to send to multiple dest
2121 buildMessageFor_shutdownShard(message , shardName, delay);
2122
2123 for (; first != last; ++first)
2124 {
2125 NLNET::IModuleProxy *proxy = *first;
2126
2127 proxy->sendModuleMessage(sender, message);
2128 }
2129
2130 }
2131 // AS send a control command to this AES
2132
2133 // This is the broadcast version of the method.
2134 template < class ProxyIterator >
2135 static void broadcast_controlCmd(ProxyIterator first, ProxyIterator last, NLNET::IModule *sender, uint32 commandId, const std::string &serviceAlias, const std::string &command)
2136 {
2137 NLNET::CMessage message;
2138
2139 // create the message to send to multiple dest
2140 buildMessageFor_controlCmd(message , commandId, serviceAlias, command);
2141
2142 for (; first != last; ++first)
2143 {
2144 NLNET::IModuleProxy *proxy = *first;
2145
2146 proxy->sendModuleMessage(sender, message);
2147 }
2148
2149 }
2150
2151 // Message serializer. Return the message received in reference for easier integration
2152 static const NLNET::CMessage &buildMessageFor_setShardOrders(NLNET::CMessage &__message, const std::string &shardName, const TShardOrders &shardOrders);
2153
2154 // Message serializer. Return the message received in reference for easier integration
2155 static const NLNET::CMessage &buildMessageFor_shutdownShard(NLNET::CMessage &__message, const std::string &shardName, uint32 delay);
2156
2157 // Message serializer. Return the message received in reference for easier integration
2158 static const NLNET::CMessage &buildMessageFor_controlCmd(NLNET::CMessage &__message, uint32 commandId, const std::string &serviceAlias, const std::string &command);
2159
2160 // Message serializer. Return the message received in reference for easier integration
2161 static const NLNET::CMessage &buildMessageFor_serviceCmd(NLNET::CMessage &__message, uint32 commandId, const std::string &serviceAlias, const std::string &command);
2162
2163 // Message serializer. Return the message received in reference for easier integration
2164 static const NLNET::CMessage &buildMessageFor_commandResult(NLNET::CMessage &__message, uint32 commandId, const std::string &serviceAlias, const std::string &result);
2165
2166 // Message serializer. Return the message received in reference for easier integration
2167 static const NLNET::CMessage &buildMessageFor_graphUpdate(NLNET::CMessage &__message, const TGraphDatas &graphDatas);
2168
2169 // Message serializer. Return the message received in reference for easier integration
2170 static const NLNET::CMessage &buildMessageFor_highRezGraphUpdate(NLNET::CMessage &__message, const THighRezDatas &graphDatas);
2171
2172 // Message serializer. Return the message received in reference for easier integration
2173 static const NLNET::CMessage &buildMessageFor_serviceStatusUpdate(NLNET::CMessage &__message, const std::string &status);
2174
2175
2176
2177
2178 };
2179
2180 /////////////////////////////////////////////////////////////////
2181 // WARNING : this is a generated file, don't change it !
2182 /////////////////////////////////////////////////////////////////
2183 class CAdminExecutorServiceClientSkel
2184 {
2185 public:
2186 /// the interceptor type
2187 typedef NLNET::CInterceptorForwarder < CAdminExecutorServiceClientSkel> TInterceptor;
2188 protected:
2189 CAdminExecutorServiceClientSkel()
2190 {
2191 // do early run time check for message table
2192 getMessageHandlers();
2193 }
2194 virtual ~CAdminExecutorServiceClientSkel()
2195 {
2196 }
2197
2198 void init(NLNET::IModule *module)
2199 {
2200 _Interceptor.init(this, module);
2201 }
2202
2203 // unused interceptors
2204 std::string fwdBuildModuleManifest() const { return std::string(); }
2205 void fwdOnModuleUp(NLNET::IModuleProxy *moduleProxy) {}
2206 void fwdOnModuleDown(NLNET::IModuleProxy *moduleProxy) {}
2207 void fwdOnModuleSecurityChange(NLNET::IModuleProxy *moduleProxy) {}
2208
2209 // process module message interceptor
2210 bool fwdOnProcessModuleMessage(NLNET::IModuleProxy *sender, const NLNET::CMessage &message);
2211 private:
2212
2213 typedef void (CAdminExecutorServiceClientSkel::*TMessageHandler)(NLNET::IModuleProxy *sender, const NLNET::CMessage &message);
2214 typedef std::map<std::string, TMessageHandler> TMessageHandlerMap;
2215
2216 const TMessageHandlerMap &getMessageHandlers() const;
2217
2218
2219 void serviceCmd_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
2220
2221 void serviceCmdNoReturn_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
2222
2223 // declare one interceptor member of the skeleton
2224 TInterceptor _Interceptor;
2225
2226 // declare the interceptor forwarder as friend of this class
2227 friend class NLNET::CInterceptorForwarder < CAdminExecutorServiceClientSkel>;
2228 public:
2229 /////////////////////////////////////////////////////////////////
2230 // WARNING : this is a generated file, don't change it !
2231 /////////////////////////////////////////////////////////////////
2232
2233 // execute a command and return the result.
2234 virtual void serviceCmd(NLNET::IModuleProxy *sender, uint32 commandId, const std::string &command) =0;
2235 // Send a command to a service without waiting for the return value.
2236 virtual void serviceCmdNoReturn(NLNET::IModuleProxy *sender, const std::string &command) =0;
2237
2238
2239 };
2240
2241 /////////////////////////////////////////////////////////////////
2242 // WARNING : this is a generated file, don't change it !
2243 /////////////////////////////////////////////////////////////////
2244 class CAdminExecutorServiceClientProxy
2245 {
2246 /// Smart pointer on the module proxy
2247 NLNET::TModuleProxyPtr _ModuleProxy;
2248
2249 // Pointer on the local module that implement the interface (if the proxy is for a local module)
2250 NLNET::TModulePtr _LocalModule;
2251 // Direct pointer on the server implementation interface for collocated module
2252 CAdminExecutorServiceClientSkel *_LocalModuleSkel;
2253
2254
2255 public:
2256 CAdminExecutorServiceClientProxy(NLNET::IModuleProxy *proxy)
2257 {
2258
2259 _ModuleProxy = proxy;
2260
2261 // initialize collocated servant interface
2262 if (proxy->getModuleDistance() == 0)
2263 {
2264 _LocalModule = proxy->getLocalModule();
2265 nlassert(_LocalModule != NULL);
2266 CAdminExecutorServiceClientSkel::TInterceptor *interceptor = NULL;
2267 interceptor = static_cast < NLNET::CModuleBase* >(_LocalModule.getPtr())->getInterceptor(interceptor);
2268 nlassert(interceptor != NULL);
2269
2270 _LocalModuleSkel = interceptor->getParent();
2271 nlassert(_LocalModuleSkel != NULL);
2272 }
2273 else
2274 _LocalModuleSkel = 0;
2275
2276 }
2277 virtual ~CAdminExecutorServiceClientProxy()
2278 {
2279 }
2280
2281 NLNET::IModuleProxy *getModuleProxy()
2282 {
2283 return _ModuleProxy;
2284 }
2285
2286 // execute a command and return the result.
2287 void serviceCmd(NLNET::IModule *sender, uint32 commandId, const std::string &command);
2288 // Send a command to a service without waiting for the return value.
2289 void serviceCmdNoReturn(NLNET::IModule *sender, const std::string &command);
2290
2291 // Message serializer. Return the message received in reference for easier integration
2292 static const NLNET::CMessage &buildMessageFor_serviceCmd(NLNET::CMessage &__message, uint32 commandId, const std::string &command);
2293
2294 // Message serializer. Return the message received in reference for easier integration
2295 static const NLNET::CMessage &buildMessageFor_serviceCmdNoReturn(NLNET::CMessage &__message, const std::string &command);
2296
2297
2298
2299
2300 };
2301
2302 }
2303
2304 #endif