ryzom/server/src/patchman_service/module_admin_itf.cpp

   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 }