ryzom/server/src/admin_modules/admin_modules_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 #include "admin_modules_itf.h"
  23
  24 namespace ADMIN
  25 {
  26
  27         /////////////////////////////////////////////////////////////////
  28         // WARNING : this is a generated file, don't change it !
  29         /////////////////////////////////////////////////////////////////
  30
  31
  32         const CAdminServiceSkel::TMessageHandlerMap &CAdminServiceSkel::getMessageHandlers() const
  33         {
  34                 static TMessageHandlerMap handlers;
  35                 static bool init = false;
  36
  37                 if (!init)
  38                 {
  39                         std::pair < TMessageHandlerMap::iterator, bool > res;
  40
  41                         res = handlers.insert(std::make_pair(std::string("USU"), &CAdminServiceSkel::upServiceUpdate_skel));
  42                         // if this assert, you have a doubly message name in your interface definition !
  43                         nlassert(res.second);
  44
  45                         res = handlers.insert(std::make_pair(std::string("GU"), &CAdminServiceSkel::graphUpdate_skel));
  46                         // if this assert, you have a doubly message name in your interface definition !
  47                         nlassert(res.second);
  48
  49                         res = handlers.insert(std::make_pair(std::string("HRGU"), &CAdminServiceSkel::highRezGraphUpdate_skel));
  50                         // if this assert, you have a doubly message name in your interface definition !
  51                         nlassert(res.second);
  52
  53                         res = handlers.insert(std::make_pair(std::string("CR"), &CAdminServiceSkel::commandResult_skel));
  54                         // if this assert, you have a doubly message name in your interface definition !
  55                         nlassert(res.second);
  56
  57                         init = true;
  58                 }
  59
  60                 return handlers;
  61         }
  62         bool CAdminServiceSkel::fwdOnProcessModuleMessage(NLNET::IModuleProxy *sender, const NLNET::CMessage &message)
  63         {
  64                 const TMessageHandlerMap &mh = getMessageHandlers();
  65
  66                 TMessageHandlerMap::const_iterator it(mh.find(message.getName()));
  67
  68                 if (it == mh.end())
  69                 {
  70                         return false;
  71                 }
  72
  73                 TMessageHandler cmd = it->second;
  74                 (this->*cmd)(sender, message);
  75
  76                 return true;
  77         }
  78
  79
  80         void CAdminServiceSkel::upServiceUpdate_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
  81         {
  82                 H_AUTO(CAdminServiceSkel_upServiceUpdate_USU);
  83                 std::vector < TServiceStatus >  serviceStatus;
  84                         nlRead(__message, serialCont, serviceStatus);
  85                 upServiceUpdate(sender, serviceStatus);
  86         }
  87
  88         void CAdminServiceSkel::graphUpdate_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
  89         {
  90                 H_AUTO(CAdminServiceSkel_graphUpdate_GU);
  91                 TGraphDatas     graphDatas;
  92                         nlRead(__message, serial, graphDatas);
  93                 graphUpdate(sender, graphDatas);
  94         }
  95
  96         void CAdminServiceSkel::highRezGraphUpdate_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
  97         {
  98                 H_AUTO(CAdminServiceSkel_highRezGraphUpdate_HRGU);
  99                 THighRezDatas   graphDatas;
 100                         nlRead(__message, serial, graphDatas);
 101                 highRezGraphUpdate(sender, graphDatas);
 102         }
 103
 104         void CAdminServiceSkel::commandResult_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 105         {
 106                 H_AUTO(CAdminServiceSkel_commandResult_CR);
 107                 uint32  commandId;
 108                         nlRead(__message, serial, commandId);
 109                 std::string     serviceAlias;
 110                         nlRead(__message, serial, serviceAlias);
 111                 std::string     result;
 112                         nlRead(__message, serial, result);
 113                 commandResult(sender, commandId, serviceAlias, result);
 114         }
 115                 // An AES send an update of the list of service up
 116         void CAdminServiceProxy::upServiceUpdate(NLNET::IModule *sender, const std::vector < TServiceStatus > &serviceStatus)
 117         {
 118                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 119                 {
 120                         // immediate local synchronous dispatching
 121                         _LocalModuleSkel->upServiceUpdate(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), serviceStatus);
 122                 }
 123                 else
 124                 {
 125                         // send the message for remote dispatching and execution or local queing
 126                         NLNET::CMessage __message;
 127
 128                         buildMessageFor_upServiceUpdate(__message, serviceStatus);
 129
 130                         _ModuleProxy->sendModuleMessage(sender, __message);
 131                 }
 132         }
 133                 // An AES send graph data update
 134         void CAdminServiceProxy::graphUpdate(NLNET::IModule *sender, const TGraphDatas &graphDatas)
 135         {
 136                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 137                 {
 138                         // immediate local synchronous dispatching
 139                         _LocalModuleSkel->graphUpdate(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), graphDatas);
 140                 }
 141                 else
 142                 {
 143                         // send the message for remote dispatching and execution or local queing
 144                         NLNET::CMessage __message;
 145
 146                         buildMessageFor_graphUpdate(__message, graphDatas);
 147
 148                         _ModuleProxy->sendModuleMessage(sender, __message);
 149                 }
 150         }
 151                 // An AES send high rez graph data update
 152         void CAdminServiceProxy::highRezGraphUpdate(NLNET::IModule *sender, const THighRezDatas &graphDatas)
 153         {
 154                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 155                 {
 156                         // immediate local synchronous dispatching
 157                         _LocalModuleSkel->highRezGraphUpdate(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), graphDatas);
 158                 }
 159                 else
 160                 {
 161                         // send the message for remote dispatching and execution or local queing
 162                         NLNET::CMessage __message;
 163
 164                         buildMessageFor_highRezGraphUpdate(__message, graphDatas);
 165
 166                         _ModuleProxy->sendModuleMessage(sender, __message);
 167                 }
 168         }
 169                 // AES send back the result of execution of a command
 170         void CAdminServiceProxy::commandResult(NLNET::IModule *sender, uint32 commandId, const std::string &serviceAlias, const std::string &result)
 171         {
 172                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 173                 {
 174                         // immediate local synchronous dispatching
 175                         _LocalModuleSkel->commandResult(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), commandId, serviceAlias, result);
 176                 }
 177                 else
 178                 {
 179                         // send the message for remote dispatching and execution or local queing
 180                         NLNET::CMessage __message;
 181
 182                         buildMessageFor_commandResult(__message, commandId, serviceAlias, result);
 183
 184                         _ModuleProxy->sendModuleMessage(sender, __message);
 185                 }
 186         }
 187
 188         // Message serializer. Return the message received in reference for easier integration
 189         const NLNET::CMessage &CAdminServiceProxy::buildMessageFor_upServiceUpdate(NLNET::CMessage &__message, const std::vector < TServiceStatus > &serviceStatus)
 190         {
 191                 __message.setType("USU");
 192                         nlWrite(__message, serialCont, const_cast < std::vector < TServiceStatus >& > (serviceStatus));
 193
 194
 195                 return __message;
 196         }
 197
 198         // Message serializer. Return the message received in reference for easier integration
 199         const NLNET::CMessage &CAdminServiceProxy::buildMessageFor_graphUpdate(NLNET::CMessage &__message, const TGraphDatas &graphDatas)
 200         {
 201                 __message.setType("GU");
 202                         nlWrite(__message, serial, const_cast < TGraphDatas& > (graphDatas));
 203
 204
 205                 return __message;
 206         }
 207
 208         // Message serializer. Return the message received in reference for easier integration
 209         const NLNET::CMessage &CAdminServiceProxy::buildMessageFor_highRezGraphUpdate(NLNET::CMessage &__message, const THighRezDatas &graphDatas)
 210         {
 211                 __message.setType("HRGU");
 212                         nlWrite(__message, serial, const_cast < THighRezDatas& > (graphDatas));
 213
 214
 215                 return __message;
 216         }
 217
 218         // Message serializer. Return the message received in reference for easier integration
 219         const NLNET::CMessage &CAdminServiceProxy::buildMessageFor_commandResult(NLNET::CMessage &__message, uint32 commandId, const std::string &serviceAlias, const std::string &result)
 220         {
 221                 __message.setType("CR");
 222                         nlWrite(__message, serial, commandId);
 223                         nlWrite(__message, serial, const_cast < std::string& > (serviceAlias));
 224                         nlWrite(__message, serial, const_cast < std::string& > (result));
 225
 226
 227                 return __message;
 228         }
 229
 230         /////////////////////////////////////////////////////////////////
 231         // WARNING : this is a generated file, don't change it !
 232         /////////////////////////////////////////////////////////////////
 233
 234
 235         const CAdminExecutorServiceSkel::TMessageHandlerMap &CAdminExecutorServiceSkel::getMessageHandlers() const
 236         {
 237                 static TMessageHandlerMap handlers;
 238                 static bool init = false;
 239
 240                 if (!init)
 241                 {
 242                         std::pair < TMessageHandlerMap::iterator, bool > res;
 243
 244                         res = handlers.insert(std::make_pair(std::string("SCO"), &CAdminExecutorServiceSkel::setShardOrders_skel));
 245                         // if this assert, you have a doubly message name in your interface definition !
 246                         nlassert(res.second);
 247
 248                         res = handlers.insert(std::make_pair(std::string("SDS"), &CAdminExecutorServiceSkel::shutdownShard_skel));
 249                         // if this assert, you have a doubly message name in your interface definition !
 250                         nlassert(res.second);
 251
 252                         res = handlers.insert(std::make_pair(std::string("CC"), &CAdminExecutorServiceSkel::controlCmd_skel));
 253                         // if this assert, you have a doubly message name in your interface definition !
 254                         nlassert(res.second);
 255
 256                         res = handlers.insert(std::make_pair(std::string("SCMD"), &CAdminExecutorServiceSkel::serviceCmd_skel));
 257                         // if this assert, you have a doubly message name in your interface definition !
 258                         nlassert(res.second);
 259
 260                         res = handlers.insert(std::make_pair(std::string("CR"), &CAdminExecutorServiceSkel::commandResult_skel));
 261                         // if this assert, you have a doubly message name in your interface definition !
 262                         nlassert(res.second);
 263
 264                         res = handlers.insert(std::make_pair(std::string("GU"), &CAdminExecutorServiceSkel::graphUpdate_skel));
 265                         // if this assert, you have a doubly message name in your interface definition !
 266                         nlassert(res.second);
 267
 268                         res = handlers.insert(std::make_pair(std::string("HRGU"), &CAdminExecutorServiceSkel::highRezGraphUpdate_skel));
 269                         // if this assert, you have a doubly message name in your interface definition !
 270                         nlassert(res.second);
 271
 272                         res = handlers.insert(std::make_pair(std::string("SSU"), &CAdminExecutorServiceSkel::serviceStatusUpdate_skel));
 273                         // if this assert, you have a doubly message name in your interface definition !
 274                         nlassert(res.second);
 275
 276                         init = true;
 277                 }
 278
 279                 return handlers;
 280         }
 281         bool CAdminExecutorServiceSkel::fwdOnProcessModuleMessage(NLNET::IModuleProxy *sender, const NLNET::CMessage &message)
 282         {
 283                 const TMessageHandlerMap &mh = getMessageHandlers();
 284
 285                 TMessageHandlerMap::const_iterator it(mh.find(message.getName()));
 286
 287                 if (it == mh.end())
 288                 {
 289                         return false;
 290                 }
 291
 292                 TMessageHandler cmd = it->second;
 293                 (this->*cmd)(sender, message);
 294
 295                 return true;
 296         }
 297
 298
 299         void CAdminExecutorServiceSkel::setShardOrders_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 300         {
 301                 H_AUTO(CAdminExecutorServiceSkel_setShardOrders_SCO);
 302                 std::string     shardName;
 303                         nlRead(__message, serial, shardName);
 304                 TShardOrders    shardOrders;
 305                         nlRead(__message, serial, shardOrders);
 306                 setShardOrders(sender, shardName, shardOrders);
 307         }
 308
 309         void CAdminExecutorServiceSkel::shutdownShard_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 310         {
 311                 H_AUTO(CAdminExecutorServiceSkel_shutdownShard_SDS);
 312                 std::string     shardName;
 313                         nlRead(__message, serial, shardName);
 314                 uint32  delay;
 315                         nlRead(__message, serial, delay);
 316                 shutdownShard(sender, shardName, delay);
 317         }
 318
 319         void CAdminExecutorServiceSkel::controlCmd_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 320         {
 321                 H_AUTO(CAdminExecutorServiceSkel_controlCmd_CC);
 322                 uint32  commandId;
 323                         nlRead(__message, serial, commandId);
 324                 std::string     serviceAlias;
 325                         nlRead(__message, serial, serviceAlias);
 326                 std::string     command;
 327                         nlRead(__message, serial, command);
 328                 controlCmd(sender, commandId, serviceAlias, command);
 329         }
 330
 331         void CAdminExecutorServiceSkel::serviceCmd_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 332         {
 333                 H_AUTO(CAdminExecutorServiceSkel_serviceCmd_SCMD);
 334                 uint32  commandId;
 335                         nlRead(__message, serial, commandId);
 336                 std::string     serviceAlias;
 337                         nlRead(__message, serial, serviceAlias);
 338                 std::string     command;
 339                         nlRead(__message, serial, command);
 340                 serviceCmd(sender, commandId, serviceAlias, command);
 341         }
 342
 343         void CAdminExecutorServiceSkel::commandResult_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 344         {
 345                 H_AUTO(CAdminExecutorServiceSkel_commandResult_CR);
 346                 uint32  commandId;
 347                         nlRead(__message, serial, commandId);
 348                 std::string     serviceAlias;
 349                         nlRead(__message, serial, serviceAlias);
 350                 std::string     result;
 351                         nlRead(__message, serial, result);
 352                 commandResult(sender, commandId, serviceAlias, result);
 353         }
 354
 355         void CAdminExecutorServiceSkel::graphUpdate_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 356         {
 357                 H_AUTO(CAdminExecutorServiceSkel_graphUpdate_GU);
 358                 TGraphDatas     graphDatas;
 359                         nlRead(__message, serial, graphDatas);
 360                 graphUpdate(sender, graphDatas);
 361         }
 362
 363         void CAdminExecutorServiceSkel::highRezGraphUpdate_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 364         {
 365                 H_AUTO(CAdminExecutorServiceSkel_highRezGraphUpdate_HRGU);
 366                 THighRezDatas   graphDatas;
 367                         nlRead(__message, serial, graphDatas);
 368                 highRezGraphUpdate(sender, graphDatas);
 369         }
 370
 371         void CAdminExecutorServiceSkel::serviceStatusUpdate_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 372         {
 373                 H_AUTO(CAdminExecutorServiceSkel_serviceStatusUpdate_SSU);
 374                 std::string     status;
 375                         nlRead(__message, serial, status);
 376                 serviceStatusUpdate(sender, status);
 377         }
 378                 // AS send orders for a shard
 379         void CAdminExecutorServiceProxy::setShardOrders(NLNET::IModule *sender, const std::string &shardName, const TShardOrders &shardOrders)
 380         {
 381                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 382                 {
 383                         // immediate local synchronous dispatching
 384                         _LocalModuleSkel->setShardOrders(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), shardName, shardOrders);
 385                 }
 386                 else
 387                 {
 388                         // send the message for remote dispatching and execution or local queing
 389                         NLNET::CMessage __message;
 390
 391                         buildMessageFor_setShardOrders(__message, shardName, shardOrders);
 392
 393                         _ModuleProxy->sendModuleMessage(sender, __message);
 394                 }
 395         }
 396                 // AS send a command to shutdown a shard with a delay
 397         void CAdminExecutorServiceProxy::shutdownShard(NLNET::IModule *sender, const std::string &shardName, uint32 delay)
 398         {
 399                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 400                 {
 401                         // immediate local synchronous dispatching
 402                         _LocalModuleSkel->shutdownShard(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), shardName, delay);
 403                 }
 404                 else
 405                 {
 406                         // send the message for remote dispatching and execution or local queing
 407                         NLNET::CMessage __message;
 408
 409                         buildMessageFor_shutdownShard(__message, shardName, delay);
 410
 411                         _ModuleProxy->sendModuleMessage(sender, __message);
 412                 }
 413         }
 414                 // AS send a control command to this AES
 415         void CAdminExecutorServiceProxy::controlCmd(NLNET::IModule *sender, uint32 commandId, const std::string &serviceAlias, const std::string &command)
 416         {
 417                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 418                 {
 419                         // immediate local synchronous dispatching
 420                         _LocalModuleSkel->controlCmd(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), commandId, serviceAlias, command);
 421                 }
 422                 else
 423                 {
 424                         // send the message for remote dispatching and execution or local queing
 425                         NLNET::CMessage __message;
 426
 427                         buildMessageFor_controlCmd(__message, commandId, serviceAlias, command);
 428
 429                         _ModuleProxy->sendModuleMessage(sender, __message);
 430                 }
 431         }
 432                 // Send a command to a service.
 433         void CAdminExecutorServiceProxy::serviceCmd(NLNET::IModule *sender, uint32 commandId, const std::string &serviceAlias, const std::string &command)
 434         {
 435                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 436                 {
 437                         // immediate local synchronous dispatching
 438                         _LocalModuleSkel->serviceCmd(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), commandId, serviceAlias, command);
 439                 }
 440                 else
 441                 {
 442                         // send the message for remote dispatching and execution or local queing
 443                         NLNET::CMessage __message;
 444
 445                         buildMessageFor_serviceCmd(__message, commandId, serviceAlias, command);
 446
 447                         _ModuleProxy->sendModuleMessage(sender, __message);
 448                 }
 449         }
 450                 // AES client send back the result of execution of a command
 451         void CAdminExecutorServiceProxy::commandResult(NLNET::IModule *sender, uint32 commandId, const std::string &serviceAlias, const std::string &result)
 452         {
 453                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 454                 {
 455                         // immediate local synchronous dispatching
 456                         _LocalModuleSkel->commandResult(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), commandId, serviceAlias, result);
 457                 }
 458                 else
 459                 {
 460                         // send the message for remote dispatching and execution or local queing
 461                         NLNET::CMessage __message;
 462
 463                         buildMessageFor_commandResult(__message, commandId, serviceAlias, result);
 464
 465                         _ModuleProxy->sendModuleMessage(sender, __message);
 466                 }
 467         }
 468                 // A service send graph data update
 469         void CAdminExecutorServiceProxy::graphUpdate(NLNET::IModule *sender, const TGraphDatas &graphDatas)
 470         {
 471                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 472                 {
 473                         // immediate local synchronous dispatching
 474                         _LocalModuleSkel->graphUpdate(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), graphDatas);
 475                 }
 476                 else
 477                 {
 478                         // send the message for remote dispatching and execution or local queing
 479                         NLNET::CMessage __message;
 480
 481                         buildMessageFor_graphUpdate(__message, graphDatas);
 482
 483                         _ModuleProxy->sendModuleMessage(sender, __message);
 484                 }
 485         }
 486                 // A service high rez graph data update
 487         void CAdminExecutorServiceProxy::highRezGraphUpdate(NLNET::IModule *sender, const THighRezDatas &graphDatas)
 488         {
 489                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 490                 {
 491                         // immediate local synchronous dispatching
 492                         _LocalModuleSkel->highRezGraphUpdate(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), graphDatas);
 493                 }
 494                 else
 495                 {
 496                         // send the message for remote dispatching and execution or local queing
 497                         NLNET::CMessage __message;
 498
 499                         buildMessageFor_highRezGraphUpdate(__message, graphDatas);
 500
 501                         _ModuleProxy->sendModuleMessage(sender, __message);
 502                 }
 503         }
 504                 // A service send an update of of it's status string
 505         void CAdminExecutorServiceProxy::serviceStatusUpdate(NLNET::IModule *sender, const std::string &status)
 506         {
 507                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 508                 {
 509                         // immediate local synchronous dispatching
 510                         _LocalModuleSkel->serviceStatusUpdate(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), status);
 511                 }
 512                 else
 513                 {
 514                         // send the message for remote dispatching and execution or local queing
 515                         NLNET::CMessage __message;
 516
 517                         buildMessageFor_serviceStatusUpdate(__message, status);
 518
 519                         _ModuleProxy->sendModuleMessage(sender, __message);
 520                 }
 521         }
 522
 523         // Message serializer. Return the message received in reference for easier integration
 524         const NLNET::CMessage &CAdminExecutorServiceProxy::buildMessageFor_setShardOrders(NLNET::CMessage &__message, const std::string &shardName, const TShardOrders &shardOrders)
 525         {
 526                 __message.setType("SCO");
 527                         nlWrite(__message, serial, const_cast < std::string& > (shardName));
 528                         nlWrite(__message, serial, shardOrders);
 529
 530
 531                 return __message;
 532         }
 533
 534         // Message serializer. Return the message received in reference for easier integration
 535         const NLNET::CMessage &CAdminExecutorServiceProxy::buildMessageFor_shutdownShard(NLNET::CMessage &__message, const std::string &shardName, uint32 delay)
 536         {
 537                 __message.setType("SDS");
 538                         nlWrite(__message, serial, const_cast < std::string& > (shardName));
 539                         nlWrite(__message, serial, delay);
 540
 541
 542                 return __message;
 543         }
 544
 545         // Message serializer. Return the message received in reference for easier integration
 546         const NLNET::CMessage &CAdminExecutorServiceProxy::buildMessageFor_controlCmd(NLNET::CMessage &__message, uint32 commandId, const std::string &serviceAlias, const std::string &command)
 547         {
 548                 __message.setType("CC");
 549                         nlWrite(__message, serial, commandId);
 550                         nlWrite(__message, serial, const_cast < std::string& > (serviceAlias));
 551                         nlWrite(__message, serial, const_cast < std::string& > (command));
 552
 553
 554                 return __message;
 555         }
 556
 557         // Message serializer. Return the message received in reference for easier integration
 558         const NLNET::CMessage &CAdminExecutorServiceProxy::buildMessageFor_serviceCmd(NLNET::CMessage &__message, uint32 commandId, const std::string &serviceAlias, const std::string &command)
 559         {
 560                 __message.setType("SCMD");
 561                         nlWrite(__message, serial, commandId);
 562                         nlWrite(__message, serial, const_cast < std::string& > (serviceAlias));
 563                         nlWrite(__message, serial, const_cast < std::string& > (command));
 564
 565
 566                 return __message;
 567         }
 568
 569         // Message serializer. Return the message received in reference for easier integration
 570         const NLNET::CMessage &CAdminExecutorServiceProxy::buildMessageFor_commandResult(NLNET::CMessage &__message, uint32 commandId, const std::string &serviceAlias, const std::string &result)
 571         {
 572                 __message.setType("CR");
 573                         nlWrite(__message, serial, commandId);
 574                         nlWrite(__message, serial, const_cast < std::string& > (serviceAlias));
 575                         nlWrite(__message, serial, const_cast < std::string& > (result));
 576
 577
 578                 return __message;
 579         }
 580
 581         // Message serializer. Return the message received in reference for easier integration
 582         const NLNET::CMessage &CAdminExecutorServiceProxy::buildMessageFor_graphUpdate(NLNET::CMessage &__message, const TGraphDatas &graphDatas)
 583         {
 584                 __message.setType("GU");
 585                         nlWrite(__message, serial, const_cast < TGraphDatas& > (graphDatas));
 586
 587
 588                 return __message;
 589         }
 590
 591         // Message serializer. Return the message received in reference for easier integration
 592         const NLNET::CMessage &CAdminExecutorServiceProxy::buildMessageFor_highRezGraphUpdate(NLNET::CMessage &__message, const THighRezDatas &graphDatas)
 593         {
 594                 __message.setType("HRGU");
 595                         nlWrite(__message, serial, const_cast < THighRezDatas& > (graphDatas));
 596
 597
 598                 return __message;
 599         }
 600
 601         // Message serializer. Return the message received in reference for easier integration
 602         const NLNET::CMessage &CAdminExecutorServiceProxy::buildMessageFor_serviceStatusUpdate(NLNET::CMessage &__message, const std::string &status)
 603         {
 604                 __message.setType("SSU");
 605                         nlWrite(__message, serial, const_cast < std::string& > (status));
 606
 607
 608                 return __message;
 609         }
 610
 611         /////////////////////////////////////////////////////////////////
 612         // WARNING : this is a generated file, don't change it !
 613         /////////////////////////////////////////////////////////////////
 614
 615
 616         const CAdminExecutorServiceClientSkel::TMessageHandlerMap &CAdminExecutorServiceClientSkel::getMessageHandlers() const
 617         {
 618                 static TMessageHandlerMap handlers;
 619                 static bool init = false;
 620
 621                 if (!init)
 622                 {
 623                         std::pair < TMessageHandlerMap::iterator, bool > res;
 624
 625                         res = handlers.insert(std::make_pair(std::string("SCMD"), &CAdminExecutorServiceClientSkel::serviceCmd_skel));
 626                         // if this assert, you have a doubly message name in your interface definition !
 627                         nlassert(res.second);
 628
 629                         res = handlers.insert(std::make_pair(std::string("SCMDNR"), &CAdminExecutorServiceClientSkel::serviceCmdNoReturn_skel));
 630                         // if this assert, you have a doubly message name in your interface definition !
 631                         nlassert(res.second);
 632
 633                         init = true;
 634                 }
 635
 636                 return handlers;
 637         }
 638         bool CAdminExecutorServiceClientSkel::fwdOnProcessModuleMessage(NLNET::IModuleProxy *sender, const NLNET::CMessage &message)
 639         {
 640                 const TMessageHandlerMap &mh = getMessageHandlers();
 641
 642                 TMessageHandlerMap::const_iterator it(mh.find(message.getName()));
 643
 644                 if (it == mh.end())
 645                 {
 646                         return false;
 647                 }
 648
 649                 TMessageHandler cmd = it->second;
 650                 (this->*cmd)(sender, message);
 651
 652                 return true;
 653         }
 654
 655
 656         void CAdminExecutorServiceClientSkel::serviceCmd_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 657         {
 658                 H_AUTO(CAdminExecutorServiceClientSkel_serviceCmd_SCMD);
 659                 uint32  commandId;
 660                         nlRead(__message, serial, commandId);
 661                 std::string     command;
 662                         nlRead(__message, serial, command);
 663                 serviceCmd(sender, commandId, command);
 664         }
 665
 666         void CAdminExecutorServiceClientSkel::serviceCmdNoReturn_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 667         {
 668                 H_AUTO(CAdminExecutorServiceClientSkel_serviceCmdNoReturn_SCMDNR);
 669                 std::string     command;
 670                         nlRead(__message, serial, command);
 671                 serviceCmdNoReturn(sender, command);
 672         }
 673                 // execute a command and return the result.
 674         void CAdminExecutorServiceClientProxy::serviceCmd(NLNET::IModule *sender, uint32 commandId, const std::string &command)
 675         {
 676                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 677                 {
 678                         // immediate local synchronous dispatching
 679                         _LocalModuleSkel->serviceCmd(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), commandId, command);
 680                 }
 681                 else
 682                 {
 683                         // send the message for remote dispatching and execution or local queing
 684                         NLNET::CMessage __message;
 685
 686                         buildMessageFor_serviceCmd(__message, commandId, command);
 687
 688                         _ModuleProxy->sendModuleMessage(sender, __message);
 689                 }
 690         }
 691                 // Send a command to a service without waiting for the return value.
 692         void CAdminExecutorServiceClientProxy::serviceCmdNoReturn(NLNET::IModule *sender, const std::string &command)
 693         {
 694                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 695                 {
 696                         // immediate local synchronous dispatching
 697                         _LocalModuleSkel->serviceCmdNoReturn(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), command);
 698                 }
 699                 else
 700                 {
 701                         // send the message for remote dispatching and execution or local queing
 702                         NLNET::CMessage __message;
 703
 704                         buildMessageFor_serviceCmdNoReturn(__message, command);
 705
 706                         _ModuleProxy->sendModuleMessage(sender, __message);
 707                 }
 708         }
 709
 710         // Message serializer. Return the message received in reference for easier integration
 711         const NLNET::CMessage &CAdminExecutorServiceClientProxy::buildMessageFor_serviceCmd(NLNET::CMessage &__message, uint32 commandId, const std::string &command)
 712         {
 713                 __message.setType("SCMD");
 714                         nlWrite(__message, serial, commandId);
 715                         nlWrite(__message, serial, const_cast < std::string& > (command));
 716
 717
 718                 return __message;
 719         }
 720
 721         // Message serializer. Return the message received in reference for easier integration
 722         const NLNET::CMessage &CAdminExecutorServiceClientProxy::buildMessageFor_serviceCmdNoReturn(NLNET::CMessage &__message, const std::string &command)
 723         {
 724                 __message.setType("SCMDNR");
 725                         nlWrite(__message, serial, const_cast < std::string& > (command));
 726
 727
 728                 return __message;
 729         }
 730
 731 }