ryzom/server/src/server_share/backup_service_itf.cpp

   1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This program is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU Affero General Public License as
   6 // published by the Free Software Foundation, either version 3 of the
   7 // License, or (at your option) any later version.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU Affero General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Affero General Public License
  15 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 /////////////////////////////////////////////////////////////////
  18 // WARNING : this is a generated file, don't change it !
  19 /////////////////////////////////////////////////////////////////
  20
  21 #include "stdpch.h"
  22
  23 #include "backup_service_itf.h"
  24
  25 namespace BS
  26 {
  27
  28         /////////////////////////////////////////////////////////////////
  29         // WARNING : this is a generated file, don't change it !
  30         /////////////////////////////////////////////////////////////////
  31
  32
  33         const CBackupServiceSkel::TMessageHandlerMap &CBackupServiceSkel::getMessageHandlers() const
  34         {
  35                 static TMessageHandlerMap handlers;
  36                 static bool init = false;
  37
  38                 if (!init)
  39                 {
  40                         std::pair < TMessageHandlerMap::iterator, bool > res;
  41
  42                         res = handlers.insert(std::make_pair(std::string("BSSF"), &CBackupServiceSkel::saveFile_skel));
  43                         // if this assert, you have a doubly message name in your interface definition !
  44                         nlassert(res.second);
  45
  46                         res = handlers.insert(std::make_pair(std::string("BSLF"), &CBackupServiceSkel::loadFile_skel));
  47                         // if this assert, you have a doubly message name in your interface definition !
  48                         nlassert(res.second);
  49
  50                         init = true;
  51                 }
  52
  53                 return handlers;
  54         }
  55         bool CBackupServiceSkel::fwdOnProcessModuleMessage(NLNET::IModuleProxy *sender, const NLNET::CMessage &message)
  56         {
  57                 const TMessageHandlerMap &mh = getMessageHandlers();
  58
  59                 TMessageHandlerMap::const_iterator it(mh.find(message.getName()));
  60
  61                 if (it == mh.end())
  62                 {
  63                         return false;
  64                 }
  65
  66                 TMessageHandler cmd = it->second;
  67                 (this->*cmd)(sender, message);
  68
  69                 return true;
  70         }
  71
  72
  73         void CBackupServiceSkel::saveFile_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
  74         {
  75                 H_AUTO(CBackupServiceSkel_saveFile_BSSF);
  76                 std::string     fileName;
  77                         nlRead(__message, serial, fileName);
  78                 NLNET::TBinBuffer       data;
  79                         nlRead(__message, serial, data);
  80                 saveFile(sender, fileName, data);
  81         }
  82
  83         void CBackupServiceSkel::loadFile_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
  84         {
  85                 H_AUTO(CBackupServiceSkel_loadFile_BSLF);
  86                 std::string     fileName;
  87                         nlRead(__message, serial, fileName);
  88                 uint32  requestId;
  89                         nlRead(__message, serial, requestId);
  90                 loadFile(sender, fileName, requestId);
  91         }
  92                 // A module ask to save a file in the backup repository
  93         void CBackupServiceProxy::saveFile(NLNET::IModule *sender, const std::string &fileName, const NLNET::TBinBuffer &data)
  94         {
  95                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
  96                 {
  97                         // immediate local synchronous dispatching
  98                         _LocalModuleSkel->saveFile(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), fileName, data);
  99                 }
 100                 else
 101                 {
 102                         // send the message for remote dispatching and execution or local queing
 103                         NLNET::CMessage __message;
 104
 105                         buildMessageFor_saveFile(__message, fileName, data);
 106
 107                         _ModuleProxy->sendModuleMessage(sender, __message);
 108                 }
 109         }
 110                 // A module ask to load a file
 111         void CBackupServiceProxy::loadFile(NLNET::IModule *sender, const std::string &fileName, uint32 requestId)
 112         {
 113                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 114                 {
 115                         // immediate local synchronous dispatching
 116                         _LocalModuleSkel->loadFile(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), fileName, requestId);
 117                 }
 118                 else
 119                 {
 120                         // send the message for remote dispatching and execution or local queing
 121                         NLNET::CMessage __message;
 122
 123                         buildMessageFor_loadFile(__message, fileName, requestId);
 124
 125                         _ModuleProxy->sendModuleMessage(sender, __message);
 126                 }
 127         }
 128
 129         // Message serializer. Return the message received in reference for easier integration
 130         const NLNET::CMessage &CBackupServiceProxy::buildMessageFor_saveFile(NLNET::CMessage &__message, const std::string &fileName, const NLNET::TBinBuffer &data)
 131         {
 132                 __message.setType("BSSF");
 133                         nlWrite(__message, serial, const_cast < std::string& > (fileName));
 134                         nlWrite(__message, serial, const_cast < NLNET::TBinBuffer& > (data));
 135
 136
 137                 return __message;
 138         }
 139
 140         // Message serializer. Return the message received in reference for easier integration
 141         const NLNET::CMessage &CBackupServiceProxy::buildMessageFor_loadFile(NLNET::CMessage &__message, const std::string &fileName, uint32 requestId)
 142         {
 143                 __message.setType("BSLF");
 144                         nlWrite(__message, serial, const_cast < std::string& > (fileName));
 145                         nlWrite(__message, serial, requestId);
 146
 147
 148                 return __message;
 149         }
 150
 151         /////////////////////////////////////////////////////////////////
 152         // WARNING : this is a generated file, don't change it !
 153         /////////////////////////////////////////////////////////////////
 154
 155
 156         const CBackupServiceClientSkel::TMessageHandlerMap &CBackupServiceClientSkel::getMessageHandlers() const
 157         {
 158                 static TMessageHandlerMap handlers;
 159                 static bool init = false;
 160
 161                 if (!init)
 162                 {
 163                         std::pair < TMessageHandlerMap::iterator, bool > res;
 164
 165                         res = handlers.insert(std::make_pair(std::string("BSLFR"), &CBackupServiceClientSkel::loadFileResult_skel));
 166                         // if this assert, you have a doubly message name in your interface definition !
 167                         nlassert(res.second);
 168
 169                         res = handlers.insert(std::make_pair(std::string("BSFU"), &CBackupServiceClientSkel::fileUpdate_skel));
 170                         // if this assert, you have a doubly message name in your interface definition !
 171                         nlassert(res.second);
 172
 173                         init = true;
 174                 }
 175
 176                 return handlers;
 177         }
 178         bool CBackupServiceClientSkel::fwdOnProcessModuleMessage(NLNET::IModuleProxy *sender, const NLNET::CMessage &message)
 179         {
 180                 const TMessageHandlerMap &mh = getMessageHandlers();
 181
 182                 TMessageHandlerMap::const_iterator it(mh.find(message.getName()));
 183
 184                 if (it == mh.end())
 185                 {
 186                         return false;
 187                 }
 188
 189                 TMessageHandler cmd = it->second;
 190                 (this->*cmd)(sender, message);
 191
 192                 return true;
 193         }
 194
 195
 196         void CBackupServiceClientSkel::loadFileResult_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 197         {
 198                 H_AUTO(CBackupServiceClientSkel_loadFileResult_BSLFR);
 199                 uint32  requestId;
 200                         nlRead(__message, serial, requestId);
 201                 std::string     fileName;
 202                         nlRead(__message, serial, fileName);
 203                 uint32  fileTimeStamp;
 204                         nlRead(__message, serial, fileTimeStamp);
 205                 NLNET::TBinBuffer       data;
 206                         nlRead(__message, serial, data);
 207                 loadFileResult(sender, requestId, fileName, fileTimeStamp, data);
 208         }
 209
 210         void CBackupServiceClientSkel::fileUpdate_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 211         {
 212                 H_AUTO(CBackupServiceClientSkel_fileUpdate_BSFU);
 213                 std::string     fileName;
 214                         nlRead(__message, serial, fileName);
 215                 std::vector < std::string >     content;
 216                         nlRead(__message, serialCont, content);
 217                 fileUpdate(sender, fileName, content);
 218         }
 219                 // The BS return for a load file request
 220         void CBackupServiceClientProxy::loadFileResult(NLNET::IModule *sender, uint32 requestId, const std::string &fileName, uint32 fileTimeStamp, const NLNET::TBinBuffer &data)
 221         {
 222                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 223                 {
 224                         // immediate local synchronous dispatching
 225                         _LocalModuleSkel->loadFileResult(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), requestId, fileName, fileTimeStamp, data);
 226                 }
 227                 else
 228                 {
 229                         // send the message for remote dispatching and execution or local queing
 230                         NLNET::CMessage __message;
 231
 232                         buildMessageFor_loadFileResult(__message, requestId, fileName, fileTimeStamp, data);
 233
 234                         _ModuleProxy->sendModuleMessage(sender, __message);
 235                 }
 236         }
 237                 // A file listened by the client have been changed, BS resend the file content
 238         void CBackupServiceClientProxy::fileUpdate(NLNET::IModule *sender, const std::string &fileName, const std::vector < std::string > &content)
 239         {
 240                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 241                 {
 242                         // immediate local synchronous dispatching
 243                         _LocalModuleSkel->fileUpdate(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), fileName, content);
 244                 }
 245                 else
 246                 {
 247                         // send the message for remote dispatching and execution or local queing
 248                         NLNET::CMessage __message;
 249
 250                         buildMessageFor_fileUpdate(__message, fileName, content);
 251
 252                         _ModuleProxy->sendModuleMessage(sender, __message);
 253                 }
 254         }
 255
 256         // Message serializer. Return the message received in reference for easier integration
 257         const NLNET::CMessage &CBackupServiceClientProxy::buildMessageFor_loadFileResult(NLNET::CMessage &__message, uint32 requestId, const std::string &fileName, uint32 fileTimeStamp, const NLNET::TBinBuffer &data)
 258         {
 259                 __message.setType("BSLFR");
 260                         nlWrite(__message, serial, requestId);
 261                         nlWrite(__message, serial, const_cast < std::string& > (fileName));
 262                         nlWrite(__message, serial, fileTimeStamp);
 263                         nlWrite(__message, serial, const_cast < NLNET::TBinBuffer& > (data));
 264
 265
 266                 return __message;
 267         }
 268
 269         // Message serializer. Return the message received in reference for easier integration
 270         const NLNET::CMessage &CBackupServiceClientProxy::buildMessageFor_fileUpdate(NLNET::CMessage &__message, const std::string &fileName, const std::vector < std::string > &content)
 271         {
 272                 __message.setType("BSFU");
 273                         nlWrite(__message, serial, const_cast < std::string& > (fileName));
 274                         nlWrite(__message, serialCont, const_cast < std::vector < std::string >& > (content));
 275
 276
 277                 return __message;
 278         }
 279
 280 }