nelns/welcome_service/welcome_service_itf.cpp

   1
   2 /////////////////////////////////////////////////////////////////
   3 // WARNING : this is a generated file, don't change it !
   4 /////////////////////////////////////////////////////////////////
   5
   6 #include "welcome_service_itf.h"
   7
   8 namespace WS
   9 {
  10
  11         /////////////////////////////////////////////////////////////////
  12         // WARNING : this is a generated file, don't change it !
  13         /////////////////////////////////////////////////////////////////
  14
  15
  16         const CWelcomeServiceSkel::TMessageHandlerMap &CWelcomeServiceSkel::getMessageHandlers() const
  17         {
  18                 static TMessageHandlerMap handlers;
  19                 static bool init = false;
  20
  21                 if (!init)
  22                 {
  23                         std::pair < TMessageHandlerMap::iterator, bool > res;
  24
  25                         res = handlers.insert(std::make_pair(std::string("WU"), &CWelcomeServiceSkel::welcomeUser_skel));
  26                         // if this assert, you have a doubly message name in your interface definition !
  27                         nlassert(res.second);
  28
  29                         res = handlers.insert(std::make_pair(std::string("DU"), &CWelcomeServiceSkel::disconnectUser_skel));
  30                         // if this assert, you have a doubly message name in your interface definition !
  31                         nlassert(res.second);
  32
  33                         init = true;
  34                 }
  35
  36                 return handlers;
  37         }
  38         bool CWelcomeServiceSkel::fwdOnProcessModuleMessage(NLNET::IModuleProxy *sender, const NLNET::CMessage &message)
  39         {
  40                 const TMessageHandlerMap &mh = getMessageHandlers();
  41
  42                 TMessageHandlerMap::const_iterator it(mh.find(message.getName()));
  43
  44                 if (it == mh.end())
  45                 {
  46                         return false;
  47                 }
  48
  49                 TMessageHandler cmd = it->second;
  50                 (this->*cmd)(sender, message);
  51
  52                 return true;
  53         }
  54
  55
  56         void CWelcomeServiceSkel::welcomeUser_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
  57         {
  58                 H_AUTO(CWelcomeServiceSkel_welcomeUser_WU);
  59                 uint32  charId;
  60                         nlRead(__message, serial, charId);
  61                 std::string     userName;
  62                         nlRead(__message, serial, userName);
  63                 NLNET::CLoginCookie     cookie;
  64                         nlRead(__message, serial, cookie);
  65                 std::string     priviledge;
  66                         nlRead(__message, serial, priviledge);
  67                 std::string     exPriviledge;
  68                         nlRead(__message, serial, exPriviledge);
  69                 WS::TUserRole   mode;
  70                         nlRead(__message, serial, mode);
  71                 uint32  instanceId;
  72                         nlRead(__message, serial, instanceId);
  73                 welcomeUser(sender, charId, userName, cookie, priviledge, exPriviledge, mode, instanceId);
  74         }
  75
  76         void CWelcomeServiceSkel::disconnectUser_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
  77         {
  78                 H_AUTO(CWelcomeServiceSkel_disconnectUser_DU);
  79                 uint32  userId;
  80                         nlRead(__message, serial, userId);
  81                 disconnectUser(sender, userId);
  82         }
  83                 // ask the welcome service to welcome a character
  84         void CWelcomeServiceProxy::welcomeUser(NLNET::IModule *sender, uint32 charId, const std::string &userName, const NLNET::CLoginCookie &cookie, const std::string &priviledge, const std::string &exPriviledge, WS::TUserRole mode, uint32 instanceId)
  85         {
  86                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
  87                 {
  88                         // immediate local synchronous dispatching
  89                         _LocalModuleSkel->welcomeUser(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), charId, userName, cookie, priviledge, exPriviledge, mode, instanceId);
  90                 }
  91                 else
  92                 {
  93                         // send the message for remote dispatching and execution or local queing
  94                         NLNET::CMessage __message;
  95
  96                         buildMessageFor_welcomeUser(__message, charId, userName, cookie, priviledge, exPriviledge, mode, instanceId);
  97
  98                         _ModuleProxy->sendModuleMessage(sender, __message);
  99                 }
 100         }
 101                 // ask the welcome service to disconnect a user
 102         void CWelcomeServiceProxy::disconnectUser(NLNET::IModule *sender, uint32 userId)
 103         {
 104                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 105                 {
 106                         // immediate local synchronous dispatching
 107                         _LocalModuleSkel->disconnectUser(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), userId);
 108                 }
 109                 else
 110                 {
 111                         // send the message for remote dispatching and execution or local queing
 112                         NLNET::CMessage __message;
 113
 114                         buildMessageFor_disconnectUser(__message, userId);
 115
 116                         _ModuleProxy->sendModuleMessage(sender, __message);
 117                 }
 118         }
 119
 120         // Message serializer. Return the message received in reference for easier integration
 121         const NLNET::CMessage &CWelcomeServiceProxy::buildMessageFor_welcomeUser(NLNET::CMessage &__message, uint32 charId, const std::string &userName, const NLNET::CLoginCookie &cookie, const std::string &priviledge, const std::string &exPriviledge, WS::TUserRole mode, uint32 instanceId)
 122         {
 123                 __message.setType("WU");
 124                         nlWrite(__message, serial, charId);
 125                         nlWrite(__message, serial, const_cast < std::string& > (userName));
 126                         nlWrite(__message, serial, const_cast < NLNET::CLoginCookie& > (cookie));
 127                         nlWrite(__message, serial, const_cast < std::string& > (priviledge));
 128                         nlWrite(__message, serial, const_cast < std::string& > (exPriviledge));
 129                         nlWrite(__message, serial, mode);
 130                         nlWrite(__message, serial, instanceId);
 131
 132
 133                 return __message;
 134         }
 135
 136         // Message serializer. Return the message received in reference for easier integration
 137         const NLNET::CMessage &CWelcomeServiceProxy::buildMessageFor_disconnectUser(NLNET::CMessage &__message, uint32 userId)
 138         {
 139                 __message.setType("DU");
 140                         nlWrite(__message, serial, userId);
 141
 142
 143                 return __message;
 144         }
 145
 146         /////////////////////////////////////////////////////////////////
 147         // WARNING : this is a generated file, don't change it !
 148         /////////////////////////////////////////////////////////////////
 149
 150
 151         const CLoginServiceSkel::TMessageHandlerMap &CLoginServiceSkel::getMessageHandlers() const
 152         {
 153                 static TMessageHandlerMap handlers;
 154                 static bool init = false;
 155
 156                 if (!init)
 157                 {
 158                         std::pair < TMessageHandlerMap::iterator, bool > res;
 159
 160                         res = handlers.insert(std::make_pair(std::string("PUL"), &CLoginServiceSkel::pendingUserLost_skel));
 161                         // if this assert, you have a doubly message name in your interface definition !
 162                         nlassert(res.second);
 163
 164                         init = true;
 165                 }
 166
 167                 return handlers;
 168         }
 169         bool CLoginServiceSkel::fwdOnProcessModuleMessage(NLNET::IModuleProxy *sender, const NLNET::CMessage &message)
 170         {
 171                 const TMessageHandlerMap &mh = getMessageHandlers();
 172
 173                 TMessageHandlerMap::const_iterator it(mh.find(message.getName()));
 174
 175                 if (it == mh.end())
 176                 {
 177                         return false;
 178                 }
 179
 180                 TMessageHandler cmd = it->second;
 181                 (this->*cmd)(sender, message);
 182
 183                 return true;
 184         }
 185
 186
 187         void CLoginServiceSkel::pendingUserLost_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 188         {
 189                 H_AUTO(CLoginServiceSkel_pendingUserLost_PUL);
 190                 NLNET::CLoginCookie     cookie;
 191                         nlRead(__message, serial, cookie);
 192                 pendingUserLost(sender, cookie);
 193         }
 194                 // An awaited user did not connect before the allowed timeout expire
 195         void CLoginServiceProxy::pendingUserLost(NLNET::IModule *sender, const NLNET::CLoginCookie &cookie)
 196         {
 197                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 198                 {
 199                         // immediate local synchronous dispatching
 200                         _LocalModuleSkel->pendingUserLost(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), cookie);
 201                 }
 202                 else
 203                 {
 204                         // send the message for remote dispatching and execution or local queing
 205                         NLNET::CMessage __message;
 206
 207                         buildMessageFor_pendingUserLost(__message, cookie);
 208
 209                         _ModuleProxy->sendModuleMessage(sender, __message);
 210                 }
 211         }
 212
 213         // Message serializer. Return the message received in reference for easier integration
 214         const NLNET::CMessage &CLoginServiceProxy::buildMessageFor_pendingUserLost(NLNET::CMessage &__message, const NLNET::CLoginCookie &cookie)
 215         {
 216                 __message.setType("PUL");
 217                         nlWrite(__message, serial, const_cast < NLNET::CLoginCookie& > (cookie));
 218
 219
 220                 return __message;
 221         }
 222
 223         /////////////////////////////////////////////////////////////////
 224         // WARNING : this is a generated file, don't change it !
 225         /////////////////////////////////////////////////////////////////
 226
 227
 228         const CWelcomeServiceClientSkel::TMessageHandlerMap &CWelcomeServiceClientSkel::getMessageHandlers() const
 229         {
 230                 static TMessageHandlerMap handlers;
 231                 static bool init = false;
 232
 233                 if (!init)
 234                 {
 235                         std::pair < TMessageHandlerMap::iterator, bool > res;
 236
 237                         res = handlers.insert(std::make_pair(std::string("RWS"), &CWelcomeServiceClientSkel::registerWS_skel));
 238                         // if this assert, you have a doubly message name in your interface definition !
 239                         nlassert(res.second);
 240
 241                         res = handlers.insert(std::make_pair(std::string("RWSOS"), &CWelcomeServiceClientSkel::reportWSOpenState_skel));
 242                         // if this assert, you have a doubly message name in your interface definition !
 243                         nlassert(res.second);
 244
 245                         res = handlers.insert(std::make_pair(std::string("WUR"), &CWelcomeServiceClientSkel::welcomeUserResult_skel));
 246                         // if this assert, you have a doubly message name in your interface definition !
 247                         nlassert(res.second);
 248
 249                         res = handlers.insert(std::make_pair(std::string("UCP"), &CWelcomeServiceClientSkel::updateConnectedPlayerCount_skel));
 250                         // if this assert, you have a doubly message name in your interface definition !
 251                         nlassert(res.second);
 252
 253                         init = true;
 254                 }
 255
 256                 return handlers;
 257         }
 258         bool CWelcomeServiceClientSkel::fwdOnProcessModuleMessage(NLNET::IModuleProxy *sender, const NLNET::CMessage &message)
 259         {
 260                 const TMessageHandlerMap &mh = getMessageHandlers();
 261
 262                 TMessageHandlerMap::const_iterator it(mh.find(message.getName()));
 263
 264                 if (it == mh.end())
 265                 {
 266                         return false;
 267                 }
 268
 269                 TMessageHandler cmd = it->second;
 270                 (this->*cmd)(sender, message);
 271
 272                 return true;
 273         }
 274
 275
 276         void CWelcomeServiceClientSkel::registerWS_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 277         {
 278                 H_AUTO(CWelcomeServiceClientSkel_registerWS_RWS);
 279                 uint32  shardId;
 280                         nlRead(__message, serial, shardId);
 281                 uint32  fixedSessionId;
 282                         nlRead(__message, serial, fixedSessionId);
 283                 bool    isOnline;
 284                         nlRead(__message, serial, isOnline);
 285                 registerWS(sender, shardId, fixedSessionId, isOnline);
 286         }
 287
 288         void CWelcomeServiceClientSkel::reportWSOpenState_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 289         {
 290                 H_AUTO(CWelcomeServiceClientSkel_reportWSOpenState_RWSOS);
 291                 bool    isOnline;
 292                         nlRead(__message, serial, isOnline);
 293                 reportWSOpenState(sender, isOnline);
 294         }
 295
 296         void CWelcomeServiceClientSkel::welcomeUserResult_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 297         {
 298                 H_AUTO(CWelcomeServiceClientSkel_welcomeUserResult_WUR);
 299                 uint32  userId;
 300                         nlRead(__message, serial, userId);
 301                 bool    ok;
 302                         nlRead(__message, serial, ok);
 303                 std::string     shardAddr;
 304                         nlRead(__message, serial, shardAddr);
 305                 std::string     errorMsg;
 306                         nlRead(__message, serial, errorMsg);
 307                 welcomeUserResult(sender, userId, ok, shardAddr, errorMsg);
 308         }
 309
 310         void CWelcomeServiceClientSkel::updateConnectedPlayerCount_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 311         {
 312                 H_AUTO(CWelcomeServiceClientSkel_updateConnectedPlayerCount_UCP);
 313                 uint32  nbOnlinePlayers;
 314                         nlRead(__message, serial, nbOnlinePlayers);
 315                 uint32  nbPendingPlayers;
 316                         nlRead(__message, serial, nbPendingPlayers);
 317                 updateConnectedPlayerCount(sender, nbOnlinePlayers, nbPendingPlayers);
 318         }
 319                 // Register the welcome service in the ring session manager
 320                 // The provided sessionId will be non-zero only for a shard with a fixed sessionId
 321         void CWelcomeServiceClientProxy::registerWS(NLNET::IModule *sender, uint32 shardId, uint32 fixedSessionId, bool isOnline)
 322         {
 323                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 324                 {
 325                         // immediate local synchronous dispatching
 326                         _LocalModuleSkel->registerWS(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), shardId, fixedSessionId, isOnline);
 327                 }
 328                 else
 329                 {
 330                         // send the message for remote dispatching and execution or local queing
 331                         NLNET::CMessage __message;
 332
 333                         buildMessageFor_registerWS(__message, shardId, fixedSessionId, isOnline);
 334
 335                         _ModuleProxy->sendModuleMessage(sender, __message);
 336                 }
 337         }
 338                 // WS report it's current open state
 339         void CWelcomeServiceClientProxy::reportWSOpenState(NLNET::IModule *sender, bool isOnline)
 340         {
 341                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 342                 {
 343                         // immediate local synchronous dispatching
 344                         _LocalModuleSkel->reportWSOpenState(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), isOnline);
 345                 }
 346                 else
 347                 {
 348                         // send the message for remote dispatching and execution or local queing
 349                         NLNET::CMessage __message;
 350
 351                         buildMessageFor_reportWSOpenState(__message, isOnline);
 352
 353                         _ModuleProxy->sendModuleMessage(sender, __message);
 354                 }
 355         }
 356                 // return for welcome user
 357         void CWelcomeServiceClientProxy::welcomeUserResult(NLNET::IModule *sender, uint32 userId, bool ok, const std::string &shardAddr, const std::string &errorMsg)
 358         {
 359                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 360                 {
 361                         // immediate local synchronous dispatching
 362                         _LocalModuleSkel->welcomeUserResult(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), userId, ok, shardAddr, errorMsg);
 363                 }
 364                 else
 365                 {
 366                         // send the message for remote dispatching and execution or local queing
 367                         NLNET::CMessage __message;
 368
 369                         buildMessageFor_welcomeUserResult(__message, userId, ok, shardAddr, errorMsg);
 370
 371                         _ModuleProxy->sendModuleMessage(sender, __message);
 372                 }
 373         }
 374                 // transmits the current player counts
 375         void CWelcomeServiceClientProxy::updateConnectedPlayerCount(NLNET::IModule *sender, uint32 nbOnlinePlayers, uint32 nbPendingPlayers)
 376         {
 377                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 378                 {
 379                         // immediate local synchronous dispatching
 380                         _LocalModuleSkel->updateConnectedPlayerCount(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), nbOnlinePlayers, nbPendingPlayers);
 381                 }
 382                 else
 383                 {
 384                         // send the message for remote dispatching and execution or local queing
 385                         NLNET::CMessage __message;
 386
 387                         buildMessageFor_updateConnectedPlayerCount(__message, nbOnlinePlayers, nbPendingPlayers);
 388
 389                         _ModuleProxy->sendModuleMessage(sender, __message);
 390                 }
 391         }
 392
 393         // Message serializer. Return the message received in reference for easier integration
 394         const NLNET::CMessage &CWelcomeServiceClientProxy::buildMessageFor_registerWS(NLNET::CMessage &__message, uint32 shardId, uint32 fixedSessionId, bool isOnline)
 395         {
 396                 __message.setType("RWS");
 397                         nlWrite(__message, serial, shardId);
 398                         nlWrite(__message, serial, fixedSessionId);
 399                         nlWrite(__message, serial, isOnline);
 400
 401
 402                 return __message;
 403         }
 404
 405         // Message serializer. Return the message received in reference for easier integration
 406         const NLNET::CMessage &CWelcomeServiceClientProxy::buildMessageFor_reportWSOpenState(NLNET::CMessage &__message, bool isOnline)
 407         {
 408                 __message.setType("RWSOS");
 409                         nlWrite(__message, serial, isOnline);
 410
 411
 412                 return __message;
 413         }
 414
 415         // Message serializer. Return the message received in reference for easier integration
 416         const NLNET::CMessage &CWelcomeServiceClientProxy::buildMessageFor_welcomeUserResult(NLNET::CMessage &__message, uint32 userId, bool ok, const std::string &shardAddr, const std::string &errorMsg)
 417         {
 418                 __message.setType("WUR");
 419                         nlWrite(__message, serial, userId);
 420                         nlWrite(__message, serial, ok);
 421                         nlWrite(__message, serial, const_cast < std::string& > (shardAddr));
 422                         nlWrite(__message, serial, const_cast < std::string& > (errorMsg));
 423
 424
 425                 return __message;
 426         }
 427
 428         // Message serializer. Return the message received in reference for easier integration
 429         const NLNET::CMessage &CWelcomeServiceClientProxy::buildMessageFor_updateConnectedPlayerCount(NLNET::CMessage &__message, uint32 nbOnlinePlayers, uint32 nbPendingPlayers)
 430         {
 431                 __message.setType("UCP");
 432                         nlWrite(__message, serial, nbOnlinePlayers);
 433                         nlWrite(__message, serial, nbPendingPlayers);
 434
 435
 436                 return __message;
 437         }
 438
 439 }