ryzom/server/src/patchman_service/rr_module_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 #error deprecated
  18 /////////////////////////////////////////////////////////////////
  19 // WARNING : this is a generated file, don't change it !
  20 /////////////////////////////////////////////////////////////////
  21
  22 #ifndef RR_MODULE_ITF_H
  23 #define RR_MODULE_ITF_H
  24 #include "nel/net/message.h"
  25 #include "nel/net/module.h"
  26 #include "nel/net/module_message.h"
  27 #include "nel/net/module_gateway.h"
  28 #include "nel/misc/string_conversion.h"
  29
  30 #include "nel/misc/md5.h"
  31
  32 //#include "repository.h"
  33
  34 #ifndef NLNET_INTERFACE_GET_MODULE
  35 # define NLNET_INTERFACE_GET_MODULE     NLNET::IModule *getModuleInstance() { return this; }
  36 #endif
  37 namespace PATCHMAN
  38 {
  39
  40         class TFileRecord;
  41
  42         /////////////////////////////////////////////////////////////////
  43         // WARNING : this is a generated file, don't change it !
  44         /////////////////////////////////////////////////////////////////
  45         class TFileRecord
  46         {
  47         private:
  48                 //
  49                 std::string     _FileName;
  50                 //
  51                 NLMISC::CHashKeyMD5     _Checksum;
  52         public:
  53                 //
  54                 const std::string &getFileName() const
  55                 {
  56                         return _FileName;
  57                 }
  58
  59                 std::string &getFileName()
  60                 {
  61                         return _FileName;
  62                 }
  63
  64
  65                 void setFileName(const std::string &value)
  66                 {
  67                         if (_FileName != value)
  68                         {
  69
  70
  71                                 _FileName = value;
  72
  73
  74                         }
  75                 }
  76                         //
  77                 const NLMISC::CHashKeyMD5 &getChecksum() const
  78                 {
  79                         return _Checksum;
  80                 }
  81
  82                 NLMISC::CHashKeyMD5 &getChecksum()
  83                 {
  84                         return _Checksum;
  85                 }
  86
  87
  88                 void setChecksum(const NLMISC::CHashKeyMD5 &value)
  89                 {
  90                         if (_Checksum != value)
  91                         {
  92
  93
  94                                 _Checksum = value;
  95
  96
  97                         }
  98                 }
  99
 100                 bool operator == (const TFileRecord &other) const
 101                 {
 102                         return _FileName == other._FileName
 103                                 && _Checksum == other._Checksum;
 104                 }
 105
 106
 107                 void serial(NLMISC::IStream &s)
 108                 {
 109                         s.serial(_FileName);
 110                         s.serial(_Checksum);
 111
 112                 }
 113
 114
 115         private:
 116
 117
 118         };
 119
 120
 121
 122         /////////////////////////////////////////////////////////////////
 123         // WARNING : this is a generated file, don't change it !
 124         /////////////////////////////////////////////////////////////////
 125         class CRepositoryReceiverSkel
 126         {
 127         protected:
 128                 CRepositoryReceiverSkel()
 129                 {
 130                         // do early run time check for message table
 131                         getMessageHandlers();
 132                 }
 133                 virtual ~CRepositoryReceiverSkel()
 134                 {
 135                 }
 136
 137
 138
 139         private:
 140                 typedef void (CRepositoryReceiverSkel::*TMessageHandler)(NLNET::IModuleProxy *sender, const NLNET::CMessage &message);
 141                 typedef std::map<std::string, TMessageHandler>  TMessageHandlerMap;
 142
 143
 144                 const TMessageHandlerMap &getMessageHandlers() const
 145                 {
 146                         static TMessageHandlerMap handlers;
 147                         static bool init = false;
 148
 149                         if (!init)
 150                         {
 151                                 std::pair < TMessageHandlerMap::iterator, bool > res;
 152
 153                                 res = handlers.insert(std::make_pair(std::string("RR_LIST"), &CRepositoryReceiverSkel::fileList_skel));
 154                                 // if this assert, you have a doubly message name in your interface definition !
 155                                 nlassert(res.second);
 156
 157                                 res = handlers.insert(std::make_pair(std::string("RR_FILE_BEGIN"), &CRepositoryReceiverSkel::beginFile_skel));
 158                                 // if this assert, you have a doubly message name in your interface definition !
 159                                 nlassert(res.second);
 160
 161                                 res = handlers.insert(std::make_pair(std::string("RR_FILE_DATA"), &CRepositoryReceiverSkel::fileData_skel));
 162                                 // if this assert, you have a doubly message name in your interface definition !
 163                                 nlassert(res.second);
 164
 165                                 res = handlers.insert(std::make_pair(std::string("RR_FILE_END"), &CRepositoryReceiverSkel::fileEnd_skel));
 166                                 // if this assert, you have a doubly message name in your interface definition !
 167                                 nlassert(res.second);
 168
 169                                 init = true;
 170                         }
 171
 172                         return handlers;
 173                 }
 174
 175         protected:
 176                 bool onDispatchMessage(NLNET::IModuleProxy *sender, const NLNET::CMessage &message)
 177                 {
 178                         const TMessageHandlerMap &mh = getMessageHandlers();
 179
 180                         TMessageHandlerMap::const_iterator it(mh.find(message.getName()));
 181
 182                         if (it == mh.end())
 183                         {
 184                                 return false;
 185                         }
 186
 187                         TMessageHandler cmd = it->second;
 188                         (this->*cmd)(sender, message);
 189
 190                         return true;
 191                 }
 192
 193         private:
 194
 195                 void fileList_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 196                 {
 197                         uint32  version;
 198                         nlRead(__message, serial, version);
 199                         TFileInfoVector files;
 200                         nlRead(__message, serialCont, files);
 201                         fileList(sender, version, files);
 202                 }
 203
 204                 void beginFile_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 205                 {
 206                         std::string     fileName;
 207                         nlRead(__message, serial, fileName);
 208                         uint32  fileSize;
 209                         nlRead(__message, serial, fileSize);
 210                         beginFile(sender, fileName, fileSize);
 211                 }
 212
 213                 void fileData_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 214                 {
 215                         std::string     fileName;
 216                         nlRead(__message, serial, fileName);
 217                         std::string     data;
 218                         nlRead(__message, serial, data);
 219                         fileData(sender, fileName, data);
 220                 }
 221
 222                 void fileEnd_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 223                 {
 224                         std::string     fileName;
 225                         nlRead(__message, serial, fileName);
 226                         fileEnd(sender, fileName);
 227                 }
 228
 229         public:
 230                 /////////////////////////////////////////////////////////////////
 231                 // WARNING : this is a generated file, don't change it !
 232                 /////////////////////////////////////////////////////////////////
 233
 234                 //
 235                 virtual void fileList(NLNET::IModuleProxy *sender, uint32 version, const TFileInfoVector &files) =0;
 236                 //
 237                 virtual void beginFile(NLNET::IModuleProxy *sender, const std::string &fileName, uint32 fileSize) =0;
 238                 //
 239                 virtual void fileData(NLNET::IModuleProxy *sender, const std::string &fileName, const std::string &data) =0;
 240                 //
 241                 virtual void fileEnd(NLNET::IModuleProxy *sender, const std::string &fileName) =0;
 242
 243
 244         };
 245
 246         /////////////////////////////////////////////////////////////////
 247         // WARNING : this is a generated file, don't change it !
 248         /////////////////////////////////////////////////////////////////
 249         class CRepositoryReceiverProxy
 250         {
 251                 /// Smart pointer on the module proxy
 252                 NLNET::TModuleProxyPtr  _ModuleProxy;
 253
 254                 // Pointer on the local module that implement the interface (if the proxy is for a local module)
 255                 NLNET::TModulePtr                                       _LocalModule;
 256                 // Direct pointer on the server implementation interface for collocated module
 257                 CRepositoryReceiverSkel *_LocalModuleSkel;
 258
 259
 260         public:
 261                 CRepositoryReceiverProxy(NLNET::IModuleProxy *proxy)
 262                 {
 263
 264                         _ModuleProxy = proxy;
 265
 266                         // initialize collocated servant interface
 267                         if (proxy->getModuleDistance() == 0)
 268                         {
 269                                 _LocalModule = proxy->getLocalModule();
 270                                 nlassert(_LocalModule != NULL);
 271                                 _LocalModuleSkel = dynamic_cast < CRepositoryReceiverSkel* > (_LocalModule.getPtr());
 272                                 nlassert(_LocalModuleSkel != NULL);
 273                         }
 274                         else
 275                                 _LocalModuleSkel = 0;
 276
 277                 }
 278                 virtual ~CRepositoryReceiverProxy()
 279                 {
 280                 }
 281
 282                 NLNET::IModuleProxy *getModuleProxy()
 283                 {
 284                         return _ModuleProxy;
 285                 }
 286
 287                 //
 288                 void fileList(NLNET::IModule *sender, uint32 version, const TFileInfoVector &files)
 289                 {
 290                         if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 291                         {
 292                                 // immediate local synchronous dispatching
 293                                 _LocalModuleSkel->fileList(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), version, files);
 294                         }
 295                         else
 296                         {
 297                                 // send the message for remote dispatching and execution or local queing
 298                                 NLNET::CMessage __message;
 299
 300                                 buildMessageFor_fileList(__message, version, files);
 301
 302                                 _ModuleProxy->sendModuleMessage(sender, __message);
 303                         }
 304                 }
 305                 //
 306                 void beginFile(NLNET::IModule *sender, const std::string &fileName, uint32 fileSize)
 307                 {
 308                         if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 309                         {
 310                                 // immediate local synchronous dispatching
 311                                 _LocalModuleSkel->beginFile(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), fileName, fileSize);
 312                         }
 313                         else
 314                         {
 315                                 // send the message for remote dispatching and execution or local queing
 316                                 NLNET::CMessage __message;
 317
 318                                 buildMessageFor_beginFile(__message, fileName, fileSize);
 319
 320                                 _ModuleProxy->sendModuleMessage(sender, __message);
 321                         }
 322                 }
 323                 //
 324                 void fileData(NLNET::IModule *sender, const std::string &fileName, const std::string &data)
 325                 {
 326                         if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 327                         {
 328                                 // immediate local synchronous dispatching
 329                                 _LocalModuleSkel->fileData(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), fileName, data);
 330                         }
 331                         else
 332                         {
 333                                 // send the message for remote dispatching and execution or local queing
 334                                 NLNET::CMessage __message;
 335
 336                                 buildMessageFor_fileData(__message, fileName, data);
 337
 338                                 _ModuleProxy->sendModuleMessage(sender, __message);
 339                         }
 340                 }
 341                 //
 342                 void fileEnd(NLNET::IModule *sender, const std::string &fileName)
 343                 {
 344                         if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 345                         {
 346                                 // immediate local synchronous dispatching
 347                                 _LocalModuleSkel->fileEnd(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), fileName);
 348                         }
 349                         else
 350                         {
 351                                 // send the message for remote dispatching and execution or local queing
 352                                 NLNET::CMessage __message;
 353
 354                                 buildMessageFor_fileEnd(__message, fileName);
 355
 356                                 _ModuleProxy->sendModuleMessage(sender, __message);
 357                         }
 358                 }
 359
 360                 // Message serializer. Return the message received in reference for easier integration
 361                 static const NLNET::CMessage &buildMessageFor_fileList(NLNET::CMessage &__message, uint32 version, const TFileInfoVector &files)
 362                 {
 363                         __message.setType("RR_LIST");
 364                         nlWrite(__message, serial, version);
 365                         nlWrite(__message, serialCont, const_cast < TFileInfoVector& > (files));
 366
 367
 368                         return __message;
 369                 }
 370
 371                 // Message serializer. Return the message received in reference for easier integration
 372                 static const NLNET::CMessage &buildMessageFor_beginFile(NLNET::CMessage &__message, const std::string &fileName, uint32 fileSize)
 373                 {
 374                         __message.setType("RR_FILE_BEGIN");
 375                         nlWrite(__message, serial, const_cast < std::string& > (fileName));
 376                         nlWrite(__message, serial, fileSize);
 377
 378
 379                         return __message;
 380                 }
 381
 382                 // Message serializer. Return the message received in reference for easier integration
 383                 static const NLNET::CMessage &buildMessageFor_fileData(NLNET::CMessage &__message, const std::string &fileName, const std::string &data)
 384                 {
 385                         __message.setType("RR_FILE_DATA");
 386                         nlWrite(__message, serial, const_cast < std::string& > (fileName));
 387                         nlWrite(__message, serial, const_cast < std::string& > (data));
 388
 389
 390                         return __message;
 391                 }
 392
 393                 // Message serializer. Return the message received in reference for easier integration
 394                 static const NLNET::CMessage &buildMessageFor_fileEnd(NLNET::CMessage &__message, const std::string &fileName)
 395                 {
 396                         __message.setType("RR_FILE_END");
 397                         nlWrite(__message, serial, const_cast < std::string& > (fileName));
 398
 399
 400                         return __message;
 401                 }
 402
 403
 404
 405
 406         };
 407
 408         /////////////////////////////////////////////////////////////////
 409         // WARNING : this is a generated file, don't change it !
 410         /////////////////////////////////////////////////////////////////
 411         class CFileReceiverSkel
 412         {
 413         protected:
 414                 CFileReceiverSkel()
 415                 {
 416                         // do early run time check for message table
 417                         getMessageHandlers();
 418                 }
 419                 virtual ~CFileReceiverSkel()
 420                 {
 421                 }
 422
 423
 424
 425         private:
 426                 typedef void (CFileReceiverSkel::*TMessageHandler)(NLNET::IModuleProxy *sender, const NLNET::CMessage &message);
 427                 typedef std::map<std::string, TMessageHandler>  TMessageHandlerMap;
 428
 429
 430                 const TMessageHandlerMap &getMessageHandlers() const
 431                 {
 432                         static TMessageHandlerMap handlers;
 433                         static bool init = false;
 434
 435                         if (!init)
 436                         {
 437                                 std::pair < TMessageHandlerMap::iterator, bool > res;
 438
 439                                 res = handlers.insert(std::make_pair(std::string("FR_FILE_INFO"), &CFileReceiverSkel::fileInfo_skel));
 440                                 // if this assert, you have a doubly message name in your interface definition !
 441                                 nlassert(res.second);
 442
 443                                 res = handlers.insert(std::make_pair(std::string("FR_FILE_DATA"), &CFileReceiverSkel::fileData_skel));
 444                                 // if this assert, you have a doubly message name in your interface definition !
 445                                 nlassert(res.second);
 446
 447                                 res = handlers.insert(std::make_pair(std::string("FR_FILE_ERR"), &CFileReceiverSkel::fileDataFailure_skel));
 448                                 // if this assert, you have a doubly message name in your interface definition !
 449                                 nlassert(res.second);
 450
 451                                 init = true;
 452                         }
 453
 454                         return handlers;
 455                 }
 456
 457         protected:
 458                 bool onDispatchMessage(NLNET::IModuleProxy *sender, const NLNET::CMessage &message)
 459                 {
 460                         const TMessageHandlerMap &mh = getMessageHandlers();
 461
 462                         TMessageHandlerMap::const_iterator it(mh.find(message.getName()));
 463
 464                         if (it == mh.end())
 465                         {
 466                                 return false;
 467                         }
 468
 469                         TMessageHandler cmd = it->second;
 470                         (this->*cmd)(sender, message);
 471
 472                         return true;
 473                 }
 474
 475         private:
 476
 477                 void fileInfo_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 478                 {
 479                         TFileInfoVector files;
 480                         nlRead(__message, serialCont, files);
 481                         fileInfo(sender, files);
 482                 }
 483
 484                 void fileData_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 485                 {
 486                         std::string     fileName;
 487                         nlRead(__message, serial, fileName);
 488                         uint32  startOffset;
 489                         nlRead(__message, serial, startOffset);
 490                         std::string     data;
 491                         nlRead(__message, serial, data);
 492                         fileData(sender, fileName, startOffset, data);
 493                 }
 494
 495                 void fileDataFailure_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 496                 {
 497                         std::string     fileName;
 498                         nlRead(__message, serial, fileName);
 499                         fileDataFailure(sender, fileName);
 500                 }
 501
 502         public:
 503                 /////////////////////////////////////////////////////////////////
 504                 // WARNING : this is a generated file, don't change it !
 505                 /////////////////////////////////////////////////////////////////
 506
 507                 //
 508                 virtual void fileInfo(NLNET::IModuleProxy *sender, const TFileInfoVector &files) =0;
 509                 //
 510                 virtual void fileData(NLNET::IModuleProxy *sender, const std::string &fileName, uint32 startOffset, const std::string &data) =0;
 511                 //
 512                 virtual void fileDataFailure(NLNET::IModuleProxy *sender, const std::string &fileName) =0;
 513
 514
 515         };
 516
 517         /////////////////////////////////////////////////////////////////
 518         // WARNING : this is a generated file, don't change it !
 519         /////////////////////////////////////////////////////////////////
 520         class CFileReceiverProxy
 521         {
 522                 /// Smart pointer on the module proxy
 523                 NLNET::TModuleProxyPtr  _ModuleProxy;
 524
 525                 // Pointer on the local module that implement the interface (if the proxy is for a local module)
 526                 NLNET::TModulePtr                                       _LocalModule;
 527                 // Direct pointer on the server implementation interface for collocated module
 528                 CFileReceiverSkel       *_LocalModuleSkel;
 529
 530
 531         public:
 532                 CFileReceiverProxy(NLNET::IModuleProxy *proxy)
 533                 {
 534
 535                         _ModuleProxy = proxy;
 536
 537                         // initialize collocated servant interface
 538                         if (proxy->getModuleDistance() == 0)
 539                         {
 540                                 _LocalModule = proxy->getLocalModule();
 541                                 nlassert(_LocalModule != NULL);
 542                                 _LocalModuleSkel = dynamic_cast < CFileReceiverSkel* > (_LocalModule.getPtr());
 543                                 nlassert(_LocalModuleSkel != NULL);
 544                         }
 545                         else
 546                                 _LocalModuleSkel = 0;
 547
 548                 }
 549                 virtual ~CFileReceiverProxy()
 550                 {
 551                 }
 552
 553                 NLNET::IModuleProxy *getModuleProxy()
 554                 {
 555                         return _ModuleProxy;
 556                 }
 557
 558                 //
 559                 void fileInfo(NLNET::IModule *sender, const TFileInfoVector &files)
 560                 {
 561                         if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 562                         {
 563                                 // immediate local synchronous dispatching
 564                                 _LocalModuleSkel->fileInfo(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), files);
 565                         }
 566                         else
 567                         {
 568                                 // send the message for remote dispatching and execution or local queing
 569                                 NLNET::CMessage __message;
 570
 571                                 buildMessageFor_fileInfo(__message, files);
 572
 573                                 _ModuleProxy->sendModuleMessage(sender, __message);
 574                         }
 575                 }
 576                 //
 577                 void fileData(NLNET::IModule *sender, const std::string &fileName, uint32 startOffset, const std::string &data)
 578                 {
 579                         if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 580                         {
 581                                 // immediate local synchronous dispatching
 582                                 _LocalModuleSkel->fileData(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), fileName, startOffset, data);
 583                         }
 584                         else
 585                         {
 586                                 // send the message for remote dispatching and execution or local queing
 587                                 NLNET::CMessage __message;
 588
 589                                 buildMessageFor_fileData(__message, fileName, startOffset, data);
 590
 591                                 _ModuleProxy->sendModuleMessage(sender, __message);
 592                         }
 593                 }
 594                 //
 595                 void fileDataFailure(NLNET::IModule *sender, const std::string &fileName)
 596                 {
 597                         if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 598                         {
 599                                 // immediate local synchronous dispatching
 600                                 _LocalModuleSkel->fileDataFailure(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), fileName);
 601                         }
 602                         else
 603                         {
 604                                 // send the message for remote dispatching and execution or local queing
 605                                 NLNET::CMessage __message;
 606
 607                                 buildMessageFor_fileDataFailure(__message, fileName);
 608
 609                                 _ModuleProxy->sendModuleMessage(sender, __message);
 610                         }
 611                 }
 612
 613                 // Message serializer. Return the message received in reference for easier integration
 614                 static const NLNET::CMessage &buildMessageFor_fileInfo(NLNET::CMessage &__message, const TFileInfoVector &files)
 615                 {
 616                         __message.setType("FR_FILE_INFO");
 617                         nlWrite(__message, serialCont, const_cast < TFileInfoVector& > (files));
 618
 619
 620                         return __message;
 621                 }
 622
 623                 // Message serializer. Return the message received in reference for easier integration
 624                 static const NLNET::CMessage &buildMessageFor_fileData(NLNET::CMessage &__message, const std::string &fileName, uint32 startOffset, const std::string &data)
 625                 {
 626                         __message.setType("FR_FILE_DATA");
 627                         nlWrite(__message, serial, const_cast < std::string& > (fileName));
 628                         nlWrite(__message, serial, startOffset);
 629                         nlWrite(__message, serial, const_cast < std::string& > (data));
 630
 631
 632                         return __message;
 633                 }
 634
 635                 // Message serializer. Return the message received in reference for easier integration
 636                 static const NLNET::CMessage &buildMessageFor_fileDataFailure(NLNET::CMessage &__message, const std::string &fileName)
 637                 {
 638                         __message.setType("FR_FILE_ERR");
 639                         nlWrite(__message, serial, const_cast < std::string& > (fileName));
 640
 641
 642                         return __message;
 643                 }
 644
 645
 646
 647
 648         };
 649
 650 }
 651
 652 #endif