?  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 / patchman_service / module_admin_itf.cpp
blob8e2a2a34d13b6a7da445dfb05f673f5575a61ffe
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 #include "module_admin_itf.h"
22
23 namespace PATCHMAN
24 {
25
26 /////////////////////////////////////////////////////////////////
27 // WARNING : this is a generated file, don't change it !
28 /////////////////////////////////////////////////////////////////
29
30
31 const CFileReceiverSkel::TMessageHandlerMap &CFileReceiverSkel::getMessageHandlers() const
32 {
33 static TMessageHandlerMap handlers;
34 static bool init = false;
35
36 if (!init)
37 {
38 std::pair < TMessageHandlerMap::iterator, bool > res;
39
40 res = handlers.insert(std::make_pair(std::string("FR_SETUP_SUBS"), &CFileReceiverSkel::setupSubscriptions_skel));
41 // if this assert, you have a doubly message name in your interface definition !
42 nlassert(res.second);
43
44 res = handlers.insert(std::make_pair(std::string("FR_FILE_INFO"), &CFileReceiverSkel::cbFileInfo_skel));
45 // if this assert, you have a doubly message name in your interface definition !
46 nlassert(res.second);
47
48 res = handlers.insert(std::make_pair(std::string("FR_FILE_DATA"), &CFileReceiverSkel::cbFileData_skel));
49 // if this assert, you have a doubly message name in your interface definition !
50 nlassert(res.second);
51
52 res = handlers.insert(std::make_pair(std::string("FR_FILE_ERR"), &CFileReceiverSkel::cbFileDataFailure_skel));
53 // if this assert, you have a doubly message name in your interface definition !
54 nlassert(res.second);
55
56 init = true;
57 }
58
59 return handlers;
60 }
61 bool CFileReceiverSkel::fwdOnProcessModuleMessage(NLNET::IModuleProxy *sender, const NLNET::CMessage &message)
62 {
63 const TMessageHandlerMap &mh = getMessageHandlers();
64
65 TMessageHandlerMap::const_iterator it(mh.find(message.getName()));
66
67 if (it == mh.end())
68 {
69 return false;
70 }
71
72 TMessageHandler cmd = it->second;
73 (this->*cmd)(sender, message);
74
75 return true;
76 }
77
78
79 void CFileReceiverSkel::setupSubscriptions_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
80 {
81 H_AUTO(CFileReceiverSkel_setupSubscriptions_FR_SETUP_SUBS);
82 setupSubscriptions(sender);
83 }
84
85 void CFileReceiverSkel::cbFileInfo_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
86 {
87 H_AUTO(CFileReceiverSkel_cbFileInfo_FR_FILE_INFO);
88 TFileInfoVector files;
89 nlRead(__message, serialCont, files);
90 cbFileInfo(sender, files);
91 }
92
93 void CFileReceiverSkel::cbFileData_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
94 {
95 H_AUTO(CFileReceiverSkel_cbFileData_FR_FILE_DATA);
96 std::string fileName;
97 nlRead(__message, serial, fileName);
98 uint32 startOffset;
99 nlRead(__message, serial, startOffset);
100 NLNET::TBinBuffer data;
101 nlRead(__message, serial, data);
102 cbFileData(sender, fileName, startOffset, data);
103 }
104
105 void CFileReceiverSkel::cbFileDataFailure_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
106 {
107 H_AUTO(CFileReceiverSkel_cbFileDataFailure_FR_FILE_ERR);
108 std::string fileName;
109 nlRead(__message, serial, fileName);
110 cbFileDataFailure(sender, fileName);
111 }
112 //
113 void CFileReceiverProxy::setupSubscriptions(NLNET::IModule *sender)
114 {
115 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
116 {
117 // immediate local synchronous dispatching
118 _LocalModuleSkel->setupSubscriptions(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender));
119 }
120 else
121 {
122 // send the message for remote dispatching and execution or local queing
123 NLNET::CMessage __message;
124
125 buildMessageFor_setupSubscriptions(__message);
126
127 _ModuleProxy->sendModuleMessage(sender, __message);
128 }
129 }
130 //
131 void CFileReceiverProxy::cbFileInfo(NLNET::IModule *sender, const TFileInfoVector &files)
132 {
133 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
134 {
135 // immediate local synchronous dispatching
136 _LocalModuleSkel->cbFileInfo(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), files);
137 }
138 else
139 {
140 // send the message for remote dispatching and execution or local queing
141 NLNET::CMessage __message;
142
143 buildMessageFor_cbFileInfo(__message, files);
144
145 _ModuleProxy->sendModuleMessage(sender, __message);
146 }
147 }
148 //
149 void CFileReceiverProxy::cbFileData(NLNET::IModule *sender, const std::string &fileName, uint32 startOffset, const NLNET::TBinBuffer &data)
150 {
151 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
152 {
153 // immediate local synchronous dispatching
154 _LocalModuleSkel->cbFileData(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), fileName, startOffset, data);
155 }
156 else
157 {
158 // send the message for remote dispatching and execution or local queing
159 NLNET::CMessage __message;
160
161 buildMessageFor_cbFileData(__message, fileName, startOffset, data);
162
163 _ModuleProxy->sendModuleMessage(sender, __message);
164 }
165 }
166 //
167 void CFileReceiverProxy::cbFileDataFailure(NLNET::IModule *sender, const std::string &fileName)
168 {
169 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
170 {
171 // immediate local synchronous dispatching
172 _LocalModuleSkel->cbFileDataFailure(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), fileName);
173 }
174 else
175 {
176 // send the message for remote dispatching and execution or local queing
177 NLNET::CMessage __message;
178
179 buildMessageFor_cbFileDataFailure(__message, fileName);
180
181 _ModuleProxy->sendModuleMessage(sender, __message);
182 }
183 }
184
185 // Message serializer. Return the message received in reference for easier integration
186 const NLNET::CMessage &CFileReceiverProxy::buildMessageFor_setupSubscriptions(NLNET::CMessage &__message)
187 {
188 __message.setType("FR_SETUP_SUBS");
189
190
191 return __message;
192 }
193
194 // Message serializer. Return the message received in reference for easier integration
195 const NLNET::CMessage &CFileReceiverProxy::buildMessageFor_cbFileInfo(NLNET::CMessage &__message, const TFileInfoVector &files)
196 {
197 __message.setType("FR_FILE_INFO");
198 nlWrite(__message, serialCont, const_cast < TFileInfoVector& > (files));
199
200
201 return __message;
202 }
203
204 // Message serializer. Return the message received in reference for easier integration
205 const NLNET::CMessage &CFileReceiverProxy::buildMessageFor_cbFileData(NLNET::CMessage &__message, const std::string &fileName, uint32 startOffset, const NLNET::TBinBuffer &data)
206 {
207 __message.setType("FR_FILE_DATA");
208 nlWrite(__message, serial, const_cast < std::string& > (fileName));
209 nlWrite(__message, serial, startOffset);
210 nlWrite(__message, serial, const_cast < NLNET::TBinBuffer& > (data));
211
212
213 return __message;
214 }
215
216 // Message serializer. Return the message received in reference for easier integration
217 const NLNET::CMessage &CFileReceiverProxy::buildMessageFor_cbFileDataFailure(NLNET::CMessage &__message, const std::string &fileName)
218 {
219 __message.setType("FR_FILE_ERR");
220 nlWrite(__message, serial, const_cast < std::string& > (fileName));
221
222
223 return __message;
224 }
225
226 /////////////////////////////////////////////////////////////////
227 // WARNING : this is a generated file, don't change it !
228 /////////////////////////////////////////////////////////////////
229
230
231 const CFileRepositorySkel::TMessageHandlerMap &CFileRepositorySkel::getMessageHandlers() const
232 {
233 static TMessageHandlerMap handlers;
234 static bool init = false;
235
236 if (!init)
237 {
238 std::pair < TMessageHandlerMap::iterator, bool > res;
239
240 res = handlers.insert(std::make_pair(std::string("FR_REQUEST_INFO"), &CFileRepositorySkel::requestFileInfo_skel));
241 // if this assert, you have a doubly message name in your interface definition !
242 nlassert(res.second);
243
244 res = handlers.insert(std::make_pair(std::string("FR_REQUEST_DATA"), &CFileRepositorySkel::requestFileData_skel));
245 // if this assert, you have a doubly message name in your interface definition !
246 nlassert(res.second);
247
248 res = handlers.insert(std::make_pair(std::string("FR_GET_INFO"), &CFileRepositorySkel::getInfo_skel));
249 // if this assert, you have a doubly message name in your interface definition !
250 nlassert(res.second);
251
252 res = handlers.insert(std::make_pair(std::string("FR_SUBSCRIBE"), &CFileRepositorySkel::subscribe_skel));
253 // if this assert, you have a doubly message name in your interface definition !
254 nlassert(res.second);
255
256 res = handlers.insert(std::make_pair(std::string("FR_UNSUBSCRIBE"), &CFileRepositorySkel::unsubscribe_skel));
257 // if this assert, you have a doubly message name in your interface definition !
258 nlassert(res.second);
259
260 res = handlers.insert(std::make_pair(std::string("FR_UNSUBSCRIBE_ALL"), &CFileRepositorySkel::unsubscribeAll_skel));
261 // if this assert, you have a doubly message name in your interface definition !
262 nlassert(res.second);
263
264 init = true;
265 }
266
267 return handlers;
268 }
269 bool CFileRepositorySkel::fwdOnProcessModuleMessage(NLNET::IModuleProxy *sender, const NLNET::CMessage &message)
270 {
271 const TMessageHandlerMap &mh = getMessageHandlers();
272
273 TMessageHandlerMap::const_iterator it(mh.find(message.getName()));
274
275 if (it == mh.end())
276 {
277 return false;
278 }
279
280 TMessageHandler cmd = it->second;
281 (this->*cmd)(sender, message);
282
283 return true;
284 }
285
286
287 void CFileRepositorySkel::requestFileInfo_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
288 {
289 H_AUTO(CFileRepositorySkel_requestFileInfo_FR_REQUEST_INFO);
290 NLMISC::CSString fileName;
291 nlRead(__message, serial, fileName);
292 requestFileInfo(sender, fileName);
293 }
294
295 void CFileRepositorySkel::requestFileData_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
296 {
297 H_AUTO(CFileRepositorySkel_requestFileData_FR_REQUEST_DATA);
298 NLMISC::CSString fileName;
299 nlRead(__message, serial, fileName);
300 uint32 startOffset;
301 nlRead(__message, serial, startOffset);
302 uint32 numBytes;
303 nlRead(__message, serial, numBytes);
304 requestFileData(sender, fileName, startOffset, numBytes);
305 }
306
307 void CFileRepositorySkel::getInfo_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
308 {
309 H_AUTO(CFileRepositorySkel_getInfo_FR_GET_INFO);
310 NLMISC::CSString fileSpec;
311 nlRead(__message, serial, fileSpec);
312 getInfo(sender, fileSpec);
313 }
314
315 void CFileRepositorySkel::subscribe_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
316 {
317 H_AUTO(CFileRepositorySkel_subscribe_FR_SUBSCRIBE);
318 NLMISC::CSString fileSpec;
319 nlRead(__message, serial, fileSpec);
320 subscribe(sender, fileSpec);
321 }
322
323 void CFileRepositorySkel::unsubscribe_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
324 {
325 H_AUTO(CFileRepositorySkel_unsubscribe_FR_UNSUBSCRIBE);
326 NLMISC::CSString fileSpec;
327 nlRead(__message, serial, fileSpec);
328 unsubscribe(sender, fileSpec);
329 }
330
331 void CFileRepositorySkel::unsubscribeAll_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
332 {
333 H_AUTO(CFileRepositorySkel_unsubscribeAll_FR_UNSUBSCRIBE_ALL);
334 unsubscribeAll(sender);
335 }
336 // Request info concerning a particular file
337 void CFileRepositoryProxy::requestFileInfo(NLNET::IModule *sender, const NLMISC::CSString &fileName)
338 {
339 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
340 {
341 // immediate local synchronous dispatching
342 _LocalModuleSkel->requestFileInfo(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), fileName);
343 }
344 else
345 {
346 // send the message for remote dispatching and execution or local queing
347 NLNET::CMessage __message;
348
349 buildMessageFor_requestFileInfo(__message, fileName);
350
351 _ModuleProxy->sendModuleMessage(sender, __message);
352 }
353 }
354 // Request a data block for a particular file
355 void CFileRepositoryProxy::requestFileData(NLNET::IModule *sender, const NLMISC::CSString &fileName, uint32 startOffset, uint32 numBytes)
356 {
357 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
358 {
359 // immediate local synchronous dispatching
360 _LocalModuleSkel->requestFileData(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), fileName, startOffset, numBytes);
361 }
362 else
363 {
364 // send the message for remote dispatching and execution or local queing
365 NLNET::CMessage __message;
366
367 buildMessageFor_requestFileData(__message, fileName, startOffset, numBytes);
368
369 _ModuleProxy->sendModuleMessage(sender, __message);
370 }
371 }
372 // Ask for the info concerning files matching given filespec
373 void CFileRepositoryProxy::getInfo(NLNET::IModule *sender, const NLMISC::CSString &fileSpec)
374 {
375 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
376 {
377 // immediate local synchronous dispatching
378 _LocalModuleSkel->getInfo(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), fileSpec);
379 }
380 else
381 {
382 // send the message for remote dispatching and execution or local queing
383 NLNET::CMessage __message;
384
385 buildMessageFor_getInfo(__message, fileSpec);
386
387 _ModuleProxy->sendModuleMessage(sender, __message);
388 }
389 }
390 // Ask for the info concerning files matching given filespec to be forwarded to me now
391 // and for updates to be sent to me as they are generated
392 void CFileRepositoryProxy::subscribe(NLNET::IModule *sender, const NLMISC::CSString &fileSpec)
393 {
394 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
395 {
396 // immediate local synchronous dispatching
397 _LocalModuleSkel->subscribe(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), fileSpec);
398 }
399 else
400 {
401 // send the message for remote dispatching and execution or local queing
402 NLNET::CMessage __message;
403
404 buildMessageFor_subscribe(__message, fileSpec);
405
406 _ModuleProxy->sendModuleMessage(sender, __message);
407 }
408 }
409 // Cancel subscription for given filespec
410 void CFileRepositoryProxy::unsubscribe(NLNET::IModule *sender, const NLMISC::CSString &fileSpec)
411 {
412 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
413 {
414 // immediate local synchronous dispatching
415 _LocalModuleSkel->unsubscribe(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), fileSpec);
416 }
417 else
418 {
419 // send the message for remote dispatching and execution or local queing
420 NLNET::CMessage __message;
421
422 buildMessageFor_unsubscribe(__message, fileSpec);
423
424 _ModuleProxy->sendModuleMessage(sender, __message);
425 }
426 }
427 // Cancel all subscriptions for given filespec
428 void CFileRepositoryProxy::unsubscribeAll(NLNET::IModule *sender)
429 {
430 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
431 {
432 // immediate local synchronous dispatching
433 _LocalModuleSkel->unsubscribeAll(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender));
434 }
435 else
436 {
437 // send the message for remote dispatching and execution or local queing
438 NLNET::CMessage __message;
439
440 buildMessageFor_unsubscribeAll(__message);
441
442 _ModuleProxy->sendModuleMessage(sender, __message);
443 }
444 }
445
446 // Message serializer. Return the message received in reference for easier integration
447 const NLNET::CMessage &CFileRepositoryProxy::buildMessageFor_requestFileInfo(NLNET::CMessage &__message, const NLMISC::CSString &fileName)
448 {
449 __message.setType("FR_REQUEST_INFO");
450 nlWrite(__message, serial, const_cast < NLMISC::CSString& > (fileName));
451
452
453 return __message;
454 }
455
456 // Message serializer. Return the message received in reference for easier integration
457 const NLNET::CMessage &CFileRepositoryProxy::buildMessageFor_requestFileData(NLNET::CMessage &__message, const NLMISC::CSString &fileName, uint32 startOffset, uint32 numBytes)
458 {
459 __message.setType("FR_REQUEST_DATA");
460 nlWrite(__message, serial, const_cast < NLMISC::CSString& > (fileName));
461 nlWrite(__message, serial, startOffset);
462 nlWrite(__message, serial, numBytes);
463
464
465 return __message;
466 }
467
468 // Message serializer. Return the message received in reference for easier integration
469 const NLNET::CMessage &CFileRepositoryProxy::buildMessageFor_getInfo(NLNET::CMessage &__message, const NLMISC::CSString &fileSpec)
470 {
471 __message.setType("FR_GET_INFO");
472 nlWrite(__message, serial, const_cast < NLMISC::CSString& > (fileSpec));
473
474
475 return __message;
476 }
477
478 // Message serializer. Return the message received in reference for easier integration
479 const NLNET::CMessage &CFileRepositoryProxy::buildMessageFor_subscribe(NLNET::CMessage &__message, const NLMISC::CSString &fileSpec)
480 {
481 __message.setType("FR_SUBSCRIBE");
482 nlWrite(__message, serial, const_cast < NLMISC::CSString& > (fileSpec));
483
484
485 return __message;
486 }
487
488 // Message serializer. Return the message received in reference for easier integration
489 const NLNET::CMessage &CFileRepositoryProxy::buildMessageFor_unsubscribe(NLNET::CMessage &__message, const NLMISC::CSString &fileSpec)
490 {
491 __message.setType("FR_UNSUBSCRIBE");
492 nlWrite(__message, serial, const_cast < NLMISC::CSString& > (fileSpec));
493
494
495 return __message;
496 }
497
498 // Message serializer. Return the message received in reference for easier integration
499 const NLNET::CMessage &CFileRepositoryProxy::buildMessageFor_unsubscribeAll(NLNET::CMessage &__message)
500 {
501 __message.setType("FR_UNSUBSCRIBE_ALL");
502
503
504 return __message;
505 }
506
507 /////////////////////////////////////////////////////////////////
508 // WARNING : this is a generated file, don't change it !
509 /////////////////////////////////////////////////////////////////
510
511
512 const CAdministeredModuleBaseSkel::TMessageHandlerMap &CAdministeredModuleBaseSkel::getMessageHandlers() const
513 {
514 static TMessageHandlerMap handlers;
515 static bool init = false;
516
517 if (!init)
518 {
519 std::pair < TMessageHandlerMap::iterator, bool > res;
520
521 res = handlers.insert(std::make_pair(std::string("ADMIN_EXEC"), &CAdministeredModuleBaseSkel::executeCommand_skel));
522 // if this assert, you have a doubly message name in your interface definition !
523 nlassert(res.second);
524
525 res = handlers.insert(std::make_pair(std::string("ADMIN_SETNEXT"), &CAdministeredModuleBaseSkel::installVersion_skel));
526 // if this assert, you have a doubly message name in your interface definition !
527 nlassert(res.second);
528
529 res = handlers.insert(std::make_pair(std::string("ADMIN_SETLIVE"), &CAdministeredModuleBaseSkel::launchVersion_skel));
530 // if this assert, you have a doubly message name in your interface definition !
531 nlassert(res.second);
532
533 init = true;
534 }
535
536 return handlers;
537 }
538 bool CAdministeredModuleBaseSkel::fwdOnProcessModuleMessage(NLNET::IModuleProxy *sender, const NLNET::CMessage &message)
539 {
540 const TMessageHandlerMap &mh = getMessageHandlers();
541
542 TMessageHandlerMap::const_iterator it(mh.find(message.getName()));
543
544 if (it == mh.end())
545 {
546 return false;
547 }
548
549 TMessageHandler cmd = it->second;
550 (this->*cmd)(sender, message);
551
552 return true;
553 }
554
555
556 void CAdministeredModuleBaseSkel::executeCommand_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
557 {
558 H_AUTO(CAdministeredModuleBaseSkel_executeCommand_ADMIN_EXEC);
559 NLMISC::CSString originator;
560 nlRead(__message, serial, originator);
561 NLMISC::CSString cmdline;
562 nlRead(__message, serial, cmdline);
563 executeCommand(sender, originator, cmdline);
564 }
565
566 void CAdministeredModuleBaseSkel::installVersion_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
567 {
568 H_AUTO(CAdministeredModuleBaseSkel_installVersion_ADMIN_SETNEXT);
569 NLMISC::CSString domainName;
570 nlRead(__message, serial, domainName);
571 uint32 version;
572 nlRead(__message, serial, version);
573 installVersion(sender, domainName, version);
574 }
575
576 void CAdministeredModuleBaseSkel::launchVersion_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
577 {
578 H_AUTO(CAdministeredModuleBaseSkel_launchVersion_ADMIN_SETLIVE);
579 NLMISC::CSString domainName;
580 nlRead(__message, serial, domainName);
581 uint32 version;
582 nlRead(__message, serial, version);
583 launchVersion(sender, domainName, version);
584 }
585 //
586 // Message sent by SPM module to request execution of a command
587 void CAdministeredModuleBaseProxy::executeCommand(NLNET::IModule *sender, const NLMISC::CSString &originator, const NLMISC::CSString &cmdline)
588 {
589 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
590 {
591 // immediate local synchronous dispatching
592 _LocalModuleSkel->executeCommand(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), originator, cmdline);
593 }
594 else
595 {
596 // send the message for remote dispatching and execution or local queing
597 NLNET::CMessage __message;
598
599 buildMessageFor_executeCommand(__message, originator, cmdline);
600
601 _ModuleProxy->sendModuleMessage(sender, __message);
602 }
603 }
604 //
605 void CAdministeredModuleBaseProxy::installVersion(NLNET::IModule *sender, const NLMISC::CSString &domainName, uint32 version)
606 {
607 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
608 {
609 // immediate local synchronous dispatching
610 _LocalModuleSkel->installVersion(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), domainName, version);
611 }
612 else
613 {
614 // send the message for remote dispatching and execution or local queing
615 NLNET::CMessage __message;
616
617 buildMessageFor_installVersion(__message, domainName, version);
618
619 _ModuleProxy->sendModuleMessage(sender, __message);
620 }
621 }
622 //
623 void CAdministeredModuleBaseProxy::launchVersion(NLNET::IModule *sender, const NLMISC::CSString &domainName, uint32 version)
624 {
625 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
626 {
627 // immediate local synchronous dispatching
628 _LocalModuleSkel->launchVersion(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), domainName, version);
629 }
630 else
631 {
632 // send the message for remote dispatching and execution or local queing
633 NLNET::CMessage __message;
634
635 buildMessageFor_launchVersion(__message, domainName, version);
636
637 _ModuleProxy->sendModuleMessage(sender, __message);
638 }
639 }
640
641 // Message serializer. Return the message received in reference for easier integration
642 const NLNET::CMessage &CAdministeredModuleBaseProxy::buildMessageFor_executeCommand(NLNET::CMessage &__message, const NLMISC::CSString &originator, const NLMISC::CSString &cmdline)
643 {
644 __message.setType("ADMIN_EXEC");
645 nlWrite(__message, serial, const_cast < NLMISC::CSString& > (originator));
646 nlWrite(__message, serial, const_cast < NLMISC::CSString& > (cmdline));
647
648
649 return __message;
650 }
651
652 // Message serializer. Return the message received in reference for easier integration
653 const NLNET::CMessage &CAdministeredModuleBaseProxy::buildMessageFor_installVersion(NLNET::CMessage &__message, const NLMISC::CSString &domainName, uint32 version)
654 {
655 __message.setType("ADMIN_SETNEXT");
656 nlWrite(__message, serial, const_cast < NLMISC::CSString& > (domainName));
657 nlWrite(__message, serial, version);
658
659
660 return __message;
661 }
662
663 // Message serializer. Return the message received in reference for easier integration
664 const NLNET::CMessage &CAdministeredModuleBaseProxy::buildMessageFor_launchVersion(NLNET::CMessage &__message, const NLMISC::CSString &domainName, uint32 version)
665 {
666 __message.setType("ADMIN_SETLIVE");
667 nlWrite(__message, serial, const_cast < NLMISC::CSString& > (domainName));
668 nlWrite(__message, serial, version);
669
670
671 return __message;
672 }
673
674 /////////////////////////////////////////////////////////////////
675 // WARNING : this is a generated file, don't change it !
676 /////////////////////////////////////////////////////////////////
677
678
679 const CServerPatchTerminalSkel::TMessageHandlerMap &CServerPatchTerminalSkel::getMessageHandlers() const
680 {
681 static TMessageHandlerMap handlers;
682 static bool init = false;
683
684 if (!init)
685 {
686 std::pair < TMessageHandlerMap::iterator, bool > res;
687
688 res = handlers.insert(std::make_pair(std::string("SPT_STATE"), &CServerPatchTerminalSkel::declareState_skel));
689 // if this assert, you have a doubly message name in your interface definition !
690 nlassert(res.second);
691
692 res = handlers.insert(std::make_pair(std::string("SPT_MODULEDOWN"), &CServerPatchTerminalSkel::declareModuleDown_skel));
693 // if this assert, you have a doubly message name in your interface definition !
694 nlassert(res.second);
695
696 res = handlers.insert(std::make_pair(std::string("SPT_VERSION_NAME"), &CServerPatchTerminalSkel::declareVersionName_skel));
697 // if this assert, you have a doubly message name in your interface definition !
698 nlassert(res.second);
699
700 res = handlers.insert(std::make_pair(std::string("SPT_DOMAIN_INFO"), &CServerPatchTerminalSkel::declareDomainInfo_skel));
701 // if this assert, you have a doubly message name in your interface definition !
702 nlassert(res.second);
703
704 res = handlers.insert(std::make_pair(std::string("SPT_VERSION_ACK"), &CServerPatchTerminalSkel::ackVersionChange_skel));
705 // if this assert, you have a doubly message name in your interface definition !
706 nlassert(res.second);
707
708 res = handlers.insert(std::make_pair(std::string("SPT_SETNEXT"), &CServerPatchTerminalSkel::setInstallVersion_skel));
709 // if this assert, you have a doubly message name in your interface definition !
710 nlassert(res.second);
711
712 res = handlers.insert(std::make_pair(std::string("SPT_SETLIVE"), &CServerPatchTerminalSkel::setLaunchVersion_skel));
713 // if this assert, you have a doubly message name in your interface definition !
714 nlassert(res.second);
715
716 res = handlers.insert(std::make_pair(std::string("SPT_EXEC_ACK"), &CServerPatchTerminalSkel::executedCommandAck_skel));
717 // if this assert, you have a doubly message name in your interface definition !
718 nlassert(res.second);
719
720 res = handlers.insert(std::make_pair(std::string("SPT_EXEC_RESULT"), &CServerPatchTerminalSkel::executedCommandResult_skel));
721 // if this assert, you have a doubly message name in your interface definition !
722 nlassert(res.second);
723
724 init = true;
725 }
726
727 return handlers;
728 }
729 bool CServerPatchTerminalSkel::fwdOnProcessModuleMessage(NLNET::IModuleProxy *sender, const NLNET::CMessage &message)
730 {
731 const TMessageHandlerMap &mh = getMessageHandlers();
732
733 TMessageHandlerMap::const_iterator it(mh.find(message.getName()));
734
735 if (it == mh.end())
736 {
737 return false;
738 }
739
740 TMessageHandler cmd = it->second;
741 (this->*cmd)(sender, message);
742
743 return true;
744 }
745
746
747 void CServerPatchTerminalSkel::declareState_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
748 {
749 H_AUTO(CServerPatchTerminalSkel_declareState_SPT_STATE);
750 NLMISC::CSString moduleName;
751 nlRead(__message, serial, moduleName);
752 NLMISC::CSString state;
753 nlRead(__message, serial, state);
754 declareState(sender, moduleName, state);
755 }
756
757 void CServerPatchTerminalSkel::declareModuleDown_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
758 {
759 H_AUTO(CServerPatchTerminalSkel_declareModuleDown_SPT_MODULEDOWN);
760 NLMISC::CSString moduleName;
761 nlRead(__message, serial, moduleName);
762 declareModuleDown(sender, moduleName);
763 }
764
765 void CServerPatchTerminalSkel::declareVersionName_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
766 {
767 H_AUTO(CServerPatchTerminalSkel_declareVersionName_SPT_VERSION_NAME);
768 NLMISC::CSString versionName;
769 nlRead(__message, serial, versionName);
770 uint32 clientVersion;
771 nlRead(__message, serial, clientVersion);
772 uint32 serverVersion;
773 nlRead(__message, serial, serverVersion);
774 declareVersionName(sender, versionName, clientVersion, serverVersion);
775 }
776
777 void CServerPatchTerminalSkel::declareDomainInfo_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
778 {
779 H_AUTO(CServerPatchTerminalSkel_declareDomainInfo_SPT_DOMAIN_INFO);
780 NLMISC::CSString domainName;
781 nlRead(__message, serial, domainName);
782 uint32 installVersion;
783 nlRead(__message, serial, installVersion);
784 uint32 launchVersion;
785 nlRead(__message, serial, launchVersion);
786 declareDomainInfo(sender, domainName, installVersion, launchVersion);
787 }
788
789 void CServerPatchTerminalSkel::ackVersionChange_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
790 {
791 H_AUTO(CServerPatchTerminalSkel_ackVersionChange_SPT_VERSION_ACK);
792 NLMISC::CSString domainName;
793 nlRead(__message, serial, domainName);
794 bool success;
795 nlRead(__message, serial, success);
796 NLMISC::CSString comment;
797 nlRead(__message, serial, comment);
798 ackVersionChange(sender, domainName, success, comment);
799 }
800
801 void CServerPatchTerminalSkel::setInstallVersion_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
802 {
803 H_AUTO(CServerPatchTerminalSkel_setInstallVersion_SPT_SETNEXT);
804 NLMISC::CSString domain;
805 nlRead(__message, serial, domain);
806 uint32 version;
807 nlRead(__message, serial, version);
808 setInstallVersion(sender, domain, version);
809 }
810
811 void CServerPatchTerminalSkel::setLaunchVersion_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
812 {
813 H_AUTO(CServerPatchTerminalSkel_setLaunchVersion_SPT_SETLIVE);
814 NLMISC::CSString domain;
815 nlRead(__message, serial, domain);
816 uint32 version;
817 nlRead(__message, serial, version);
818 setLaunchVersion(sender, domain, version);
819 }
820
821 void CServerPatchTerminalSkel::executedCommandAck_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
822 {
823 H_AUTO(CServerPatchTerminalSkel_executedCommandAck_SPT_EXEC_ACK);
824 NLMISC::CSString result;
825 nlRead(__message, serial, result);
826 executedCommandAck(sender, result);
827 }
828
829 void CServerPatchTerminalSkel::executedCommandResult_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
830 {
831 H_AUTO(CServerPatchTerminalSkel_executedCommandResult_SPT_EXEC_RESULT);
832 NLMISC::CSString originator;
833 nlRead(__message, serial, originator);
834 NLMISC::CSString commandline;
835 nlRead(__message, serial, commandline);
836 NLMISC::CSString result;
837 nlRead(__message, serial, result);
838 executedCommandResult(sender, originator, commandline, result);
839 }
840 //
841 // Message sent by SPM module to declare the state of a named module
842 // This message is sent by the SPM for each connected SP / RE / RR type module on connection of SPT to SPM
843 // This message is also sent by the SPM for each type the SPM receives a state update from a SP / RE / RR type module
844 void CServerPatchTerminalProxy::declareState(NLNET::IModule *sender, const NLMISC::CSString &moduleName, const NLMISC::CSString &state)
845 {
846 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
847 {
848 // immediate local synchronous dispatching
849 _LocalModuleSkel->declareState(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), moduleName, state);
850 }
851 else
852 {
853 // send the message for remote dispatching and execution or local queing
854 NLNET::CMessage __message;
855
856 buildMessageFor_declareState(__message, moduleName, state);
857
858 _ModuleProxy->sendModuleMessage(sender, __message);
859 }
860 }
861 //
862 // Message sent by SPM module to declare module down for a connected SPA / SPR / SPB type module
863 void CServerPatchTerminalProxy::declareModuleDown(NLNET::IModule *sender, const NLMISC::CSString &moduleName)
864 {
865 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
866 {
867 // immediate local synchronous dispatching
868 _LocalModuleSkel->declareModuleDown(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), moduleName);
869 }
870 else
871 {
872 // send the message for remote dispatching and execution or local queing
873 NLNET::CMessage __message;
874
875 buildMessageFor_declareModuleDown(__message, moduleName);
876
877 _ModuleProxy->sendModuleMessage(sender, __message);
878 }
879 }
880 //
881 // Message sent by SPM module to define a named version
882 void CServerPatchTerminalProxy::declareVersionName(NLNET::IModule *sender, const NLMISC::CSString &versionName, uint32 clientVersion, uint32 serverVersion)
883 {
884 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
885 {
886 // immediate local synchronous dispatching
887 _LocalModuleSkel->declareVersionName(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), versionName, clientVersion, serverVersion);
888 }
889 else
890 {
891 // send the message for remote dispatching and execution or local queing
892 NLNET::CMessage __message;
893
894 buildMessageFor_declareVersionName(__message, versionName, clientVersion, serverVersion);
895
896 _ModuleProxy->sendModuleMessage(sender, __message);
897 }
898 }
899 //
900 // Message sent by SPM module to give info on a named domain
901 void CServerPatchTerminalProxy::declareDomainInfo(NLNET::IModule *sender, const NLMISC::CSString &domainName, uint32 installVersion, uint32 launchVersion)
902 {
903 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
904 {
905 // immediate local synchronous dispatching
906 _LocalModuleSkel->declareDomainInfo(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), domainName, installVersion, launchVersion);
907 }
908 else
909 {
910 // send the message for remote dispatching and execution or local queing
911 NLNET::CMessage __message;
912
913 buildMessageFor_declareDomainInfo(__message, domainName, installVersion, launchVersion);
914
915 _ModuleProxy->sendModuleMessage(sender, __message);
916 }
917 }
918 //
919 // Message sent by SPM module to acknowledge a version change attempt
920 void CServerPatchTerminalProxy::ackVersionChange(NLNET::IModule *sender, const NLMISC::CSString &domainName, bool success, const NLMISC::CSString &comment)
921 {
922 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
923 {
924 // immediate local synchronous dispatching
925 _LocalModuleSkel->ackVersionChange(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), domainName, success, comment);
926 }
927 else
928 {
929 // send the message for remote dispatching and execution or local queing
930 NLNET::CMessage __message;
931
932 buildMessageFor_ackVersionChange(__message, domainName, success, comment);
933
934 _ModuleProxy->sendModuleMessage(sender, __message);
935 }
936 }
937 //
938 // Message sent by SPM to inform us of the current installed version for a given domain
939 void CServerPatchTerminalProxy::setInstallVersion(NLNET::IModule *sender, const NLMISC::CSString &domain, uint32 version)
940 {
941 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
942 {
943 // immediate local synchronous dispatching
944 _LocalModuleSkel->setInstallVersion(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), domain, version);
945 }
946 else
947 {
948 // send the message for remote dispatching and execution or local queing
949 NLNET::CMessage __message;
950
951 buildMessageFor_setInstallVersion(__message, domain, version);
952
953 _ModuleProxy->sendModuleMessage(sender, __message);
954 }
955 }
956 //
957 // Message sent by SPM to inform us of the current live version for a given domain
958 void CServerPatchTerminalProxy::setLaunchVersion(NLNET::IModule *sender, const NLMISC::CSString &domain, uint32 version)
959 {
960 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
961 {
962 // immediate local synchronous dispatching
963 _LocalModuleSkel->setLaunchVersion(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), domain, version);
964 }
965 else
966 {
967 // send the message for remote dispatching and execution or local queing
968 NLNET::CMessage __message;
969
970 buildMessageFor_setLaunchVersion(__message, domain, version);
971
972 _ModuleProxy->sendModuleMessage(sender, __message);
973 }
974 }
975 //
976 // Message sent by SPM with result of command issuued via executeCommandOnModules()
977 void CServerPatchTerminalProxy::executedCommandAck(NLNET::IModule *sender, const NLMISC::CSString &result)
978 {
979 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
980 {
981 // immediate local synchronous dispatching
982 _LocalModuleSkel->executedCommandAck(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), result);
983 }
984 else
985 {
986 // send the message for remote dispatching and execution or local queing
987 NLNET::CMessage __message;
988
989 buildMessageFor_executedCommandAck(__message, result);
990
991 _ModuleProxy->sendModuleMessage(sender, __message);
992 }
993 }
994 //
995 // Message sent by SPM with result of command issuued via executeCommandOnModules()
996 void CServerPatchTerminalProxy::executedCommandResult(NLNET::IModule *sender, const NLMISC::CSString &originator, const NLMISC::CSString &commandline, const NLMISC::CSString &result)
997 {
998 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
999 {
1000 // immediate local synchronous dispatching
1001 _LocalModuleSkel->executedCommandResult(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), originator, commandline, result);
1002 }
1003 else
1004 {
1005 // send the message for remote dispatching and execution or local queing
1006 NLNET::CMessage __message;
1007
1008 buildMessageFor_executedCommandResult(__message, originator, commandline, result);
1009
1010 _ModuleProxy->sendModuleMessage(sender, __message);
1011 }
1012 }
1013
1014 // Message serializer. Return the message received in reference for easier integration
1015 const NLNET::CMessage &CServerPatchTerminalProxy::buildMessageFor_declareState(NLNET::CMessage &__message, const NLMISC::CSString &moduleName, const NLMISC::CSString &state)
1016 {
1017 __message.setType("SPT_STATE");
1018 nlWrite(__message, serial, const_cast < NLMISC::CSString& > (moduleName));
1019 nlWrite(__message, serial, const_cast < NLMISC::CSString& > (state));
1020
1021
1022 return __message;
1023 }
1024
1025 // Message serializer. Return the message received in reference for easier integration
1026 const NLNET::CMessage &CServerPatchTerminalProxy::buildMessageFor_declareModuleDown(NLNET::CMessage &__message, const NLMISC::CSString &moduleName)
1027 {
1028 __message.setType("SPT_MODULEDOWN");
1029 nlWrite(__message, serial, const_cast < NLMISC::CSString& > (moduleName));
1030
1031
1032 return __message;
1033 }
1034
1035 // Message serializer. Return the message received in reference for easier integration
1036 const NLNET::CMessage &CServerPatchTerminalProxy::buildMessageFor_declareVersionName(NLNET::CMessage &__message, const NLMISC::CSString &versionName, uint32 clientVersion, uint32 serverVersion)
1037 {
1038 __message.setType("SPT_VERSION_NAME");
1039 nlWrite(__message, serial, const_cast < NLMISC::CSString& > (versionName));
1040 nlWrite(__message, serial, clientVersion);
1041 nlWrite(__message, serial, serverVersion);
1042
1043
1044 return __message;
1045 }
1046
1047 // Message serializer. Return the message received in reference for easier integration
1048 const NLNET::CMessage &CServerPatchTerminalProxy::buildMessageFor_declareDomainInfo(NLNET::CMessage &__message, const NLMISC::CSString &domainName, uint32 installVersion, uint32 launchVersion)
1049 {
1050 __message.setType("SPT_DOMAIN_INFO");
1051 nlWrite(__message, serial, const_cast < NLMISC::CSString& > (domainName));
1052 nlWrite(__message, serial, installVersion);
1053 nlWrite(__message, serial, launchVersion);
1054
1055
1056 return __message;
1057 }
1058
1059 // Message serializer. Return the message received in reference for easier integration
1060 const NLNET::CMessage &CServerPatchTerminalProxy::buildMessageFor_ackVersionChange(NLNET::CMessage &__message, const NLMISC::CSString &domainName, bool success, const NLMISC::CSString &comment)
1061 {
1062 __message.setType("SPT_VERSION_ACK");
1063 nlWrite(__message, serial, const_cast < NLMISC::CSString& > (domainName));
1064 nlWrite(__message, serial, success);
1065 nlWrite(__message, serial, const_cast < NLMISC::CSString& > (comment));
1066
1067
1068 return __message;
1069 }
1070
1071 // Message serializer. Return the message received in reference for easier integration
1072 const NLNET::CMessage &CServerPatchTerminalProxy::buildMessageFor_setInstallVersion(NLNET::CMessage &__message, const NLMISC::CSString &domain, uint32 version)
1073 {
1074 __message.setType("SPT_SETNEXT");
1075 nlWrite(__message, serial, const_cast < NLMISC::CSString& > (domain));
1076 nlWrite(__message, serial, version);
1077
1078
1079 return __message;
1080 }
1081
1082 // Message serializer. Return the message received in reference for easier integration
1083 const NLNET::CMessage &CServerPatchTerminalProxy::buildMessageFor_setLaunchVersion(NLNET::CMessage &__message, const NLMISC::CSString &domain, uint32 version)
1084 {
1085 __message.setType("SPT_SETLIVE");
1086 nlWrite(__message, serial, const_cast < NLMISC::CSString& > (domain));
1087 nlWrite(__message, serial, version);
1088
1089
1090 return __message;
1091 }
1092
1093 // Message serializer. Return the message received in reference for easier integration
1094 const NLNET::CMessage &CServerPatchTerminalProxy::buildMessageFor_executedCommandAck(NLNET::CMessage &__message, const NLMISC::CSString &result)
1095 {
1096 __message.setType("SPT_EXEC_ACK");
1097 nlWrite(__message, serial, const_cast < NLMISC::CSString& > (result));
1098
1099
1100 return __message;
1101 }
1102
1103 // Message serializer. Return the message received in reference for easier integration
1104 const NLNET::CMessage &CServerPatchTerminalProxy::buildMessageFor_executedCommandResult(NLNET::CMessage &__message, const NLMISC::CSString &originator, const NLMISC::CSString &commandline, const NLMISC::CSString &result)
1105 {
1106 __message.setType("SPT_EXEC_RESULT");
1107 nlWrite(__message, serial, const_cast < NLMISC::CSString& > (originator));
1108 nlWrite(__message, serial, const_cast < NLMISC::CSString& > (commandline));
1109 nlWrite(__message, serial, const_cast < NLMISC::CSString& > (result));
1110
1111
1112 return __message;
1113 }
1114
1115 /////////////////////////////////////////////////////////////////
1116 // WARNING : this is a generated file, don't change it !
1117 /////////////////////////////////////////////////////////////////
1118
1119
1120 const CServerPatchManagerSkel::TMessageHandlerMap &CServerPatchManagerSkel::getMessageHandlers() const
1121 {
1122 static TMessageHandlerMap handlers;
1123 static bool init = false;
1124
1125 if (!init)
1126 {
1127 std::pair < TMessageHandlerMap::iterator, bool > res;
1128
1129 res = handlers.insert(std::make_pair(std::string("SPM_REGISTER"), &CServerPatchManagerSkel::registerAdministeredModule_skel));
1130 // if this assert, you have a doubly message name in your interface definition !
1131 nlassert(res.second);
1132
1133 res = handlers.insert(std::make_pair(std::string("SPM_REFRESH"), &CServerPatchManagerSkel::requestRefresh_skel));
1134 // if this assert, you have a doubly message name in your interface definition !
1135 nlassert(res.second);
1136
1137 res = handlers.insert(std::make_pair(std::string("SPM_SETNEXT"), &CServerPatchManagerSkel::setInstallVersion_skel));
1138 // if this assert, you have a doubly message name in your interface definition !
1139 nlassert(res.second);
1140
1141 res = handlers.insert(std::make_pair(std::string("SPM_SETLIVE"), &CServerPatchManagerSkel::setLaunchVersion_skel));
1142 // if this assert, you have a doubly message name in your interface definition !
1143 nlassert(res.second);
1144
1145 res = handlers.insert(std::make_pair(std::string("SPM_STATE"), &CServerPatchManagerSkel::declareState_skel));
1146 // if this assert, you have a doubly message name in your interface definition !
1147 nlassert(res.second);
1148
1149 res = handlers.insert(std::make_pair(std::string("SPM_VERSION_NAME"), &CServerPatchManagerSkel::declareVersionName_skel));
1150 // if this assert, you have a doubly message name in your interface definition !
1151 nlassert(res.second);
1152
1153 res = handlers.insert(std::make_pair(std::string("SPM_EXEC"), &CServerPatchManagerSkel::executeCommandOnModules_skel));
1154 // if this assert, you have a doubly message name in your interface definition !
1155 nlassert(res.second);
1156
1157 res = handlers.insert(std::make_pair(std::string("SPM_EXEC_RESULT"), &CServerPatchManagerSkel::executedCommandResult_skel));
1158 // if this assert, you have a doubly message name in your interface definition !
1159 nlassert(res.second);
1160
1161 init = true;
1162 }
1163
1164 return handlers;
1165 }
1166 bool CServerPatchManagerSkel::fwdOnProcessModuleMessage(NLNET::IModuleProxy *sender, const NLNET::CMessage &message)
1167 {
1168 const TMessageHandlerMap &mh = getMessageHandlers();
1169
1170 TMessageHandlerMap::const_iterator it(mh.find(message.getName()));
1171
1172 if (it == mh.end())
1173 {
1174 return false;
1175 }
1176
1177 TMessageHandler cmd = it->second;
1178 (this->*cmd)(sender, message);
1179
1180 return true;
1181 }
1182
1183
1184 void CServerPatchManagerSkel::registerAdministeredModule_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
1185 {
1186 H_AUTO(CServerPatchManagerSkel_registerAdministeredModule_SPM_REGISTER);
1187 bool requireApplierUpdates;
1188 nlRead(__message, serial, requireApplierUpdates);
1189 bool requireTerminalUpdates;
1190 nlRead(__message, serial, requireTerminalUpdates);
1191 bool requireDepCfgUpdates;
1192 nlRead(__message, serial, requireDepCfgUpdates);
1193 bool isAdministered;
1194 nlRead(__message, serial, isAdministered);
1195 registerAdministeredModule(sender, requireApplierUpdates, requireTerminalUpdates, requireDepCfgUpdates, isAdministered);
1196 }
1197
1198 void CServerPatchManagerSkel::requestRefresh_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
1199 {
1200 H_AUTO(CServerPatchManagerSkel_requestRefresh_SPM_REFRESH);
1201 requestRefresh(sender);
1202 }
1203
1204 void CServerPatchManagerSkel::setInstallVersion_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
1205 {
1206 H_AUTO(CServerPatchManagerSkel_setInstallVersion_SPM_SETNEXT);
1207 NLMISC::CSString domain;
1208 nlRead(__message, serial, domain);
1209 uint32 version;
1210 nlRead(__message, serial, version);
1211 setInstallVersion(sender, domain, version);
1212 }
1213
1214 void CServerPatchManagerSkel::setLaunchVersion_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
1215 {
1216 H_AUTO(CServerPatchManagerSkel_setLaunchVersion_SPM_SETLIVE);
1217 NLMISC::CSString domain;
1218 nlRead(__message, serial, domain);
1219 uint32 version;
1220 nlRead(__message, serial, version);
1221 setLaunchVersion(sender, domain, version);
1222 }
1223
1224 void CServerPatchManagerSkel::declareState_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
1225 {
1226 H_AUTO(CServerPatchManagerSkel_declareState_SPM_STATE);
1227 NLMISC::CSString state;
1228 nlRead(__message, serial, state);
1229 declareState(sender, state);
1230 }
1231
1232 void CServerPatchManagerSkel::declareVersionName_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
1233 {
1234 H_AUTO(CServerPatchManagerSkel_declareVersionName_SPM_VERSION_NAME);
1235 NLMISC::CSString versionName;
1236 nlRead(__message, serial, versionName);
1237 uint32 clientVersion;
1238 nlRead(__message, serial, clientVersion);
1239 uint32 serverVersion;
1240 nlRead(__message, serial, serverVersion);
1241 declareVersionName(sender, versionName, clientVersion, serverVersion);
1242 }
1243
1244 void CServerPatchManagerSkel::executeCommandOnModules_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
1245 {
1246 H_AUTO(CServerPatchManagerSkel_executeCommandOnModules_SPM_EXEC);
1247 NLMISC::CSString target;
1248 nlRead(__message, serial, target);
1249 NLMISC::CSString commandline;
1250 nlRead(__message, serial, commandline);
1251 executeCommandOnModules(sender, target, commandline);
1252 }
1253
1254 void CServerPatchManagerSkel::executedCommandResult_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
1255 {
1256 H_AUTO(CServerPatchManagerSkel_executedCommandResult_SPM_EXEC_RESULT);
1257 NLMISC::CSString originator;
1258 nlRead(__message, serial, originator);
1259 NLMISC::CSString commandline;
1260 nlRead(__message, serial, commandline);
1261 NLMISC::CSString result;
1262 nlRead(__message, serial, result);
1263 executedCommandResult(sender, originator, commandline, result);
1264 }
1265 //
1266 // Message sent by an administered module to register
1267 void CServerPatchManagerProxy::registerAdministeredModule(NLNET::IModule *sender, bool requireApplierUpdates, bool requireTerminalUpdates, bool requireDepCfgUpdates, bool isAdministered)
1268 {
1269 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
1270 {
1271 // immediate local synchronous dispatching
1272 _LocalModuleSkel->registerAdministeredModule(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), requireApplierUpdates, requireTerminalUpdates, requireDepCfgUpdates, isAdministered);
1273 }
1274 else
1275 {
1276 // send the message for remote dispatching and execution or local queing
1277 NLNET::CMessage __message;
1278
1279 buildMessageFor_registerAdministeredModule(__message, requireApplierUpdates, requireTerminalUpdates, requireDepCfgUpdates, isAdministered);
1280
1281 _ModuleProxy->sendModuleMessage(sender, __message);
1282 }
1283 }
1284 //
1285 // Message sent by SPT module to request a refresh of state info etc
1286 void CServerPatchManagerProxy::requestRefresh(NLNET::IModule *sender)
1287 {
1288 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
1289 {
1290 // immediate local synchronous dispatching
1291 _LocalModuleSkel->requestRefresh(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender));
1292 }
1293 else
1294 {
1295 // send the message for remote dispatching and execution or local queing
1296 NLNET::CMessage __message;
1297
1298 buildMessageFor_requestRefresh(__message);
1299
1300 _ModuleProxy->sendModuleMessage(sender, __message);
1301 }
1302 }
1303 //
1304 // Message sent by SPT module to request a change of install version for a given domain
1305 // This message is forwarded to all SPA modules of the given domain
1306 void CServerPatchManagerProxy::setInstallVersion(NLNET::IModule *sender, const NLMISC::CSString &domain, uint32 version)
1307 {
1308 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
1309 {
1310 // immediate local synchronous dispatching
1311 _LocalModuleSkel->setInstallVersion(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), domain, version);
1312 }
1313 else
1314 {
1315 // send the message for remote dispatching and execution or local queing
1316 NLNET::CMessage __message;
1317
1318 buildMessageFor_setInstallVersion(__message, domain, version);
1319
1320 _ModuleProxy->sendModuleMessage(sender, __message);
1321 }
1322 }
1323 //
1324 // Message sent by SPT module to request a change of launch version for a given domain
1325 // This message is forwarded to all SPA modules of the given domain
1326 void CServerPatchManagerProxy::setLaunchVersion(NLNET::IModule *sender, const NLMISC::CSString &domain, uint32 version)
1327 {
1328 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
1329 {
1330 // immediate local synchronous dispatching
1331 _LocalModuleSkel->setLaunchVersion(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), domain, version);
1332 }
1333 else
1334 {
1335 // send the message for remote dispatching and execution or local queing
1336 NLNET::CMessage __message;
1337
1338 buildMessageFor_setLaunchVersion(__message, domain, version);
1339
1340 _ModuleProxy->sendModuleMessage(sender, __message);
1341 }
1342 }
1343 //
1344 // Message sent by SPR / SPB / SPA type modules to declare their states
1345 // This message is forwarded to all connected SPT modules
1346 void CServerPatchManagerProxy::declareState(NLNET::IModule *sender, const NLMISC::CSString &state)
1347 {
1348 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
1349 {
1350 // immediate local synchronous dispatching
1351 _LocalModuleSkel->declareState(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), state);
1352 }
1353 else
1354 {
1355 // send the message for remote dispatching and execution or local queing
1356 NLNET::CMessage __message;
1357
1358 buildMessageFor_declareState(__message, state);
1359
1360 _ModuleProxy->sendModuleMessage(sender, __message);
1361 }
1362 }
1363 //
1364 // Message sent by SPT module to define a new named version
1365 void CServerPatchManagerProxy::declareVersionName(NLNET::IModule *sender, const NLMISC::CSString &versionName, uint32 clientVersion, uint32 serverVersion)
1366 {
1367 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
1368 {
1369 // immediate local synchronous dispatching
1370 _LocalModuleSkel->declareVersionName(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), versionName, clientVersion, serverVersion);
1371 }
1372 else
1373 {
1374 // send the message for remote dispatching and execution or local queing
1375 NLNET::CMessage __message;
1376
1377 buildMessageFor_declareVersionName(__message, versionName, clientVersion, serverVersion);
1378
1379 _ModuleProxy->sendModuleMessage(sender, __message);
1380 }
1381 }
1382 //
1383 // Message sent by SPT module to request execution of a command on one or more modules
1384 // Note that the 'target' parameter may be a wildcard
1385 void CServerPatchManagerProxy::executeCommandOnModules(NLNET::IModule *sender, const NLMISC::CSString &target, const NLMISC::CSString &commandline)
1386 {
1387 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
1388 {
1389 // immediate local synchronous dispatching
1390 _LocalModuleSkel->executeCommandOnModules(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), target, commandline);
1391 }
1392 else
1393 {
1394 // send the message for remote dispatching and execution or local queing
1395 NLNET::CMessage __message;
1396
1397 buildMessageFor_executeCommandOnModules(__message, target, commandline);
1398
1399 _ModuleProxy->sendModuleMessage(sender, __message);
1400 }
1401 }
1402 //
1403 // Message with result of command issuued via executeCommandOnSPA()
1404 void CServerPatchManagerProxy::executedCommandResult(NLNET::IModule *sender, const NLMISC::CSString &originator, const NLMISC::CSString &commandline, const NLMISC::CSString &result)
1405 {
1406 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
1407 {
1408 // immediate local synchronous dispatching
1409 _LocalModuleSkel->executedCommandResult(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), originator, commandline, result);
1410 }
1411 else
1412 {
1413 // send the message for remote dispatching and execution or local queing
1414 NLNET::CMessage __message;
1415
1416 buildMessageFor_executedCommandResult(__message, originator, commandline, result);
1417
1418 _ModuleProxy->sendModuleMessage(sender, __message);
1419 }
1420 }
1421
1422 // Message serializer. Return the message received in reference for easier integration
1423 const NLNET::CMessage &CServerPatchManagerProxy::buildMessageFor_registerAdministeredModule(NLNET::CMessage &__message, bool requireApplierUpdates, bool requireTerminalUpdates, bool requireDepCfgUpdates, bool isAdministered)
1424 {
1425 __message.setType("SPM_REGISTER");
1426 nlWrite(__message, serial, requireApplierUpdates);
1427 nlWrite(__message, serial, requireTerminalUpdates);
1428 nlWrite(__message, serial, requireDepCfgUpdates);
1429 nlWrite(__message, serial, isAdministered);
1430
1431
1432 return __message;
1433 }
1434
1435 // Message serializer. Return the message received in reference for easier integration
1436 const NLNET::CMessage &CServerPatchManagerProxy::buildMessageFor_requestRefresh(NLNET::CMessage &__message)
1437 {
1438 __message.setType("SPM_REFRESH");
1439
1440
1441 return __message;
1442 }
1443
1444 // Message serializer. Return the message received in reference for easier integration
1445 const NLNET::CMessage &CServerPatchManagerProxy::buildMessageFor_setInstallVersion(NLNET::CMessage &__message, const NLMISC::CSString &domain, uint32 version)
1446 {
1447 __message.setType("SPM_SETNEXT");
1448 nlWrite(__message, serial, const_cast < NLMISC::CSString& > (domain));
1449 nlWrite(__message, serial, version);
1450
1451
1452 return __message;
1453 }
1454
1455 // Message serializer. Return the message received in reference for easier integration
1456 const NLNET::CMessage &CServerPatchManagerProxy::buildMessageFor_setLaunchVersion(NLNET::CMessage &__message, const NLMISC::CSString &domain, uint32 version)
1457 {
1458 __message.setType("SPM_SETLIVE");
1459 nlWrite(__message, serial, const_cast < NLMISC::CSString& > (domain));
1460 nlWrite(__message, serial, version);
1461
1462
1463 return __message;
1464 }
1465
1466 // Message serializer. Return the message received in reference for easier integration
1467 const NLNET::CMessage &CServerPatchManagerProxy::buildMessageFor_declareState(NLNET::CMessage &__message, const NLMISC::CSString &state)
1468 {
1469 __message.setType("SPM_STATE");
1470 nlWrite(__message, serial, const_cast < NLMISC::CSString& > (state));
1471
1472
1473 return __message;
1474 }
1475
1476 // Message serializer. Return the message received in reference for easier integration
1477 const NLNET::CMessage &CServerPatchManagerProxy::buildMessageFor_declareVersionName(NLNET::CMessage &__message, const NLMISC::CSString &versionName, uint32 clientVersion, uint32 serverVersion)
1478 {
1479 __message.setType("SPM_VERSION_NAME");
1480 nlWrite(__message, serial, const_cast < NLMISC::CSString& > (versionName));
1481 nlWrite(__message, serial, clientVersion);
1482 nlWrite(__message, serial, serverVersion);
1483
1484
1485 return __message;
1486 }
1487
1488 // Message serializer. Return the message received in reference for easier integration
1489 const NLNET::CMessage &CServerPatchManagerProxy::buildMessageFor_executeCommandOnModules(NLNET::CMessage &__message, const NLMISC::CSString &target, const NLMISC::CSString &commandline)
1490 {
1491 __message.setType("SPM_EXEC");
1492 nlWrite(__message, serial, const_cast < NLMISC::CSString& > (target));
1493 nlWrite(__message, serial, const_cast < NLMISC::CSString& > (commandline));
1494
1495
1496 return __message;
1497 }
1498
1499 // Message serializer. Return the message received in reference for easier integration
1500 const NLNET::CMessage &CServerPatchManagerProxy::buildMessageFor_executedCommandResult(NLNET::CMessage &__message, const NLMISC::CSString &originator, const NLMISC::CSString &commandline, const NLMISC::CSString &result)
1501 {
1502 __message.setType("SPM_EXEC_RESULT");
1503 nlWrite(__message, serial, const_cast < NLMISC::CSString& > (originator));
1504 nlWrite(__message, serial, const_cast < NLMISC::CSString& > (commandline));
1505 nlWrite(__message, serial, const_cast < NLMISC::CSString& > (result));
1506
1507
1508 return __message;
1509 }
1510
1511 /////////////////////////////////////////////////////////////////
1512 // WARNING : this is a generated file, don't change it !
1513 /////////////////////////////////////////////////////////////////
1514
1515
1516 const CDeploymentConfigurationSynchroniserSkel::TMessageHandlerMap &CDeploymentConfigurationSynchroniserSkel::getMessageHandlers() const
1517 {
1518 static TMessageHandlerMap handlers;
1519 static bool init = false;
1520
1521 if (!init)
1522 {
1523 std::pair < TMessageHandlerMap::iterator, bool > res;
1524
1525 res = handlers.insert(std::make_pair(std::string("DEPCFG_REQUEST"), &CDeploymentConfigurationSynchroniserSkel::requestSync_skel));
1526 // if this assert, you have a doubly message name in your interface definition !
1527 nlassert(res.second);
1528
1529 res = handlers.insert(std::make_pair(std::string("DEPCFG_SYNC"), &CDeploymentConfigurationSynchroniserSkel::sync_skel));
1530 // if this assert, you have a doubly message name in your interface definition !
1531 nlassert(res.second);
1532
1533 init = true;
1534 }
1535
1536 return handlers;
1537 }
1538 bool CDeploymentConfigurationSynchroniserSkel::fwdOnProcessModuleMessage(NLNET::IModuleProxy *sender, const NLNET::CMessage &message)
1539 {
1540 const TMessageHandlerMap &mh = getMessageHandlers();
1541
1542 TMessageHandlerMap::const_iterator it(mh.find(message.getName()));
1543
1544 if (it == mh.end())
1545 {
1546 return false;
1547 }
1548
1549 TMessageHandler cmd = it->second;
1550 (this->*cmd)(sender, message);
1551
1552 return true;
1553 }
1554
1555
1556 void CDeploymentConfigurationSynchroniserSkel::requestSync_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
1557 {
1558 H_AUTO(CDeploymentConfigurationSynchroniserSkel_requestSync_DEPCFG_REQUEST);
1559 requestSync(sender);
1560 }
1561
1562 void CDeploymentConfigurationSynchroniserSkel::sync_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
1563 {
1564 H_AUTO(CDeploymentConfigurationSynchroniserSkel_sync_DEPCFG_SYNC);
1565 NLNET::TBinBuffer dataBlob;
1566 nlRead(__message, serial, dataBlob);
1567 sync(sender, dataBlob);
1568 }
1569 //
1570 // Request for a copy of another module's CDeploymentConfiguration singleton
1571 void CDeploymentConfigurationSynchroniserProxy::requestSync(NLNET::IModule *sender)
1572 {
1573 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
1574 {
1575 // immediate local synchronous dispatching
1576 _LocalModuleSkel->requestSync(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender));
1577 }
1578 else
1579 {
1580 // send the message for remote dispatching and execution or local queing
1581 NLNET::CMessage __message;
1582
1583 buildMessageFor_requestSync(__message);
1584
1585 _ModuleProxy->sendModuleMessage(sender, __message);
1586 }
1587 }
1588 //
1589 // A copy of the data from the CDeploymentConfiguration singleton
1590 void CDeploymentConfigurationSynchroniserProxy::sync(NLNET::IModule *sender, const NLNET::TBinBuffer &dataBlob)
1591 {
1592 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
1593 {
1594 // immediate local synchronous dispatching
1595 _LocalModuleSkel->sync(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), dataBlob);
1596 }
1597 else
1598 {
1599 // send the message for remote dispatching and execution or local queing
1600 NLNET::CMessage __message;
1601
1602 buildMessageFor_sync(__message, dataBlob);
1603
1604 _ModuleProxy->sendModuleMessage(sender, __message);
1605 }
1606 }
1607
1608 // Message serializer. Return the message received in reference for easier integration
1609 const NLNET::CMessage &CDeploymentConfigurationSynchroniserProxy::buildMessageFor_requestSync(NLNET::CMessage &__message)
1610 {
1611 __message.setType("DEPCFG_REQUEST");
1612
1613
1614 return __message;
1615 }
1616
1617 // Message serializer. Return the message received in reference for easier integration
1618 const NLNET::CMessage &CDeploymentConfigurationSynchroniserProxy::buildMessageFor_sync(NLNET::CMessage &__message, const NLNET::TBinBuffer &dataBlob)
1619 {
1620 __message.setType("DEPCFG_SYNC");
1621 nlWrite(__message, serial, const_cast < NLNET::TBinBuffer& > (dataBlob));
1622
1623
1624 return __message;
1625 }
1626
1627 }