ryzom/server/src/patchman_service/re_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 /////////////////////////////////////////////////////////////////
  20 // WARNING : this is a generated file, don't change it !
  21 /////////////////////////////////////////////////////////////////
  22
  23 #ifndef RE_MODULE_ITF_H
  24 #define RE_MODULE_ITF_H
  25 #include "nel/net/message.h"
  26 #include "nel/net/module.h"
  27 #include "nel/net/module_message.h"
  28 #include "nel/net/module_gateway.h"
  29 #include "nel/misc/string_conversion.h"
  30
  31 #ifndef NLNET_INTERFACE_GET_MODULE
  32 # define NLNET_INTERFACE_GET_MODULE     NLNET::IModule *getModuleInstance() { return this; }
  33 #endif
  34 namespace PATCHMAN
  35 {
  36
  37
  38         /////////////////////////////////////////////////////////////////
  39         // WARNING : this is a generated file, don't change it !
  40         /////////////////////////////////////////////////////////////////
  41         class CRepositoryEmitterSkel
  42         {
  43         protected:
  44                 CRepositoryEmitterSkel()
  45                 {
  46                         // do early run time check for message table
  47                         getMessageHandlers();
  48                 }
  49                 virtual ~CRepositoryEmitterSkel()
  50                 {
  51                 }
  52
  53
  54
  55         private:
  56                 typedef void (CRepositoryEmitterSkel::*TMessageHandler)(NLNET::IModuleProxy *sender, const NLNET::CMessage &message);
  57                 typedef std::map<std::string, TMessageHandler>  TMessageHandlerMap;
  58
  59
  60                 const TMessageHandlerMap &getMessageHandlers() const
  61                 {
  62                         static TMessageHandlerMap handlers;
  63                         static bool init = false;
  64
  65                         if (!init)
  66                         {
  67                                 std::pair < TMessageHandlerMap::iterator, bool > res;
  68
  69                                 res = handlers.insert(std::make_pair(std::string("RE_REQUEST"), &CRepositoryEmitterSkel::requestFile_skel));
  70                                 // if this assert, you have a doubly message name in your interface definition !
  71                                 nlassert(res.second);
  72
  73                                 res = handlers.insert(std::make_pair(std::string("RE_DATA_ACK"), &CRepositoryEmitterSkel::fileDataAck_skel));
  74                                 // if this assert, you have a doubly message name in your interface definition !
  75                                 nlassert(res.second);
  76
  77                                 res = handlers.insert(std::make_pair(std::string("RE_ERR_DUPMOD"), &CRepositoryEmitterSkel::duplicateModuleError_skel));
  78                                 // if this assert, you have a doubly message name in your interface definition !
  79                                 nlassert(res.second);
  80
  81                                 init = true;
  82                         }
  83
  84                         return handlers;
  85                 }
  86
  87         protected:
  88                 bool onDispatchMessage(NLNET::IModuleProxy *sender, const NLNET::CMessage &message)
  89                 {
  90                         const TMessageHandlerMap &mh = getMessageHandlers();
  91
  92                         TMessageHandlerMap::const_iterator it(mh.find(message.getName()));
  93
  94                         if (it == mh.end())
  95                         {
  96                                 return false;
  97                         }
  98
  99                         TMessageHandler cmd = it->second;
 100                         (this->*cmd)(sender, message);
 101
 102                         return true;
 103                 }
 104
 105         private:
 106
 107                 void requestFile_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 108                 {
 109                         std::string     fileName;
 110                         nlRead(__message, serial, fileName);
 111                         requestFile(sender, fileName);
 112                 }
 113
 114                 void fileDataAck_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 115                 {
 116                         std::string     fileName;
 117                         nlRead(__message, serial, fileName);
 118                         bool    status;
 119                         nlRead(__message, serial, status);
 120                         fileDataAck(sender, fileName, status);
 121                 }
 122
 123                 void duplicateModuleError_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 124                 {
 125                         duplicateModuleError(sender);
 126                 }
 127
 128         public:
 129                 /////////////////////////////////////////////////////////////////
 130                 // WARNING : this is a generated file, don't change it !
 131                 /////////////////////////////////////////////////////////////////
 132
 133                 //
 134                 virtual void requestFile(NLNET::IModuleProxy *sender, const std::string &fileName) =0;
 135                 //
 136                 virtual void fileDataAck(NLNET::IModuleProxy *sender, const std::string &fileName, bool status) =0;
 137                 //
 138                 virtual void duplicateModuleError(NLNET::IModuleProxy *sender) =0;
 139
 140
 141         };
 142
 143         /////////////////////////////////////////////////////////////////
 144         // WARNING : this is a generated file, don't change it !
 145         /////////////////////////////////////////////////////////////////
 146         class CRepositoryEmitterProxy
 147         {
 148                 /// Smart pointer on the module proxy
 149                 NLNET::TModuleProxyPtr  _ModuleProxy;
 150
 151                 // Pointer on the local module that implement the interface (if the proxy is for a local module)
 152                 NLNET::TModulePtr                                       _LocalModule;
 153                 // Direct pointer on the server implementation interface for collocated module
 154                 CRepositoryEmitterSkel  *_LocalModuleSkel;
 155
 156
 157         public:
 158                 CRepositoryEmitterProxy(NLNET::IModuleProxy *proxy)
 159                 {
 160
 161                         _ModuleProxy = proxy;
 162
 163                         // initialize collocated servant interface
 164                         if (proxy->getModuleDistance() == 0)
 165                         {
 166                                 _LocalModule = proxy->getLocalModule();
 167                                 nlassert(_LocalModule != NULL);
 168                                 _LocalModuleSkel = dynamic_cast < CRepositoryEmitterSkel* > (_LocalModule.getPtr());
 169                                 nlassert(_LocalModuleSkel != NULL);
 170                         }
 171                         else
 172                                 _LocalModuleSkel = 0;
 173
 174                 }
 175                 virtual ~CRepositoryEmitterProxy()
 176                 {
 177                 }
 178
 179                 NLNET::IModuleProxy *getModuleProxy()
 180                 {
 181                         return _ModuleProxy;
 182                 }
 183
 184                 //
 185                 void requestFile(NLNET::IModule *sender, const std::string &fileName)
 186                 {
 187                         if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 188                         {
 189                                 // immediate local synchronous dispatching
 190                                 _LocalModuleSkel->requestFile(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), fileName);
 191                         }
 192                         else
 193                         {
 194                                 // send the message for remote dispatching and execution or local queing
 195                                 NLNET::CMessage __message;
 196
 197                                 buildMessageFor_requestFile(__message, fileName);
 198
 199                                 _ModuleProxy->sendModuleMessage(sender, __message);
 200                         }
 201                 }
 202                 //
 203                 void fileDataAck(NLNET::IModule *sender, const std::string &fileName, bool status)
 204                 {
 205                         if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 206                         {
 207                                 // immediate local synchronous dispatching
 208                                 _LocalModuleSkel->fileDataAck(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), fileName, status);
 209                         }
 210                         else
 211                         {
 212                                 // send the message for remote dispatching and execution or local queing
 213                                 NLNET::CMessage __message;
 214
 215                                 buildMessageFor_fileDataAck(__message, fileName, status);
 216
 217                                 _ModuleProxy->sendModuleMessage(sender, __message);
 218                         }
 219                 }
 220                 //
 221                 void duplicateModuleError(NLNET::IModule *sender)
 222                 {
 223                         if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 224                         {
 225                                 // immediate local synchronous dispatching
 226                                 _LocalModuleSkel->duplicateModuleError(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender));
 227                         }
 228                         else
 229                         {
 230                                 // send the message for remote dispatching and execution or local queing
 231                                 NLNET::CMessage __message;
 232
 233                                 buildMessageFor_duplicateModuleError(__message);
 234
 235                                 _ModuleProxy->sendModuleMessage(sender, __message);
 236                         }
 237                 }
 238
 239                 // Message serializer. Return the message received in reference for easier integration
 240                 static const NLNET::CMessage &buildMessageFor_requestFile(NLNET::CMessage &__message, const std::string &fileName)
 241                 {
 242                         __message.setType("RE_REQUEST");
 243                         nlWrite(__message, serial, const_cast < std::string& > (fileName));
 244
 245
 246                         return __message;
 247                 }
 248
 249                 // Message serializer. Return the message received in reference for easier integration
 250                 static const NLNET::CMessage &buildMessageFor_fileDataAck(NLNET::CMessage &__message, const std::string &fileName, bool status)
 251                 {
 252                         __message.setType("RE_DATA_ACK");
 253                         nlWrite(__message, serial, const_cast < std::string& > (fileName));
 254                         nlWrite(__message, serial, status);
 255
 256
 257                         return __message;
 258                 }
 259
 260                 // Message serializer. Return the message received in reference for easier integration
 261                 static const NLNET::CMessage &buildMessageFor_duplicateModuleError(NLNET::CMessage &__message)
 262                 {
 263                         __message.setType("RE_ERR_DUPMOD");
 264
 265
 266                         return __message;
 267                 }
 268
 269
 270
 271
 272         };
 273
 274 }
 275
 276 #endif