ryzom/server/src/patchman_service/module_admin_itf.h

   1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This program is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU Affero General Public License as
   6 // published by the Free Software Foundation, either version 3 of the
   7 // License, or (at your option) any later version.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU Affero General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Affero General Public License
  15 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 /////////////////////////////////////////////////////////////////
  18 // WARNING : this is a generated file, don't change it !
  19 /////////////////////////////////////////////////////////////////
  20
  21 #ifndef MODULE_ADMIN_ITF_H
  22 #define MODULE_ADMIN_ITF_H
  23 #include "nel/misc/types_nl.h"
  24 #ifdef NL_COMP_VC8
  25   #include <memory>
  26 #endif
  27 #include "nel/misc/hierarchical_timer.h"
  28 #include "nel/misc/string_conversion.h"
  29 #include "nel/net/message.h"
  30 #include "nel/net/module.h"
  31 #include "nel/net/module_builder_parts.h"
  32 #include "nel/net/module_message.h"
  33 #include "nel/net/module_gateway.h"
  34
  35 #include "nel/misc/sstring.h"
  36
  37 #include "nel/misc/md5.h"
  38
  39 #include "nel/net/module_message.h"
  40
  41 #include "server_patch_types.h"
  42
  43 #include "file_manager.h"
  44
  45 namespace PATCHMAN
  46 {
  47
  48
  49         /////////////////////////////////////////////////////////////////
  50         // WARNING : this is a generated file, don't change it !
  51         /////////////////////////////////////////////////////////////////
  52         class CFileReceiverSkel
  53         {
  54         public:
  55                 /// the interceptor type
  56                 typedef NLNET::CInterceptorForwarder < CFileReceiverSkel>       TInterceptor;
  57         protected:
  58                 CFileReceiverSkel()
  59                 {
  60                         // do early run time check for message table
  61                         getMessageHandlers();
  62                 }
  63                 virtual ~CFileReceiverSkel()
  64                 {
  65                 }
  66
  67                 void init(NLNET::IModule *module)
  68                 {
  69                         _Interceptor.init(this, module);
  70                 }
  71
  72                 // unused interceptors
  73                 std::string                     fwdBuildModuleManifest() const  { return std::string(); }
  74                 void                            fwdOnModuleUp(NLNET::IModuleProxy *moduleProxy)  {}
  75                 void                            fwdOnModuleDown(NLNET::IModuleProxy *moduleProxy) {}
  76                 void                            fwdOnModuleSecurityChange(NLNET::IModuleProxy *moduleProxy) {}
  77
  78                 // process module message interceptor
  79                 bool fwdOnProcessModuleMessage(NLNET::IModuleProxy *sender, const NLNET::CMessage &message);
  80         private:
  81
  82                 typedef void (CFileReceiverSkel::*TMessageHandler)(NLNET::IModuleProxy *sender, const NLNET::CMessage &message);
  83                 typedef std::map<std::string, TMessageHandler>  TMessageHandlerMap;
  84
  85                 const TMessageHandlerMap &getMessageHandlers() const;
  86
  87
  88                 void setupSubscriptions_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
  89
  90                 void cbFileInfo_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
  91
  92                 void cbFileData_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
  93
  94                 void cbFileDataFailure_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
  95
  96                 // declare one interceptor member of the skeleton
  97                 TInterceptor    _Interceptor;
  98
  99                 // declare the interceptor forwarder as friend of this class
 100                 friend          class NLNET::CInterceptorForwarder < CFileReceiverSkel>;
 101         public:
 102                 /////////////////////////////////////////////////////////////////
 103                 // WARNING : this is a generated file, don't change it !
 104                 /////////////////////////////////////////////////////////////////
 105
 106                 //
 107                 virtual void setupSubscriptions(NLNET::IModuleProxy *sender) =0;
 108                 //
 109                 virtual void cbFileInfo(NLNET::IModuleProxy *sender, const TFileInfoVector &files) =0;
 110                 //
 111                 virtual void cbFileData(NLNET::IModuleProxy *sender, const std::string &fileName, uint32 startOffset, const NLNET::TBinBuffer &data) =0;
 112                 //
 113                 virtual void cbFileDataFailure(NLNET::IModuleProxy *sender, const std::string &fileName) =0;
 114
 115
 116         };
 117
 118         /////////////////////////////////////////////////////////////////
 119         // WARNING : this is a generated file, don't change it !
 120         /////////////////////////////////////////////////////////////////
 121         class CFileReceiverProxy
 122         {
 123                 /// Smart pointer on the module proxy
 124                 NLNET::TModuleProxyPtr  _ModuleProxy;
 125
 126                 // Pointer on the local module that implement the interface (if the proxy is for a local module)
 127                 NLNET::TModulePtr                                       _LocalModule;
 128                 // Direct pointer on the server implementation interface for collocated module
 129                 CFileReceiverSkel       *_LocalModuleSkel;
 130
 131
 132         public:
 133                 CFileReceiverProxy(NLNET::IModuleProxy *proxy)
 134                 {
 135
 136                         _ModuleProxy = proxy;
 137
 138                         // initialize collocated servant interface
 139                         if (proxy->getModuleDistance() == 0)
 140                         {
 141                                 _LocalModule = proxy->getLocalModule();
 142                                 nlassert(_LocalModule != NULL);
 143                                 CFileReceiverSkel::TInterceptor *interceptor = NULL;
 144                                 interceptor = static_cast < NLNET::CModuleBase* >(_LocalModule.getPtr())->getInterceptor(interceptor);
 145                                 nlassert(interceptor != NULL);
 146
 147                                 _LocalModuleSkel = interceptor->getParent();
 148                                 nlassert(_LocalModuleSkel != NULL);
 149                         }
 150                         else
 151                                 _LocalModuleSkel = 0;
 152
 153                 }
 154                 virtual ~CFileReceiverProxy()
 155                 {
 156                 }
 157
 158                 NLNET::IModuleProxy *getModuleProxy()
 159                 {
 160                         return _ModuleProxy;
 161                 }
 162
 163                 //
 164                 void setupSubscriptions(NLNET::IModule *sender);
 165                 //
 166                 void cbFileInfo(NLNET::IModule *sender, const TFileInfoVector &files);
 167                 //
 168                 void cbFileData(NLNET::IModule *sender, const std::string &fileName, uint32 startOffset, const NLNET::TBinBuffer &data);
 169                 //
 170                 void cbFileDataFailure(NLNET::IModule *sender, const std::string &fileName);
 171
 172                 // Message serializer. Return the message received in reference for easier integration
 173                 static const NLNET::CMessage &buildMessageFor_setupSubscriptions(NLNET::CMessage &__message);
 174
 175                 // Message serializer. Return the message received in reference for easier integration
 176                 static const NLNET::CMessage &buildMessageFor_cbFileInfo(NLNET::CMessage &__message, const TFileInfoVector &files);
 177
 178                 // Message serializer. Return the message received in reference for easier integration
 179                 static const NLNET::CMessage &buildMessageFor_cbFileData(NLNET::CMessage &__message, const std::string &fileName, uint32 startOffset, const NLNET::TBinBuffer &data);
 180
 181                 // Message serializer. Return the message received in reference for easier integration
 182                 static const NLNET::CMessage &buildMessageFor_cbFileDataFailure(NLNET::CMessage &__message, const std::string &fileName);
 183
 184
 185
 186
 187         };
 188
 189         /////////////////////////////////////////////////////////////////
 190         // WARNING : this is a generated file, don't change it !
 191         /////////////////////////////////////////////////////////////////
 192         class CFileRepositorySkel
 193         {
 194         public:
 195                 /// the interceptor type
 196                 typedef NLNET::CInterceptorForwarder < CFileRepositorySkel>     TInterceptor;
 197         protected:
 198                 CFileRepositorySkel()
 199                 {
 200                         // do early run time check for message table
 201                         getMessageHandlers();
 202                 }
 203                 virtual ~CFileRepositorySkel()
 204                 {
 205                 }
 206
 207                 void init(NLNET::IModule *module)
 208                 {
 209                         _Interceptor.init(this, module);
 210                 }
 211
 212                 // unused interceptors
 213                 std::string                     fwdBuildModuleManifest() const  { return std::string(); }
 214                 void                            fwdOnModuleUp(NLNET::IModuleProxy *moduleProxy)  {}
 215                 void                            fwdOnModuleDown(NLNET::IModuleProxy *moduleProxy) {}
 216                 void                            fwdOnModuleSecurityChange(NLNET::IModuleProxy *moduleProxy) {}
 217
 218                 // process module message interceptor
 219                 bool fwdOnProcessModuleMessage(NLNET::IModuleProxy *sender, const NLNET::CMessage &message);
 220         private:
 221
 222                 typedef void (CFileRepositorySkel::*TMessageHandler)(NLNET::IModuleProxy *sender, const NLNET::CMessage &message);
 223                 typedef std::map<std::string, TMessageHandler>  TMessageHandlerMap;
 224
 225                 const TMessageHandlerMap &getMessageHandlers() const;
 226
 227
 228                 void requestFileInfo_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
 229
 230                 void requestFileData_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
 231
 232                 void getInfo_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
 233
 234                 void subscribe_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
 235
 236                 void unsubscribe_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
 237
 238                 void unsubscribeAll_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
 239
 240                 // declare one interceptor member of the skeleton
 241                 TInterceptor    _Interceptor;
 242
 243                 // declare the interceptor forwarder as friend of this class
 244                 friend          class NLNET::CInterceptorForwarder < CFileRepositorySkel>;
 245         public:
 246                 /////////////////////////////////////////////////////////////////
 247                 // WARNING : this is a generated file, don't change it !
 248                 /////////////////////////////////////////////////////////////////
 249
 250                 // Request info concerning a particular file
 251                 virtual void requestFileInfo(NLNET::IModuleProxy *sender, const NLMISC::CSString &fileName) =0;
 252                 // Request a data block for a particular file
 253                 virtual void requestFileData(NLNET::IModuleProxy *sender, const NLMISC::CSString &fileName, uint32 startOffset, uint32 numBytes) =0;
 254                 // Ask for the info concerning files matching given filespec
 255                 virtual void getInfo(NLNET::IModuleProxy *sender, const NLMISC::CSString &fileSpec) =0;
 256                 // Ask for the info concerning files matching given filespec to be forwarded to me now
 257                 // and for updates to be sent to me as they are generated
 258                 virtual void subscribe(NLNET::IModuleProxy *sender, const NLMISC::CSString &fileSpec) =0;
 259                 // Cancel subscription for given filespec
 260                 virtual void unsubscribe(NLNET::IModuleProxy *sender, const NLMISC::CSString &fileSpec) =0;
 261                 // Cancel all subscriptions for given filespec
 262                 virtual void unsubscribeAll(NLNET::IModuleProxy *sender) =0;
 263
 264
 265         };
 266
 267         /////////////////////////////////////////////////////////////////
 268         // WARNING : this is a generated file, don't change it !
 269         /////////////////////////////////////////////////////////////////
 270         class CFileRepositoryProxy
 271         {
 272                 /// Smart pointer on the module proxy
 273                 NLNET::TModuleProxyPtr  _ModuleProxy;
 274
 275                 // Pointer on the local module that implement the interface (if the proxy is for a local module)
 276                 NLNET::TModulePtr                                       _LocalModule;
 277                 // Direct pointer on the server implementation interface for collocated module
 278                 CFileRepositorySkel     *_LocalModuleSkel;
 279
 280
 281         public:
 282                 CFileRepositoryProxy(NLNET::IModuleProxy *proxy)
 283                 {
 284
 285                         _ModuleProxy = proxy;
 286
 287                         // initialize collocated servant interface
 288                         if (proxy->getModuleDistance() == 0)
 289                         {
 290                                 _LocalModule = proxy->getLocalModule();
 291                                 nlassert(_LocalModule != NULL);
 292                                 CFileRepositorySkel::TInterceptor *interceptor = NULL;
 293                                 interceptor = static_cast < NLNET::CModuleBase* >(_LocalModule.getPtr())->getInterceptor(interceptor);
 294                                 nlassert(interceptor != NULL);
 295
 296                                 _LocalModuleSkel = interceptor->getParent();
 297                                 nlassert(_LocalModuleSkel != NULL);
 298                         }
 299                         else
 300                                 _LocalModuleSkel = 0;
 301
 302                 }
 303                 virtual ~CFileRepositoryProxy()
 304                 {
 305                 }
 306
 307                 NLNET::IModuleProxy *getModuleProxy()
 308                 {
 309                         return _ModuleProxy;
 310                 }
 311
 312                 // Request info concerning a particular file
 313                 void requestFileInfo(NLNET::IModule *sender, const NLMISC::CSString &fileName);
 314                 // Request a data block for a particular file
 315                 void requestFileData(NLNET::IModule *sender, const NLMISC::CSString &fileName, uint32 startOffset, uint32 numBytes);
 316                 // Ask for the info concerning files matching given filespec
 317                 void getInfo(NLNET::IModule *sender, const NLMISC::CSString &fileSpec);
 318                 // Ask for the info concerning files matching given filespec to be forwarded to me now
 319                 // and for updates to be sent to me as they are generated
 320                 void subscribe(NLNET::IModule *sender, const NLMISC::CSString &fileSpec);
 321                 // Cancel subscription for given filespec
 322                 void unsubscribe(NLNET::IModule *sender, const NLMISC::CSString &fileSpec);
 323                 // Cancel all subscriptions for given filespec
 324                 void unsubscribeAll(NLNET::IModule *sender);
 325
 326                 // Message serializer. Return the message received in reference for easier integration
 327                 static const NLNET::CMessage &buildMessageFor_requestFileInfo(NLNET::CMessage &__message, const NLMISC::CSString &fileName);
 328
 329                 // Message serializer. Return the message received in reference for easier integration
 330                 static const NLNET::CMessage &buildMessageFor_requestFileData(NLNET::CMessage &__message, const NLMISC::CSString &fileName, uint32 startOffset, uint32 numBytes);
 331
 332                 // Message serializer. Return the message received in reference for easier integration
 333                 static const NLNET::CMessage &buildMessageFor_getInfo(NLNET::CMessage &__message, const NLMISC::CSString &fileSpec);
 334
 335                 // Message serializer. Return the message received in reference for easier integration
 336                 static const NLNET::CMessage &buildMessageFor_subscribe(NLNET::CMessage &__message, const NLMISC::CSString &fileSpec);
 337
 338                 // Message serializer. Return the message received in reference for easier integration
 339                 static const NLNET::CMessage &buildMessageFor_unsubscribe(NLNET::CMessage &__message, const NLMISC::CSString &fileSpec);
 340
 341                 // Message serializer. Return the message received in reference for easier integration
 342                 static const NLNET::CMessage &buildMessageFor_unsubscribeAll(NLNET::CMessage &__message);
 343
 344
 345
 346
 347         };
 348
 349         /////////////////////////////////////////////////////////////////
 350         // WARNING : this is a generated file, don't change it !
 351         /////////////////////////////////////////////////////////////////
 352         class CAdministeredModuleBaseSkel
 353         {
 354         public:
 355                 /// the interceptor type
 356                 typedef NLNET::CInterceptorForwarder < CAdministeredModuleBaseSkel>     TInterceptor;
 357         protected:
 358                 CAdministeredModuleBaseSkel()
 359                 {
 360                         // do early run time check for message table
 361                         getMessageHandlers();
 362                 }
 363                 virtual ~CAdministeredModuleBaseSkel()
 364                 {
 365                 }
 366
 367                 void init(NLNET::IModule *module)
 368                 {
 369                         _Interceptor.init(this, module);
 370                 }
 371
 372                 // unused interceptors
 373                 std::string                     fwdBuildModuleManifest() const  { return std::string(); }
 374                 void                            fwdOnModuleUp(NLNET::IModuleProxy *moduleProxy)  {}
 375                 void                            fwdOnModuleDown(NLNET::IModuleProxy *moduleProxy) {}
 376                 void                            fwdOnModuleSecurityChange(NLNET::IModuleProxy *moduleProxy) {}
 377
 378                 // process module message interceptor
 379                 bool fwdOnProcessModuleMessage(NLNET::IModuleProxy *sender, const NLNET::CMessage &message);
 380         private:
 381
 382                 typedef void (CAdministeredModuleBaseSkel::*TMessageHandler)(NLNET::IModuleProxy *sender, const NLNET::CMessage &message);
 383                 typedef std::map<std::string, TMessageHandler>  TMessageHandlerMap;
 384
 385                 const TMessageHandlerMap &getMessageHandlers() const;
 386
 387
 388                 void executeCommand_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
 389
 390                 void installVersion_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
 391
 392                 void launchVersion_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
 393
 394                 // declare one interceptor member of the skeleton
 395                 TInterceptor    _Interceptor;
 396
 397                 // declare the interceptor forwarder as friend of this class
 398                 friend          class NLNET::CInterceptorForwarder < CAdministeredModuleBaseSkel>;
 399         public:
 400                 /////////////////////////////////////////////////////////////////
 401                 // WARNING : this is a generated file, don't change it !
 402                 /////////////////////////////////////////////////////////////////
 403
 404                 //
 405                 // Message sent by SPM module to request execution of a command
 406                 virtual void executeCommand(NLNET::IModuleProxy *sender, const NLMISC::CSString &originator, const NLMISC::CSString &cmdline) =0;
 407                 //
 408                 virtual void installVersion(NLNET::IModuleProxy *sender, const NLMISC::CSString &domainName, uint32 version) =0;
 409                 //
 410                 virtual void launchVersion(NLNET::IModuleProxy *sender, const NLMISC::CSString &domainName, uint32 version) =0;
 411
 412
 413         };
 414
 415         /////////////////////////////////////////////////////////////////
 416         // WARNING : this is a generated file, don't change it !
 417         /////////////////////////////////////////////////////////////////
 418         class CAdministeredModuleBaseProxy
 419         {
 420                 /// Smart pointer on the module proxy
 421                 NLNET::TModuleProxyPtr  _ModuleProxy;
 422
 423                 // Pointer on the local module that implement the interface (if the proxy is for a local module)
 424                 NLNET::TModulePtr                                       _LocalModule;
 425                 // Direct pointer on the server implementation interface for collocated module
 426                 CAdministeredModuleBaseSkel     *_LocalModuleSkel;
 427
 428
 429         public:
 430                 CAdministeredModuleBaseProxy(NLNET::IModuleProxy *proxy)
 431                 {
 432
 433                         _ModuleProxy = proxy;
 434
 435                         // initialize collocated servant interface
 436                         if (proxy->getModuleDistance() == 0)
 437                         {
 438                                 _LocalModule = proxy->getLocalModule();
 439                                 nlassert(_LocalModule != NULL);
 440                                 CAdministeredModuleBaseSkel::TInterceptor *interceptor = NULL;
 441                                 interceptor = static_cast < NLNET::CModuleBase* >(_LocalModule.getPtr())->getInterceptor(interceptor);
 442                                 nlassert(interceptor != NULL);
 443
 444                                 _LocalModuleSkel = interceptor->getParent();
 445                                 nlassert(_LocalModuleSkel != NULL);
 446                         }
 447                         else
 448                                 _LocalModuleSkel = 0;
 449
 450                 }
 451                 virtual ~CAdministeredModuleBaseProxy()
 452                 {
 453                 }
 454
 455                 NLNET::IModuleProxy *getModuleProxy()
 456                 {
 457                         return _ModuleProxy;
 458                 }
 459
 460                 //
 461                 // Message sent by SPM module to request execution of a command
 462                 void executeCommand(NLNET::IModule *sender, const NLMISC::CSString &originator, const NLMISC::CSString &cmdline);
 463                 //
 464                 void installVersion(NLNET::IModule *sender, const NLMISC::CSString &domainName, uint32 version);
 465                 //
 466                 void launchVersion(NLNET::IModule *sender, const NLMISC::CSString &domainName, uint32 version);
 467
 468                 // Message serializer. Return the message received in reference for easier integration
 469                 static const NLNET::CMessage &buildMessageFor_executeCommand(NLNET::CMessage &__message, const NLMISC::CSString &originator, const NLMISC::CSString &cmdline);
 470
 471                 // Message serializer. Return the message received in reference for easier integration
 472                 static const NLNET::CMessage &buildMessageFor_installVersion(NLNET::CMessage &__message, const NLMISC::CSString &domainName, uint32 version);
 473
 474                 // Message serializer. Return the message received in reference for easier integration
 475                 static const NLNET::CMessage &buildMessageFor_launchVersion(NLNET::CMessage &__message, const NLMISC::CSString &domainName, uint32 version);
 476
 477
 478
 479
 480         };
 481
 482         /////////////////////////////////////////////////////////////////
 483         // WARNING : this is a generated file, don't change it !
 484         /////////////////////////////////////////////////////////////////
 485         class CServerPatchTerminalSkel
 486         {
 487         public:
 488                 /// the interceptor type
 489                 typedef NLNET::CInterceptorForwarder < CServerPatchTerminalSkel>        TInterceptor;
 490         protected:
 491                 CServerPatchTerminalSkel()
 492                 {
 493                         // do early run time check for message table
 494                         getMessageHandlers();
 495                 }
 496                 virtual ~CServerPatchTerminalSkel()
 497                 {
 498                 }
 499
 500                 void init(NLNET::IModule *module)
 501                 {
 502                         _Interceptor.init(this, module);
 503                 }
 504
 505                 // unused interceptors
 506                 std::string                     fwdBuildModuleManifest() const  { return std::string(); }
 507                 void                            fwdOnModuleUp(NLNET::IModuleProxy *moduleProxy)  {}
 508                 void                            fwdOnModuleDown(NLNET::IModuleProxy *moduleProxy) {}
 509                 void                            fwdOnModuleSecurityChange(NLNET::IModuleProxy *moduleProxy) {}
 510
 511                 // process module message interceptor
 512                 bool fwdOnProcessModuleMessage(NLNET::IModuleProxy *sender, const NLNET::CMessage &message);
 513         private:
 514
 515                 typedef void (CServerPatchTerminalSkel::*TMessageHandler)(NLNET::IModuleProxy *sender, const NLNET::CMessage &message);
 516                 typedef std::map<std::string, TMessageHandler>  TMessageHandlerMap;
 517
 518                 const TMessageHandlerMap &getMessageHandlers() const;
 519
 520
 521                 void declareState_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
 522
 523                 void declareModuleDown_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
 524
 525                 void declareVersionName_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
 526
 527                 void declareDomainInfo_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
 528
 529                 void ackVersionChange_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
 530
 531                 void setInstallVersion_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
 532
 533                 void setLaunchVersion_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
 534
 535                 void executedCommandAck_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
 536
 537                 void executedCommandResult_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
 538
 539                 // declare one interceptor member of the skeleton
 540                 TInterceptor    _Interceptor;
 541
 542                 // declare the interceptor forwarder as friend of this class
 543                 friend          class NLNET::CInterceptorForwarder < CServerPatchTerminalSkel>;
 544         public:
 545                 /////////////////////////////////////////////////////////////////
 546                 // WARNING : this is a generated file, don't change it !
 547                 /////////////////////////////////////////////////////////////////
 548
 549                 //
 550                 // Message sent by SPM module to declare the state of a named module
 551                 // This message is sent by the SPM for each connected SP / RE / RR type module on connection of SPT to SPM
 552                 // This message is also sent by the SPM for each type the SPM receives a state update from a SP / RE / RR type module
 553                 virtual void declareState(NLNET::IModuleProxy *sender, const NLMISC::CSString &moduleName, const NLMISC::CSString &state) =0;
 554                 //
 555                 // Message sent by SPM module to declare module down for a connected SPA / SPR / SPB type module
 556                 virtual void declareModuleDown(NLNET::IModuleProxy *sender, const NLMISC::CSString &moduleName) =0;
 557                 //
 558                 // Message sent by SPM module to define a named version
 559                 virtual void declareVersionName(NLNET::IModuleProxy *sender, const NLMISC::CSString &versionName, uint32 clientVersion, uint32 serverVersion) =0;
 560                 //
 561                 // Message sent by SPM module to give info on a named domain
 562                 virtual void declareDomainInfo(NLNET::IModuleProxy *sender, const NLMISC::CSString &domainName, uint32 installVersion, uint32 launchVersion) =0;
 563                 //
 564                 // Message sent by SPM module to acknowledge a version change attempt
 565                 virtual void ackVersionChange(NLNET::IModuleProxy *sender, const NLMISC::CSString &domainName, bool success, const NLMISC::CSString &comment) =0;
 566                 //
 567                 // Message sent by SPM to inform us of the current installed version for a given domain
 568                 virtual void setInstallVersion(NLNET::IModuleProxy *sender, const NLMISC::CSString &domain, uint32 version) =0;
 569                 //
 570                 // Message sent by SPM to inform us of the current live version for a given domain
 571                 virtual void setLaunchVersion(NLNET::IModuleProxy *sender, const NLMISC::CSString &domain, uint32 version) =0;
 572                 //
 573                 // Message sent by SPM with result of command issuued via executeCommandOnModules()
 574                 virtual void executedCommandAck(NLNET::IModuleProxy *sender, const NLMISC::CSString &result) =0;
 575                 //
 576                 // Message sent by SPM with result of command issuued via executeCommandOnModules()
 577                 virtual void executedCommandResult(NLNET::IModuleProxy *sender, const NLMISC::CSString &originator, const NLMISC::CSString &commandline, const NLMISC::CSString &result) =0;
 578
 579
 580         };
 581
 582         /////////////////////////////////////////////////////////////////
 583         // WARNING : this is a generated file, don't change it !
 584         /////////////////////////////////////////////////////////////////
 585         class CServerPatchTerminalProxy
 586         {
 587                 /// Smart pointer on the module proxy
 588                 NLNET::TModuleProxyPtr  _ModuleProxy;
 589
 590                 // Pointer on the local module that implement the interface (if the proxy is for a local module)
 591                 NLNET::TModulePtr                                       _LocalModule;
 592                 // Direct pointer on the server implementation interface for collocated module
 593                 CServerPatchTerminalSkel        *_LocalModuleSkel;
 594
 595
 596         public:
 597                 CServerPatchTerminalProxy(NLNET::IModuleProxy *proxy)
 598                 {
 599
 600                         _ModuleProxy = proxy;
 601
 602                         // initialize collocated servant interface
 603                         if (proxy->getModuleDistance() == 0)
 604                         {
 605                                 _LocalModule = proxy->getLocalModule();
 606                                 nlassert(_LocalModule != NULL);
 607                                 CServerPatchTerminalSkel::TInterceptor *interceptor = NULL;
 608                                 interceptor = static_cast < NLNET::CModuleBase* >(_LocalModule.getPtr())->getInterceptor(interceptor);
 609                                 nlassert(interceptor != NULL);
 610
 611                                 _LocalModuleSkel = interceptor->getParent();
 612                                 nlassert(_LocalModuleSkel != NULL);
 613                         }
 614                         else
 615                                 _LocalModuleSkel = 0;
 616
 617                 }
 618                 virtual ~CServerPatchTerminalProxy()
 619                 {
 620                 }
 621
 622                 NLNET::IModuleProxy *getModuleProxy()
 623                 {
 624                         return _ModuleProxy;
 625                 }
 626
 627                 //
 628                 // Message sent by SPM module to declare the state of a named module
 629                 // This message is sent by the SPM for each connected SP / RE / RR type module on connection of SPT to SPM
 630                 // This message is also sent by the SPM for each type the SPM receives a state update from a SP / RE / RR type module
 631                 void declareState(NLNET::IModule *sender, const NLMISC::CSString &moduleName, const NLMISC::CSString &state);
 632                 //
 633                 // Message sent by SPM module to declare module down for a connected SPA / SPR / SPB type module
 634                 void declareModuleDown(NLNET::IModule *sender, const NLMISC::CSString &moduleName);
 635                 //
 636                 // Message sent by SPM module to define a named version
 637                 void declareVersionName(NLNET::IModule *sender, const NLMISC::CSString &versionName, uint32 clientVersion, uint32 serverVersion);
 638                 //
 639                 // Message sent by SPM module to give info on a named domain
 640                 void declareDomainInfo(NLNET::IModule *sender, const NLMISC::CSString &domainName, uint32 installVersion, uint32 launchVersion);
 641                 //
 642                 // Message sent by SPM module to acknowledge a version change attempt
 643                 void ackVersionChange(NLNET::IModule *sender, const NLMISC::CSString &domainName, bool success, const NLMISC::CSString &comment);
 644                 //
 645                 // Message sent by SPM to inform us of the current installed version for a given domain
 646                 void setInstallVersion(NLNET::IModule *sender, const NLMISC::CSString &domain, uint32 version);
 647                 //
 648                 // Message sent by SPM to inform us of the current live version for a given domain
 649                 void setLaunchVersion(NLNET::IModule *sender, const NLMISC::CSString &domain, uint32 version);
 650                 //
 651                 // Message sent by SPM with result of command issuued via executeCommandOnModules()
 652                 void executedCommandAck(NLNET::IModule *sender, const NLMISC::CSString &result);
 653                 //
 654                 // Message sent by SPM with result of command issuued via executeCommandOnModules()
 655                 void executedCommandResult(NLNET::IModule *sender, const NLMISC::CSString &originator, const NLMISC::CSString &commandline, const NLMISC::CSString &result);
 656
 657                 // Message serializer. Return the message received in reference for easier integration
 658                 static const NLNET::CMessage &buildMessageFor_declareState(NLNET::CMessage &__message, const NLMISC::CSString &moduleName, const NLMISC::CSString &state);
 659
 660                 // Message serializer. Return the message received in reference for easier integration
 661                 static const NLNET::CMessage &buildMessageFor_declareModuleDown(NLNET::CMessage &__message, const NLMISC::CSString &moduleName);
 662
 663                 // Message serializer. Return the message received in reference for easier integration
 664                 static const NLNET::CMessage &buildMessageFor_declareVersionName(NLNET::CMessage &__message, const NLMISC::CSString &versionName, uint32 clientVersion, uint32 serverVersion);
 665
 666                 // Message serializer. Return the message received in reference for easier integration
 667                 static const NLNET::CMessage &buildMessageFor_declareDomainInfo(NLNET::CMessage &__message, const NLMISC::CSString &domainName, uint32 installVersion, uint32 launchVersion);
 668
 669                 // Message serializer. Return the message received in reference for easier integration
 670                 static const NLNET::CMessage &buildMessageFor_ackVersionChange(NLNET::CMessage &__message, const NLMISC::CSString &domainName, bool success, const NLMISC::CSString &comment);
 671
 672                 // Message serializer. Return the message received in reference for easier integration
 673                 static const NLNET::CMessage &buildMessageFor_setInstallVersion(NLNET::CMessage &__message, const NLMISC::CSString &domain, uint32 version);
 674
 675                 // Message serializer. Return the message received in reference for easier integration
 676                 static const NLNET::CMessage &buildMessageFor_setLaunchVersion(NLNET::CMessage &__message, const NLMISC::CSString &domain, uint32 version);
 677
 678                 // Message serializer. Return the message received in reference for easier integration
 679                 static const NLNET::CMessage &buildMessageFor_executedCommandAck(NLNET::CMessage &__message, const NLMISC::CSString &result);
 680
 681                 // Message serializer. Return the message received in reference for easier integration
 682                 static const NLNET::CMessage &buildMessageFor_executedCommandResult(NLNET::CMessage &__message, const NLMISC::CSString &originator, const NLMISC::CSString &commandline, const NLMISC::CSString &result);
 683
 684
 685
 686
 687         };
 688
 689         /////////////////////////////////////////////////////////////////
 690         // WARNING : this is a generated file, don't change it !
 691         /////////////////////////////////////////////////////////////////
 692         class CServerPatchManagerSkel
 693         {
 694         public:
 695                 /// the interceptor type
 696                 typedef NLNET::CInterceptorForwarder < CServerPatchManagerSkel> TInterceptor;
 697         protected:
 698                 CServerPatchManagerSkel()
 699                 {
 700                         // do early run time check for message table
 701                         getMessageHandlers();
 702                 }
 703                 virtual ~CServerPatchManagerSkel()
 704                 {
 705                 }
 706
 707                 void init(NLNET::IModule *module)
 708                 {
 709                         _Interceptor.init(this, module);
 710                 }
 711
 712                 // unused interceptors
 713                 std::string                     fwdBuildModuleManifest() const  { return std::string(); }
 714                 void                            fwdOnModuleUp(NLNET::IModuleProxy *moduleProxy)  {}
 715                 void                            fwdOnModuleDown(NLNET::IModuleProxy *moduleProxy) {}
 716                 void                            fwdOnModuleSecurityChange(NLNET::IModuleProxy *moduleProxy) {}
 717
 718                 // process module message interceptor
 719                 bool fwdOnProcessModuleMessage(NLNET::IModuleProxy *sender, const NLNET::CMessage &message);
 720         private:
 721
 722                 typedef void (CServerPatchManagerSkel::*TMessageHandler)(NLNET::IModuleProxy *sender, const NLNET::CMessage &message);
 723                 typedef std::map<std::string, TMessageHandler>  TMessageHandlerMap;
 724
 725                 const TMessageHandlerMap &getMessageHandlers() const;
 726
 727
 728                 void registerAdministeredModule_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
 729
 730                 void requestRefresh_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
 731
 732                 void setInstallVersion_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
 733
 734                 void setLaunchVersion_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
 735
 736                 void declareState_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
 737
 738                 void declareVersionName_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
 739
 740                 void executeCommandOnModules_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
 741
 742                 void executedCommandResult_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
 743
 744                 // declare one interceptor member of the skeleton
 745                 TInterceptor    _Interceptor;
 746
 747                 // declare the interceptor forwarder as friend of this class
 748                 friend          class NLNET::CInterceptorForwarder < CServerPatchManagerSkel>;
 749         public:
 750                 /////////////////////////////////////////////////////////////////
 751                 // WARNING : this is a generated file, don't change it !
 752                 /////////////////////////////////////////////////////////////////
 753
 754                 //
 755                 // Message sent by an administered module to register
 756                 virtual void registerAdministeredModule(NLNET::IModuleProxy *sender, bool requireApplierUpdates, bool requireTerminalUpdates, bool requireDepCfgUpdates, bool isAdministered) =0;
 757                 //
 758                 // Message sent by SPT module to request a refresh of state info etc
 759                 virtual void requestRefresh(NLNET::IModuleProxy *sender) =0;
 760                 //
 761                 // Message sent by SPT module to request a change of install version for a given domain
 762                 // This message is forwarded to all SPA modules of the given domain
 763                 virtual void setInstallVersion(NLNET::IModuleProxy *sender, const NLMISC::CSString &domain, uint32 version) =0;
 764                 //
 765                 // Message sent by SPT module to request a change of launch version for a given domain
 766                 // This message is forwarded to all SPA modules of the given domain
 767                 virtual void setLaunchVersion(NLNET::IModuleProxy *sender, const NLMISC::CSString &domain, uint32 version) =0;
 768                 //
 769                 // Message sent by SPR / SPB / SPA type modules to declare their states
 770                 // This message is forwarded to all connected SPT modules
 771                 virtual void declareState(NLNET::IModuleProxy *sender, const NLMISC::CSString &state) =0;
 772                 //
 773                 // Message sent by SPT module to define a new named version
 774                 virtual void declareVersionName(NLNET::IModuleProxy *sender, const NLMISC::CSString &versionName, uint32 clientVersion, uint32 serverVersion) =0;
 775                 //
 776                 // Message sent by SPT module to request execution of a command on one or more modules
 777                 // Note that the 'target' parameter may be a wildcard
 778                 virtual void executeCommandOnModules(NLNET::IModuleProxy *sender, const NLMISC::CSString &target, const NLMISC::CSString &commandline) =0;
 779                 //
 780                 // Message with result of command issuued via executeCommandOnSPA()
 781                 virtual void executedCommandResult(NLNET::IModuleProxy *sender, const NLMISC::CSString &originator, const NLMISC::CSString &commandline, const NLMISC::CSString &result) =0;
 782
 783
 784         };
 785
 786         /////////////////////////////////////////////////////////////////
 787         // WARNING : this is a generated file, don't change it !
 788         /////////////////////////////////////////////////////////////////
 789         class CServerPatchManagerProxy
 790         {
 791                 /// Smart pointer on the module proxy
 792                 NLNET::TModuleProxyPtr  _ModuleProxy;
 793
 794                 // Pointer on the local module that implement the interface (if the proxy is for a local module)
 795                 NLNET::TModulePtr                                       _LocalModule;
 796                 // Direct pointer on the server implementation interface for collocated module
 797                 CServerPatchManagerSkel *_LocalModuleSkel;
 798
 799
 800         public:
 801                 CServerPatchManagerProxy(NLNET::IModuleProxy *proxy)
 802                 {
 803
 804                         _ModuleProxy = proxy;
 805
 806                         // initialize collocated servant interface
 807                         if (proxy->getModuleDistance() == 0)
 808                         {
 809                                 _LocalModule = proxy->getLocalModule();
 810                                 nlassert(_LocalModule != NULL);
 811                                 CServerPatchManagerSkel::TInterceptor *interceptor = NULL;
 812                                 interceptor = static_cast < NLNET::CModuleBase* >(_LocalModule.getPtr())->getInterceptor(interceptor);
 813                                 nlassert(interceptor != NULL);
 814
 815                                 _LocalModuleSkel = interceptor->getParent();
 816                                 nlassert(_LocalModuleSkel != NULL);
 817                         }
 818                         else
 819                                 _LocalModuleSkel = 0;
 820
 821                 }
 822                 virtual ~CServerPatchManagerProxy()
 823                 {
 824                 }
 825
 826                 NLNET::IModuleProxy *getModuleProxy()
 827                 {
 828                         return _ModuleProxy;
 829                 }
 830
 831                 //
 832                 // Message sent by an administered module to register
 833                 void registerAdministeredModule(NLNET::IModule *sender, bool requireApplierUpdates, bool requireTerminalUpdates, bool requireDepCfgUpdates, bool isAdministered);
 834                 //
 835                 // Message sent by SPT module to request a refresh of state info etc
 836                 void requestRefresh(NLNET::IModule *sender);
 837                 //
 838                 // Message sent by SPT module to request a change of install version for a given domain
 839                 // This message is forwarded to all SPA modules of the given domain
 840                 void setInstallVersion(NLNET::IModule *sender, const NLMISC::CSString &domain, uint32 version);
 841                 //
 842                 // Message sent by SPT module to request a change of launch version for a given domain
 843                 // This message is forwarded to all SPA modules of the given domain
 844                 void setLaunchVersion(NLNET::IModule *sender, const NLMISC::CSString &domain, uint32 version);
 845                 //
 846                 // Message sent by SPR / SPB / SPA type modules to declare their states
 847                 // This message is forwarded to all connected SPT modules
 848                 void declareState(NLNET::IModule *sender, const NLMISC::CSString &state);
 849                 //
 850                 // Message sent by SPT module to define a new named version
 851                 void declareVersionName(NLNET::IModule *sender, const NLMISC::CSString &versionName, uint32 clientVersion, uint32 serverVersion);
 852                 //
 853                 // Message sent by SPT module to request execution of a command on one or more modules
 854                 // Note that the 'target' parameter may be a wildcard
 855                 void executeCommandOnModules(NLNET::IModule *sender, const NLMISC::CSString &target, const NLMISC::CSString &commandline);
 856                 //
 857                 // Message with result of command issuued via executeCommandOnSPA()
 858                 void executedCommandResult(NLNET::IModule *sender, const NLMISC::CSString &originator, const NLMISC::CSString &commandline, const NLMISC::CSString &result);
 859
 860                 // Message serializer. Return the message received in reference for easier integration
 861                 static const NLNET::CMessage &buildMessageFor_registerAdministeredModule(NLNET::CMessage &__message, bool requireApplierUpdates, bool requireTerminalUpdates, bool requireDepCfgUpdates, bool isAdministered);
 862
 863                 // Message serializer. Return the message received in reference for easier integration
 864                 static const NLNET::CMessage &buildMessageFor_requestRefresh(NLNET::CMessage &__message);
 865
 866                 // Message serializer. Return the message received in reference for easier integration
 867                 static const NLNET::CMessage &buildMessageFor_setInstallVersion(NLNET::CMessage &__message, const NLMISC::CSString &domain, uint32 version);
 868
 869                 // Message serializer. Return the message received in reference for easier integration
 870                 static const NLNET::CMessage &buildMessageFor_setLaunchVersion(NLNET::CMessage &__message, const NLMISC::CSString &domain, uint32 version);
 871
 872                 // Message serializer. Return the message received in reference for easier integration
 873                 static const NLNET::CMessage &buildMessageFor_declareState(NLNET::CMessage &__message, const NLMISC::CSString &state);
 874
 875                 // Message serializer. Return the message received in reference for easier integration
 876                 static const NLNET::CMessage &buildMessageFor_declareVersionName(NLNET::CMessage &__message, const NLMISC::CSString &versionName, uint32 clientVersion, uint32 serverVersion);
 877
 878                 // Message serializer. Return the message received in reference for easier integration
 879                 static const NLNET::CMessage &buildMessageFor_executeCommandOnModules(NLNET::CMessage &__message, const NLMISC::CSString &target, const NLMISC::CSString &commandline);
 880
 881                 // Message serializer. Return the message received in reference for easier integration
 882                 static const NLNET::CMessage &buildMessageFor_executedCommandResult(NLNET::CMessage &__message, const NLMISC::CSString &originator, const NLMISC::CSString &commandline, const NLMISC::CSString &result);
 883
 884
 885
 886
 887         };
 888
 889         /////////////////////////////////////////////////////////////////
 890         // WARNING : this is a generated file, don't change it !
 891         /////////////////////////////////////////////////////////////////
 892         class CDeploymentConfigurationSynchroniserSkel
 893         {
 894         public:
 895                 /// the interceptor type
 896                 typedef NLNET::CInterceptorForwarder < CDeploymentConfigurationSynchroniserSkel>        TInterceptor;
 897         protected:
 898                 CDeploymentConfigurationSynchroniserSkel()
 899                 {
 900                         // do early run time check for message table
 901                         getMessageHandlers();
 902                 }
 903                 virtual ~CDeploymentConfigurationSynchroniserSkel()
 904                 {
 905                 }
 906
 907                 void init(NLNET::IModule *module)
 908                 {
 909                         _Interceptor.init(this, module);
 910                 }
 911
 912                 // unused interceptors
 913                 std::string                     fwdBuildModuleManifest() const  { return std::string(); }
 914                 void                            fwdOnModuleUp(NLNET::IModuleProxy *moduleProxy)  {}
 915                 void                            fwdOnModuleDown(NLNET::IModuleProxy *moduleProxy) {}
 916                 void                            fwdOnModuleSecurityChange(NLNET::IModuleProxy *moduleProxy) {}
 917
 918                 // process module message interceptor
 919                 bool fwdOnProcessModuleMessage(NLNET::IModuleProxy *sender, const NLNET::CMessage &message);
 920         private:
 921
 922                 typedef void (CDeploymentConfigurationSynchroniserSkel::*TMessageHandler)(NLNET::IModuleProxy *sender, const NLNET::CMessage &message);
 923                 typedef std::map<std::string, TMessageHandler>  TMessageHandlerMap;
 924
 925                 const TMessageHandlerMap &getMessageHandlers() const;
 926
 927
 928                 void requestSync_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
 929
 930                 void sync_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
 931
 932                 // declare one interceptor member of the skeleton
 933                 TInterceptor    _Interceptor;
 934
 935                 // declare the interceptor forwarder as friend of this class
 936                 friend          class NLNET::CInterceptorForwarder < CDeploymentConfigurationSynchroniserSkel>;
 937         public:
 938                 /////////////////////////////////////////////////////////////////
 939                 // WARNING : this is a generated file, don't change it !
 940                 /////////////////////////////////////////////////////////////////
 941
 942                 //
 943                 // Request for a copy of another module's CDeploymentConfiguration singleton
 944                 virtual void requestSync(NLNET::IModuleProxy *sender) =0;
 945                 //
 946                 // A copy of the data from the CDeploymentConfiguration singleton
 947                 virtual void sync(NLNET::IModuleProxy *sender, const NLNET::TBinBuffer &dataBlob) =0;
 948
 949
 950         };
 951
 952         /////////////////////////////////////////////////////////////////
 953         // WARNING : this is a generated file, don't change it !
 954         /////////////////////////////////////////////////////////////////
 955         class CDeploymentConfigurationSynchroniserProxy
 956         {
 957                 /// Smart pointer on the module proxy
 958                 NLNET::TModuleProxyPtr  _ModuleProxy;
 959
 960                 // Pointer on the local module that implement the interface (if the proxy is for a local module)
 961                 NLNET::TModulePtr                                       _LocalModule;
 962                 // Direct pointer on the server implementation interface for collocated module
 963                 CDeploymentConfigurationSynchroniserSkel        *_LocalModuleSkel;
 964
 965
 966         public:
 967                 CDeploymentConfigurationSynchroniserProxy(NLNET::IModuleProxy *proxy)
 968                 {
 969
 970                         _ModuleProxy = proxy;
 971
 972                         // initialize collocated servant interface
 973                         if (proxy->getModuleDistance() == 0)
 974                         {
 975                                 _LocalModule = proxy->getLocalModule();
 976                                 nlassert(_LocalModule != NULL);
 977                                 CDeploymentConfigurationSynchroniserSkel::TInterceptor *interceptor = NULL;
 978                                 interceptor = static_cast < NLNET::CModuleBase* >(_LocalModule.getPtr())->getInterceptor(interceptor);
 979                                 nlassert(interceptor != NULL);
 980
 981                                 _LocalModuleSkel = interceptor->getParent();
 982                                 nlassert(_LocalModuleSkel != NULL);
 983                         }
 984                         else
 985                                 _LocalModuleSkel = 0;
 986
 987                 }
 988                 virtual ~CDeploymentConfigurationSynchroniserProxy()
 989                 {
 990                 }
 991
 992                 NLNET::IModuleProxy *getModuleProxy()
 993                 {
 994                         return _ModuleProxy;
 995                 }
 996
 997                 //
 998                 // Request for a copy of another module's CDeploymentConfiguration singleton
 999                 void requestSync(NLNET::IModule *sender);
1000                 //
1001                 // A copy of the data from the CDeploymentConfiguration singleton
1002                 void sync(NLNET::IModule *sender, const NLNET::TBinBuffer &dataBlob);
1003
1004                 // Message serializer. Return the message received in reference for easier integration
1005                 static const NLNET::CMessage &buildMessageFor_requestSync(NLNET::CMessage &__message);
1006
1007                 // Message serializer. Return the message received in reference for easier integration
1008                 static const NLNET::CMessage &buildMessageFor_sync(NLNET::CMessage &__message, const NLNET::TBinBuffer &dataBlob);
1009
1010
1011
1012
1013         };
1014
1015 }
1016
1017 #endif