ryzom/server/src/server_share/logger_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 "logger_service_itf.h"
  24
  25 namespace LGS
  26 {
  27
  28         /////////////////////////////////////////////////////////////////
  29         // WARNING : this is a generated file, don't change it !
  30         /////////////////////////////////////////////////////////////////
  31
  32
  33         const CLoggerServiceSkel::TMessageHandlerMap &CLoggerServiceSkel::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("RC"), &CLoggerServiceSkel::registerClient_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("LG"), &CLoggerServiceSkel::reportLog_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 CLoggerServiceSkel::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 CLoggerServiceSkel::registerClient_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
  74         {
  75                 H_AUTO(CLoggerServiceSkel_registerClient_RC);
  76                 uint32  shardId;
  77                         nlRead(__message, serial, shardId);
  78                 std::vector < TLogDefinition >  logDef;
  79                         nlRead(__message, serialCont, logDef);
  80                 registerClient(sender, shardId, logDef);
  81         }
  82
  83         void CLoggerServiceSkel::reportLog_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
  84         {
  85                 H_AUTO(CLoggerServiceSkel_reportLog_LG);
  86                 std::vector < TLogInfo >        logInfos;
  87                         nlRead(__message, serialCont, logInfos);
  88                 reportLog(sender, logInfos);
  89         }
  90                 // A logger client register itself wy providing it's definition of
  91                 // the log content. It is mandatory that ALL client share
  92                 // Exactly the same definition of log.
  93         void CLoggerServiceProxy::registerClient(NLNET::IModule *sender, uint32 shardId, const std::vector < TLogDefinition > &logDef)
  94         {
  95                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
  96                 {
  97                         // immediate local synchronous dispatching
  98                         _LocalModuleSkel->registerClient(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), shardId, logDef);
  99                 }
 100                 else
 101                 {
 102                         // send the message for remote dispatching and execution or local queing
 103                         NLNET::CMessage __message;
 104
 105                         buildMessageFor_registerClient(__message, shardId, logDef);
 106
 107                         _ModuleProxy->sendModuleMessage(sender, __message);
 108                 }
 109         }
 110                 // A client send a log
 111         void CLoggerServiceProxy::reportLog(NLNET::IModule *sender, const std::vector < TLogInfo > &logInfos)
 112         {
 113                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 114                 {
 115                         // immediate local synchronous dispatching
 116                         _LocalModuleSkel->reportLog(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), logInfos);
 117                 }
 118                 else
 119                 {
 120                         // send the message for remote dispatching and execution or local queing
 121                         NLNET::CMessage __message;
 122
 123                         buildMessageFor_reportLog(__message, logInfos);
 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 &CLoggerServiceProxy::buildMessageFor_registerClient(NLNET::CMessage &__message, uint32 shardId, const std::vector < TLogDefinition > &logDef)
 131         {
 132                 __message.setType("RC");
 133                         nlWrite(__message, serial, shardId);
 134                         nlWrite(__message, serialCont, const_cast < std::vector < TLogDefinition >& > (logDef));
 135
 136
 137                 return __message;
 138         }
 139
 140         // Message serializer. Return the message received in reference for easier integration
 141         const NLNET::CMessage &CLoggerServiceProxy::buildMessageFor_reportLog(NLNET::CMessage &__message, const std::vector < TLogInfo > &logInfos)
 142         {
 143                 __message.setType("LG");
 144                         nlWrite(__message, serialCont, const_cast < std::vector < TLogInfo >& > (logInfos));
 145
 146
 147                 return __message;
 148         }
 149
 150 }