nel/src/misc/app_context.cpp

   1 // NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This source file has been modified by the following contributors:
   5 // Copyright (C) 2015-2020  Jan BOON (Kaetemi) <jan.boon@kaetemi.be>
   6 //
   7 // This program is free software: you can redistribute it and/or modify
   8 // it under the terms of the GNU Affero General Public License as
   9 // published by the Free Software Foundation, either version 3 of the
  10 // License, or (at your option) any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU Affero General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU Affero General Public License
  18 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19
  20 #include "stdmisc.h"
  21 #include "nel/misc/app_context.h"
  22 #include "nel/misc/dynloadlib.h"
  23 #include "nel/misc/command.h"
  24
  25 #include <locale.h>
  26
  27 #ifdef DEBUG_NEW
  28         #define new DEBUG_NEW
  29 #endif
  30
  31 namespace NLMISC
  32 {
  33
  34 //INelContext *NelContext = NULL;
  35 INelContext *INelContext::_NelContext = NULL;
  36
  37 INelContext ** INelContext::_getInstance()
  38 {
  39         static INelContext *nelContext = NULL;
  40
  41         return &nelContext;
  42 }
  43
  44
  45 INelContext &INelContext::getInstance()
  46 {
  47         if (*(_getInstance()) == NULL)
  48         {
  49                 _NelContext = new CApplicationContext;
  50                 *(_getInstance()) = _NelContext;
  51         }
  52
  53         return *_NelContext;
  54 }
  55
  56 bool INelContext::isContextInitialised()
  57 {
  58         return (*_getInstance()) != NULL;
  59 }
  60
  61
  62 INelContext::~INelContext()
  63 {
  64         // unregister still undeleted local command into the global command registry
  65         if (ICommand::LocalCommands)
  66         {
  67                 ICommand::TCommand::iterator first(ICommand::LocalCommands->begin()), last(ICommand::LocalCommands->end());
  68                 for (; first != last; ++first)
  69                 {
  70                         ICommand *command = first->second;
  71                         CCommandRegistry::getInstance().unregisterCommand(command);
  72                 }
  73         }
  74
  75         CInstanceCounterLocalManager::releaseInstance();
  76
  77         _NelContext = NULL;
  78         *(_getInstance()) = NULL;
  79 }
  80
  81
  82
  83 void INelContext::contextReady()
  84 {
  85         // Register the NeL Context
  86         // This assert doesn't work for Linux due to ELF symbol relocation
  87 #ifdef NL_OS_WINDOWS
  88         nlassert(*(_getInstance()) == NULL);
  89 #endif // NL_OS_WINDOWS
  90         _NelContext = this;
  91         *(_getInstance()) = this;
  92
  93         // set numeric locale to C to avoid the use of decimal separators different of a dot
  94         char *locale = setlocale(LC_NUMERIC, "C");
  95
  96         // register any pending thinks
  97
  98         // register local instance counter in the global instance counter manager
  99         CInstanceCounterLocalManager::getInstance().registerLocalManager();
 100
 101         // register local commands into the global command registry (except it there is no command at all)
 102         if (ICommand::LocalCommands != NULL)
 103         {
 104                 ICommand::TCommand::iterator first(ICommand::LocalCommands->begin()), last(ICommand::LocalCommands->end());
 105                 for (; first != last; ++first)
 106                 {
 107                         CCommandRegistry::getInstance().registerCommand(first->second);
 108                 }
 109         }
 110 }
 111
 112 CApplicationContext::CApplicationContext()
 113 {
 114         // init
 115         ErrorLog = NULL;
 116         WarningLog = NULL;
 117         InfoLog = NULL;
 118         DebugLog = NULL;
 119         AssertLog = NULL;
 120         DefaultMemDisplayer = NULL;
 121         DefaultMsgBoxDisplayer = NULL;
 122         DebugNeedAssert = false;
 123         NoAssert = false;
 124         AlreadyCreateSharedAmongThreads = false;
 125         WindowedApplication = false;
 126
 127         contextReady();
 128 }
 129
 130 CApplicationContext::~CApplicationContext()
 131 {
 132 #ifdef NL_DEBUG
 133         TSingletonRegistry::iterator it = _SingletonRegistry.begin(), iend = _SingletonRegistry.end();
 134
 135         while (it != iend)
 136         {
 137                 // can't use nldebug there because it'll create new displayers
 138                 std::string message = toString("Instance '%s' still allocated at %p\n", it->first.c_str(), it->second);
 139
 140 #ifdef NL_OS_WINDOWS
 141                 OutputDebugStringW(nlUtf8ToWide(message));
 142 #else
 143                 printf("%s", message.c_str());
 144 #endif
 145
 146                 ++it;
 147         }
 148 #endif
 149 }
 150
 151 void *CApplicationContext::getSingletonPointer(const std::string &singletonName)
 152 {
 153         TSingletonRegistry::iterator it(_SingletonRegistry.find(singletonName));
 154         if (it != _SingletonRegistry.end())
 155                 return it->second;
 156
 157 //      nlwarning("Can't find singleton '%s'", singletonName.c_str());
 158         return NULL;
 159 }
 160
 161 void CApplicationContext::setSingletonPointer(const std::string &singletonName, void *ptr)
 162 {
 163         nlassert(_SingletonRegistry.find(singletonName) == _SingletonRegistry.end());
 164         _SingletonRegistry[singletonName] = ptr;
 165 }
 166
 167 void CApplicationContext::releaseSingletonPointer(const std::string &singletonName, void *ptr)
 168 {
 169         nlassert(_SingletonRegistry.find(singletonName) != _SingletonRegistry.end());
 170         nlassert(_SingletonRegistry.find(singletonName)->second == ptr);
 171         _SingletonRegistry.erase(singletonName);
 172 }
 173
 174
 175 CLog *CApplicationContext::getErrorLog()
 176 {
 177         return ErrorLog;
 178 }
 179
 180 void CApplicationContext::setErrorLog(CLog *errorLog)
 181 {
 182         ErrorLog = errorLog;
 183 }
 184
 185 CLog *CApplicationContext::getWarningLog()
 186 {
 187         return WarningLog;
 188 }
 189
 190 void CApplicationContext::setWarningLog(CLog *warningLog)
 191 {
 192         WarningLog = warningLog;
 193 }
 194
 195 CLog *CApplicationContext::getInfoLog()
 196 {
 197         return InfoLog;
 198 }
 199
 200 void CApplicationContext::setInfoLog(CLog *infoLog)
 201 {
 202         InfoLog = infoLog;
 203 }
 204
 205 CLog *CApplicationContext::getDebugLog()
 206 {
 207         return DebugLog;
 208 }
 209
 210 void CApplicationContext::setDebugLog(CLog *debugLog)
 211 {
 212         DebugLog = debugLog;
 213 }
 214
 215 CLog *CApplicationContext::getAssertLog()
 216 {
 217         return AssertLog;
 218 }
 219
 220 void CApplicationContext::setAssertLog(CLog *assertLog)
 221 {
 222         AssertLog = assertLog;
 223 }
 224
 225 CMemDisplayer *CApplicationContext::getDefaultMemDisplayer()
 226 {
 227         return DefaultMemDisplayer;
 228 }
 229
 230 void CApplicationContext::setDefaultMemDisplayer(CMemDisplayer *memDisplayer)
 231 {
 232         DefaultMemDisplayer = memDisplayer;
 233 }
 234
 235 CMsgBoxDisplayer *CApplicationContext::getDefaultMsgBoxDisplayer()
 236 {
 237         return DefaultMsgBoxDisplayer;
 238 }
 239
 240 void CApplicationContext::setDefaultMsgBoxDisplayer(CMsgBoxDisplayer *msgBoxDisplayer)
 241 {
 242         DefaultMsgBoxDisplayer = msgBoxDisplayer;
 243 }
 244
 245 bool CApplicationContext::getDebugNeedAssert()
 246 {
 247         return DebugNeedAssert;
 248 }
 249
 250 void CApplicationContext::setDebugNeedAssert(bool needAssert)
 251 {
 252         DebugNeedAssert = needAssert;
 253 }
 254
 255 bool CApplicationContext::getNoAssert()
 256 {
 257         return NoAssert;
 258 }
 259
 260 void CApplicationContext::setNoAssert(bool noAssert)
 261 {
 262         NoAssert = noAssert;
 263 }
 264
 265 bool CApplicationContext::getAlreadyCreateSharedAmongThreads()
 266 {
 267         return AlreadyCreateSharedAmongThreads;
 268 }
 269
 270 void CApplicationContext::setAlreadyCreateSharedAmongThreads(bool b)
 271 {
 272         AlreadyCreateSharedAmongThreads = b;
 273 }
 274
 275 bool CApplicationContext::isWindowedApplication()
 276 {
 277         return WindowedApplication;
 278 }
 279
 280 void CApplicationContext::setWindowedApplication(bool b)
 281 {
 282         WindowedApplication = b;
 283 }
 284
 285 CLibraryContext::CLibraryContext(INelContext &applicationContext)
 286 : _ApplicationContext(&applicationContext)
 287 {
 288         contextReady();
 289 }
 290
 291
 292 void *CLibraryContext::getSingletonPointer(const std::string &singletonName)
 293 {
 294 //      nlassert(_ApplicationContext != NULL);
 295
 296         // just forward the call
 297         return _ApplicationContext->getSingletonPointer(singletonName);
 298 }
 299
 300 void CLibraryContext::setSingletonPointer(const std::string &singletonName, void *ptr)
 301 {
 302 //      nlassert(_ApplicationContext != NULL);
 303
 304         // just forward the call
 305         _ApplicationContext->setSingletonPointer(singletonName, ptr);
 306 }
 307
 308 void CLibraryContext::releaseSingletonPointer(const std::string &singletonName, void *ptr)
 309 {
 310 //      nlassert(_ApplicationContext != NULL);
 311
 312         // just forward the call
 313         _ApplicationContext->releaseSingletonPointer(singletonName, ptr);
 314 }
 315
 316
 317 CLog *CLibraryContext::getErrorLog()
 318 {
 319 //      nlassert(_ApplicationContext != NULL);
 320
 321         // just forward the call
 322         return _ApplicationContext->getErrorLog();
 323 }
 324
 325 void CLibraryContext::setErrorLog(CLog *errorLog)
 326 {
 327 //      nlassert(_ApplicationContext != NULL);
 328
 329         // just forward the call
 330         _ApplicationContext->setErrorLog(errorLog);
 331 }
 332
 333 CLog *CLibraryContext::getWarningLog()
 334 {
 335 //      nlassert(_ApplicationContext != NULL);
 336
 337         // just forward the call
 338         return _ApplicationContext->getWarningLog();
 339 }
 340
 341 void CLibraryContext::setWarningLog(CLog *warningLog)
 342 {
 343 //      nlassert(_ApplicationContext != NULL);
 344
 345         // just forward the call
 346         _ApplicationContext->setWarningLog(warningLog);
 347 }
 348
 349 CLog *CLibraryContext::getInfoLog()
 350 {
 351 //      nlassert(_ApplicationContext != NULL);
 352
 353         // just forward the call
 354         return _ApplicationContext->getInfoLog();
 355 }
 356
 357 void CLibraryContext::setInfoLog(CLog *infoLog)
 358 {
 359 //      nlassert(_ApplicationContext != NULL);
 360
 361         // just forward the call
 362         _ApplicationContext->setInfoLog(infoLog);
 363 }
 364
 365 CLog *CLibraryContext::getDebugLog()
 366 {
 367 //      nlassert(_ApplicationContext != NULL);
 368
 369         // just forward the call
 370         return _ApplicationContext->getDebugLog();
 371 }
 372
 373 void CLibraryContext::setDebugLog(CLog *debugLog)
 374 {
 375 //      nlassert(_ApplicationContext != NULL);
 376
 377         // just forward the call
 378         _ApplicationContext->setDebugLog(debugLog);
 379 }
 380
 381 CLog *CLibraryContext::getAssertLog()
 382 {
 383 //      nlassert(_ApplicationContext != NULL);
 384
 385         // just forward the call
 386         return _ApplicationContext->getAssertLog();
 387 }
 388
 389 void CLibraryContext::setAssertLog(CLog *assertLog)
 390 {
 391 //      nlassert(_ApplicationContext != NULL);
 392
 393         // just forward the call
 394         _ApplicationContext->setAssertLog(assertLog);
 395 }
 396
 397 CMemDisplayer *CLibraryContext::getDefaultMemDisplayer()
 398 {
 399 //      nlassert(_ApplicationContext != NULL);
 400
 401         // just forward the call
 402         return _ApplicationContext->getDefaultMemDisplayer();
 403 }
 404
 405 void CLibraryContext::setDefaultMemDisplayer(CMemDisplayer *memDisplayer)
 406 {
 407 //      nlassert(_ApplicationContext != NULL);
 408
 409         // just forward the call
 410         _ApplicationContext->setDefaultMemDisplayer(memDisplayer);
 411 }
 412
 413 CMsgBoxDisplayer *CLibraryContext::getDefaultMsgBoxDisplayer()
 414 {
 415 //      nlassert(_ApplicationContext != NULL);
 416
 417         // just forward the call
 418         return _ApplicationContext->getDefaultMsgBoxDisplayer();
 419 }
 420
 421 void CLibraryContext::setDefaultMsgBoxDisplayer(CMsgBoxDisplayer *msgBoxDisplayer)
 422 {
 423 //      nlassert(_ApplicationContext != NULL);
 424
 425         // just forward the call
 426         _ApplicationContext->setDefaultMsgBoxDisplayer(msgBoxDisplayer);
 427 }
 428
 429 bool CLibraryContext::getDebugNeedAssert()
 430 {
 431 //      nlassert(_ApplicationContext != NULL);
 432
 433         // just forward the call
 434         return _ApplicationContext->getDebugNeedAssert();
 435 }
 436
 437 void CLibraryContext::setDebugNeedAssert(bool needAssert)
 438 {
 439 //      nlassert(_ApplicationContext != NULL);
 440
 441         // just forward the call
 442         _ApplicationContext->setDebugNeedAssert(needAssert);
 443 }
 444
 445 bool CLibraryContext::getNoAssert()
 446 {
 447 //      nlassert(_ApplicationContext != NULL);
 448
 449         // just forward the call
 450         return _ApplicationContext->getNoAssert();
 451 }
 452
 453
 454
 455 void CLibraryContext::setNoAssert(bool noAssert)
 456 {
 457 //      nlassert(_ApplicationContext != NULL);
 458
 459         // just forward the call
 460         _ApplicationContext->setNoAssert(noAssert);
 461 }
 462
 463 bool CLibraryContext::getAlreadyCreateSharedAmongThreads()
 464 {
 465         return _ApplicationContext->getAlreadyCreateSharedAmongThreads();
 466 }
 467
 468 void CLibraryContext::setAlreadyCreateSharedAmongThreads(bool b)
 469 {
 470         _ApplicationContext->setAlreadyCreateSharedAmongThreads(b);
 471 }
 472
 473 bool CLibraryContext::isWindowedApplication()
 474 {
 475         return _ApplicationContext->isWindowedApplication();
 476 }
 477
 478 void CLibraryContext::setWindowedApplication(bool b)
 479 {
 480         _ApplicationContext->setWindowedApplication(b);
 481 }
 482
 483 void initNelLibrary(NLMISC::CLibrary &lib)
 484 {
 485         nlassert(lib.isLibraryLoaded());
 486
 487         TInitLibraryFunc *funptrptr = reinterpret_cast<TInitLibraryFunc*>(lib.getSymbolAddress("libraryEntry"));
 488         nlassert(funptrptr != NULL);
 489
 490         TInitLibraryFunc funptr = *funptrptr;
 491
 492         // call the initialisation function
 493         funptr(NLMISC::INelContext::getInstance());
 494 }
 495
 496
 497
 498 } // namespace NLMISC