nel/src/misc/sheet_id.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) 2012-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 /* This class is case unsensitive. It means that you can call build() and
  21  * buildIdVector() with string with anycase, it'll work.
  22  */
  23
  24 #include "stdmisc.h"
  25
  26 #include "nel/misc/file.h"
  27 #include "nel/misc/path.h"
  28
  29 #include "nel/misc/sheet_id.h"
  30 #include "nel/misc/common.h"
  31 #include "nel/misc/hierarchical_timer.h"
  32
  33 using namespace std;
  34
  35 #ifdef DEBUG_NEW
  36 #define new DEBUG_NEW
  37 #endif
  38
  39 namespace NLMISC
  40 {
  41
  42 CSheetId::CChar CSheetId::_AllStrings;
  43 CStaticMap<uint32, CSheetId::CChar> CSheetId::_SheetIdToName;
  44 CStaticMap<CSheetId::CChar, uint32, CSheetId::CCharComp> CSheetId::_SheetNameToId;
  45 //map<uint32,std::string> CSheetId::_SheetIdToName;
  46 //map<std::string,uint32> CSheetId::_SheetNameToId;
  47 vector<std::string> CSheetId::_FileExtensions;
  48 bool CSheetId::_Initialised = false;
  49 bool CSheetId::_RemoveUnknownSheet = true;
  50 bool CSheetId::_DontHaveSheetKnowledge = false;
  51 std::map<std::string, uint32> CSheetId::_DevTypeNameToId;
  52 std::vector<std::vector<std::string>> CSheetId::_DevSheetIdToName;
  53 std::map<std::string, uint32> CSheetId::_DevSheetNameToId;
  54
  55 const CSheetId CSheetId::Unknown((uint32)0);
  56
  57 void CSheetId::cbFileChange(const std::string &filename)
  58 {
  59         nlinfo("SHEETID: %s changed, reload it", filename.c_str());
  60
  61         loadSheetId();
  62 }
  63
  64 //-----------------------------------------------
  65 //      CSheetId
  66 //
  67 //-----------------------------------------------
  68 CSheetId::CSheetId(uint32 sheetRef)
  69 {
  70         _Id.Id = sheetRef;
  71
  72 #ifdef NL_DEBUG_SHEET_ID
  73         // Yoyo: don't access the static map, because of order of static ctor call.
  74         // For now, all static CSheetId are 0 (eg: CSheetId::Unknown)
  75         if (sheetRef)
  76         {
  77                 TSheetIdToNameMap::iterator it(_SheetIdToName.find(sheetRef));
  78                 if (it != _SheetIdToName.end())
  79                 {
  80                         _DebugSheetName = it->second.Ptr;
  81                 }
  82                 else
  83                         _DebugSheetName = NULL;
  84         }
  85         else
  86         {
  87                 _DebugSheetName = NULL;
  88         }
  89 #endif
  90 }
  91
  92 //-----------------------------------------------
  93 //      CSheetId
  94 //
  95 //-----------------------------------------------
  96 CSheetId::CSheetId(int sheetRef)
  97 {
  98         _Id.Id = (uint32)sheetRef;
  99
 100 #ifdef NL_DEBUG_SHEET_ID
 101         // Yoyo: don't access the static map, because of order of static ctor call.
 102         // For now, all static CSheetId are 0 (eg: CSheetId::Unknown)
 103         if (sheetRef)
 104         {
 105                 TSheetIdToNameMap::iterator it(_SheetIdToName.find(sheetRef));
 106                 if (it != _SheetIdToName.end())
 107                 {
 108                         _DebugSheetName = it->second.Ptr;
 109                 }
 110                 else
 111                         _DebugSheetName = NULL;
 112         }
 113         else
 114         {
 115                 _DebugSheetName = NULL;
 116         }
 117 #endif
 118 }
 119
 120 //-----------------------------------------------
 121 //      CSheetId
 122 //
 123 //-----------------------------------------------
 124 CSheetId::CSheetId(const string &sheetName)
 125 {
 126         if (!buildSheetId(sheetName.c_str(), sheetName.size()))
 127         {
 128                 if (sheetName.empty())
 129                         nlwarning("SHEETID: Try to create an CSheetId with empty name. TODO: check why.");
 130                 else
 131                         nlwarning("SHEETID: The sheet '%s' is not in sheet_id.bin, setting it to Unknown", sheetName.c_str());
 132                 //std::string stack;
 133                 //NLMISC::getCallStack(stack);
 134                 //std::vector<std::string> contexts;
 135                 //NLMISC::explode(stack, string("\n"), contexts);
 136                 //nldebug("Dumping callstack :");
 137                 //for (uint i=0; i<contexts.size(); ++i)
 138                 //      nldebug("  %3u : %s", i, contexts[i].c_str());
 139                 *this = Unknown;
 140         }
 141
 142         // nldebug("LIST_SHEET_ID: %s (%s)", toString().c_str(), sheetName.c_str());
 143
 144 } // CSheetId //
 145
 146 //-----------------------------------------------
 147 //      CSheetId
 148 //
 149 //-----------------------------------------------
 150 CSheetId::CSheetId(const char *sheetName)
 151 {
 152         if (!buildSheetId(sheetName, strlen(sheetName)))
 153         {
 154                 if (!sheetName[0])
 155                         nlwarning("SHEETID: Try to create an CSheetId with empty name. TODO: check why.");
 156                 else
 157                         nlwarning("SHEETID: The sheet '%s' is not in sheet_id.bin, setting it to Unknown", sheetName);
 158                 *this = Unknown;
 159         }
 160
 161         // nldebug("LIST_SHEET_ID: %s (%s)", toString().c_str(), sheetName.c_str());
 162
 163 } // CSheetId //
 164
 165 CSheetId::CSheetId(const std::string &sheetName, const std::string &defaultType)
 166 {
 167         // Don't use this function without defaultType, use the one above.
 168         nlassert(defaultType.size() != 0);
 169
 170         if (sheetName.rfind('.') == std::string::npos)
 171         {
 172                 std::string withType = sheetName + "." + defaultType;
 173                 *this = CSheetId(withType);
 174                 // nldebug("SHEETID: Constructing CSheetId from name '%s' without explicit type, defaulting as '%s' to '%s'", sheetName.c_str(), defaultType.c_str(), withType.c_str());
 175         }
 176         else
 177         {
 178                 *this = CSheetId(sheetName);
 179         }
 180 }
 181
 182 static std::string s_Dot = ".";
 183
 184 CSheetId::CSheetId(const std::string &sheetName, const char *defaultType)
 185 {
 186         // Don't use this function without defaultType, use the one above.
 187         nlassert(defaultType[0]);
 188
 189         if (sheetName.rfind('.') == std::string::npos)
 190         {
 191                 std::string withType = sheetName + s_Dot + defaultType;
 192                 *this = CSheetId(withType);
 193                 // nldebug("SHEETID: Constructing CSheetId from name '%s' without explicit type, defaulting as '%s' to '%s'", sheetName.c_str(), defaultType.c_str(), withType.c_str());
 194         }
 195         else
 196         {
 197                 *this = CSheetId(sheetName);
 198         }
 199 }
 200
 201 CSheetId::CSheetId(const char *sheetName, const char *defaultType)
 202 {
 203         // Don't use this function without defaultType, use the one above.
 204         nlassert(defaultType[0]);
 205
 206         if (!strchr(sheetName, '.'))
 207         {
 208                 std::string withType = sheetName + s_Dot + defaultType;
 209                 *this = CSheetId(withType);
 210                 // nldebug("SHEETID: Constructing CSheetId from name '%s' without explicit type, defaulting as '%s' to '%s'", sheetName.c_str(), defaultType.c_str(), withType.c_str());
 211         }
 212         else
 213         {
 214                 *this = CSheetId(sheetName);
 215         }
 216 }
 217
 218 //-----------------------------------------------
 219 //      Build
 220 //
 221 //-----------------------------------------------
 222 bool CSheetId::buildSheetId(const char *sheetName, size_t sheetNameLen)
 223 {
 224         nlassert(_Initialised);
 225
 226         // When no sheet_id.bin is loaded, use dynamically assigned IDs.
 227         if (_DontHaveSheetKnowledge)
 228         {
 229                 std::string sheetNameLc = toLowerAscii(sheetName);
 230                 std::map<std::string, uint32>::iterator it = _DevSheetNameToId.find(sheetNameLc);
 231                 if (it == _DevSheetNameToId.end())
 232                 {
 233                         // Create a new dynamic sheet ID.
 234                         // nldebug("SHEETID: Creating a dynamic sheet id for '%s'", sheetName.c_str());
 235                         std::string sheetType = CFile::getExtension(sheetNameLc);
 236                         std::string sheetName = CFile::getFilenameWithoutExtension(sheetNameLc);
 237                         std::map<std::string, uint32>::iterator tit = _DevTypeNameToId.find(sheetType);
 238                         uint32 typeId;
 239                         if (tit == _DevTypeNameToId.end())
 240                         {
 241                                 _FileExtensions.push_back(sheetType);
 242                                 _DevSheetIdToName.push_back(std::vector<std::string>());
 243                                 typeId = (uint32)_FileExtensions.size() - 1;
 244                                 _DevTypeNameToId[sheetType] = typeId;
 245                                 std::string unknownNewType = std::string("unknown." + sheetType);
 246                                 _DevSheetIdToName[typeId].push_back(unknownNewType);
 247                                 _Id.IdInfos.Type = typeId;
 248                                 _Id.IdInfos.Id = _DevSheetIdToName[typeId].size() - 1;
 249                                 _DevSheetNameToId[unknownNewType] = _Id.Id;
 250                                 if (sheetName == "unknown")
 251                                         return true; // Return with the unknown sheet id of this type
 252                         }
 253                         else
 254                         {
 255                                 typeId = tit->second;
 256                                 _Id.IdInfos.Type = typeId;
 257                         }
 258                         // Add a new sheet name to the type
 259                         _DevSheetIdToName[typeId].push_back(sheetNameLc);
 260                         _Id.IdInfos.Id = _DevSheetIdToName[typeId].size() - 1;
 261                         // nldebug("SHEETID: Type %i, id %i, sheetid %i", _Id.IdInfos.Type, _Id.IdInfos.Id, _Id.Id);
 262                         _DevSheetNameToId[sheetNameLc] = _Id.Id;
 263                         return true;
 264                 }
 265                 _Id.Id = it->second;
 266                 return true;
 267         }
 268
 269         // try looking up the sheet name in _SheetNameToId
 270         TSheetNameToIdMap::const_iterator itId;
 271         CChar c;
 272 #ifdef alloca
 273 #pragma warning(push)
 274 #pragma warning(disable : 6255)
 275         c.Ptr = (char *)alloca(sheetNameLen + 1);
 276 #pragma warning(pop)
 277 #else
 278         c.Ptr = new char[sheetName.size() + 1];
 279 #endif
 280         strcpy(c.Ptr, sheetName);
 281         toLowerAscii(c.Ptr);
 282
 283         itId = _SheetNameToId.find(c);
 284 #ifndef alloca
 285         delete[] c.Ptr; // Don't delete alloca
 286 #endif
 287         if (itId != _SheetNameToId.end())
 288         {
 289                 _Id.Id = itId->second;
 290 #ifdef NL_DEBUG_SHEET_ID
 291                 // store debug info
 292                 _DebugSheetName = itId->first.Ptr;
 293 #endif
 294                 return true;
 295         }
 296
 297         // we failed to find the sheet name in the sheetname map so see if the string is numeric
 298         if (sheetName[0] == '#' && sheetName[1])
 299         {
 300                 uint32 numericId;
 301                 if (NLMISC::fromString((const char *)(sheetName + 1), numericId))
 302                 {
 303                         _Id.Id = numericId;
 304                         return true;
 305                 }
 306         }
 307
 308         return false;
 309 }
 310
 311 void CSheetId::loadSheetId()
 312 {
 313         H_AUTO(CSheetIdInit);
 314         //nldebug("Loading sheet_id.bin");
 315
 316         // Open the sheet id to sheet file name association
 317         CIFile file;
 318         std::string path = CPath::lookup("sheet_id.bin", false, false);
 319         if (!path.empty() && file.open(path))
 320         {
 321                 // clear entries
 322                 _FileExtensions.clear();
 323                 _SheetIdToName.clear();
 324                 _SheetNameToId.clear();
 325
 326                 // reserve space for the vector of file extensions
 327                 _FileExtensions.resize(1 << (NL_SHEET_ID_TYPE_BITS));
 328
 329                 // Get the map from the file
 330                 map<uint32, string> tempMap;
 331                 contReset(tempMap);
 332                 file.serialCont(tempMap);
 333                 file.close();
 334
 335                 if (_RemoveUnknownSheet)
 336                 {
 337                         uint32 removednbfiles = 0;
 338                         uint32 nbfiles = (uint32)tempMap.size();
 339
 340                         // now we remove all files that not available
 341                         map<uint32, string>::iterator itStr2;
 342                         for (itStr2 = tempMap.begin(); itStr2 != tempMap.end();)
 343                         {
 344                                 if (CPath::exists((*itStr2).second))
 345                                 {
 346                                         ++itStr2;
 347                                 }
 348                                 else
 349                                 {
 350                                         map<uint32, string>::iterator olditStr = itStr2;
 351                                         //nldebug ("Removing file '%s' from CSheetId because the file not exists", (*olditStr).second.c_str ());
 352                                         itStr2++;
 353                                         tempMap.erase(olditStr);
 354                                         removednbfiles++;
 355                                 }
 356                         }
 357                         nlinfo("SHEETID: Removed %d files on %d from CSheetId because these files don't exist", removednbfiles, nbfiles);
 358                 }
 359
 360                 // Convert the map to one big string and 1 static map (id to name)
 361                 {
 362                         // Get the number and size of all strings
 363                         vector<CChar> tempVec; // Used to initialise the first map
 364                         uint32 nNb = 0;
 365                         uint32 nSize = 0;
 366                         map<uint32, string>::const_iterator it = tempMap.begin();
 367                         while (it != tempMap.end())
 368                         {
 369                                 nSize += (uint32)it->second.size() + 1;
 370                                 nNb++;
 371                                 it++;
 372                         }
 373
 374                         // Make the big string (composed of all strings) and a vector referencing each string
 375                         tempVec.resize(nNb);
 376                         _AllStrings.Ptr = new char[nSize];
 377                         it = tempMap.begin();
 378                         nSize = 0;
 379                         nNb = 0;
 380                         while (it != tempMap.end())
 381                         {
 382                                 tempVec[nNb].Ptr = _AllStrings.Ptr + nSize;
 383                                 strcpy(_AllStrings.Ptr + nSize, it->second.c_str());
 384                                 toLowerAscii(_AllStrings.Ptr + nSize);
 385                                 nSize += (uint32)it->second.size() + 1;
 386                                 nNb++;
 387                                 it++;
 388                         }
 389
 390                         // Finally build the static map (id to name)
 391                         _SheetIdToName.reserve(tempVec.size());
 392                         it = tempMap.begin();
 393                         nNb = 0;
 394                         while (it != tempMap.end())
 395                         {
 396                                 _SheetIdToName.add(pair<uint32, CChar>(it->first, CChar(tempVec[nNb])));
 397
 398                                 nNb++;
 399                                 it++;
 400                         }
 401
 402                         // The vector of all small string is not needed anymore we have all the info in
 403                         // the static map and with the pointer AllStrings referencing the beginning.
 404                 }
 405
 406                 // Build the invert map (Name to Id) & file extension vector
 407                 {
 408                         uint32 nSize = (uint32)_SheetIdToName.size();
 409                         _SheetNameToId.reserve(nSize);
 410                         TSheetIdToNameMap::iterator itStr;
 411                         for (itStr = _SheetIdToName.begin(); itStr != _SheetIdToName.end(); ++itStr)
 412                         {
 413                                 // add entry to the inverse map
 414                                 _SheetNameToId.add(make_pair((*itStr).second, (*itStr).first));
 415
 416                                 // work out the type value for this entry in the map
 417                                 TSheetId sheetId;
 418                                 sheetId.Id = (*itStr).first;
 419                                 uint32 type = sheetId.IdInfos.Type;
 420
 421                                 // check whether we need to add an entry to the file extensions vector
 422                                 if (_FileExtensions[type].empty())
 423                                 {
 424                                         // find the file extension part of the given file name
 425                                         _FileExtensions[type] = toLowerAscii(CFile::getExtension((*itStr).second.Ptr));
 426                                 }
 427                                 nSize--;
 428                         }
 429                         _SheetNameToId.endAdd();
 430                 }
 431         }
 432         else
 433         {
 434                 nlerror("<CSheetId::init> Can't open the file sheet_id.bin");
 435         }
 436         nldebug("Finished loading sheet_id.bin: %u entries read", _SheetIdToName.size());
 437 }
 438
 439 //-----------------------------------------------
 440 //      init
 441 //
 442 //-----------------------------------------------
 443 void CSheetId::init(bool removeUnknownSheet)
 444 {
 445         // allow multiple calls to init in case libraries depending on sheetid call this init from their own
 446         if (_Initialised)
 447         {
 448                 if (_DontHaveSheetKnowledge)
 449                         nlinfo("SHEETID: CSheetId is already initialized without sheet_id.bin");
 450                 return;
 451         }
 452
 453         //      CFile::addFileChangeCallback ("sheet_id.bin", cbFileChange);
 454
 455         _RemoveUnknownSheet = removeUnknownSheet;
 456
 457         loadSheetId();
 458         _Initialised = true;
 459
 460 } // init //
 461
 462 void CSheetId::initWithoutSheet()
 463 {
 464         if (_Initialised)
 465         {
 466                 nlassert(_DontHaveSheetKnowledge);
 467                 return;
 468         }
 469
 470         _Initialised = true;
 471         _DontHaveSheetKnowledge = true;
 472
 473         // Initialize id 0,0 as unknown.unknown
 474         CSheetId unknownUnknown = CSheetId("unknown.unknown");
 475         nlassert(unknownUnknown == CSheetId::Unknown);
 476 }
 477
 478 //-----------------------------------------------
 479 //      uninit
 480 //
 481 //-----------------------------------------------
 482 void CSheetId::uninit()
 483 {
 484         delete[] _AllStrings.Ptr;
 485         _FileExtensions.clear();
 486         _DevTypeNameToId.clear();
 487         _DevSheetIdToName.clear();
 488         _DevSheetNameToId.clear();
 489 } // uninit //
 490
 491 //-----------------------------------------------
 492 //      operator=
 493 //
 494 //-----------------------------------------------
 495 CSheetId &CSheetId::operator=(const CSheetId &sheetId)
 496 {
 497         if (!_Initialised)
 498                 init(false);
 499
 500         if (this == &sheetId)
 501         {
 502                 return *this;
 503         }
 504
 505         _Id.Id = sheetId.asInt();
 506
 507 #ifdef NL_DEBUG_SHEET_ID
 508         _DebugSheetName = sheetId._DebugSheetName;
 509 #endif
 510
 511         return *this;
 512
 513 } // operator= //
 514
 515 //-----------------------------------------------
 516 //      operator=
 517 //
 518 //-----------------------------------------------
 519 CSheetId &CSheetId::operator=(const string &sheetName)
 520 {
 521
 522         if (!buildSheetId(sheetName.c_str(), sheetName.size()))
 523                 *this = Unknown;
 524
 525         // nldebug("LIST_SHEET_ID: %s (%s)", toString().c_str(), sheetName.c_str());
 526
 527         return *this;
 528
 529 } // operator= //
 530
 531 //-----------------------------------------------
 532 //      operator=
 533 //
 534 //-----------------------------------------------
 535 CSheetId &CSheetId::operator=(const char *sheetName)
 536 {
 537
 538         if (!buildSheetId(sheetName, strlen(sheetName)))
 539                 *this = Unknown;
 540
 541         // nldebug("LIST_SHEET_ID: %s (%s)", toString().c_str(), sheetName);
 542
 543         return *this;
 544
 545 } // operator= //
 546
 547 //-----------------------------------------------
 548 //      operator=
 549 //
 550 //-----------------------------------------------
 551 CSheetId &CSheetId::operator=(uint32 sheetRef)
 552 {
 553         if (!_Initialised)
 554                 init(false);
 555
 556         _Id.Id = sheetRef;
 557
 558         return *this;
 559
 560 } // operator= //
 561
 562 //-----------------------------------------------
 563 //      operator=
 564 //
 565 //-----------------------------------------------
 566 CSheetId &CSheetId::operator=(int sheetRef)
 567 {
 568         if (!_Initialised)
 569                 init(false);
 570
 571         _Id.Id = (uint32)sheetRef;
 572
 573         return *this;
 574
 575 } // operator= //
 576
 577 //-----------------------------------------------
 578 //      operator<
 579 //
 580 //-----------------------------------------------
 581 bool CSheetId::operator<(const CSheetId &sheetRef) const
 582 {
 583         if (!_Initialised)
 584                 init(false);
 585
 586         if (_Id.Id < sheetRef.asInt())
 587         {
 588                 return true;
 589         }
 590
 591         return false;
 592
 593 } // operator< //
 594
 595 //-----------------------------------------------
 596 //      toString
 597 //
 598 //-----------------------------------------------
 599 string CSheetId::toString(bool ifNotFoundUseNumericId) const
 600 {
 601         if (!_Initialised)
 602                 init(false);
 603
 604         if (_DontHaveSheetKnowledge)
 605         {
 606                 if (_Id.IdInfos.Type < _DevSheetIdToName.size()
 607                     && _Id.IdInfos.Id < _DevSheetIdToName[_Id.IdInfos.Type].size())
 608                 {
 609                         return _DevSheetIdToName[_Id.IdInfos.Type][_Id.IdInfos.Id];
 610                 }
 611                 else
 612                 {
 613                         if (ifNotFoundUseNumericId)
 614                         {
 615                                 return NLMISC::toString("#%u", _Id.Id);
 616                         }
 617                         else
 618                         {
 619                                 return NLMISC::toString("<Sheet %u not found in loaded sheets>", _Id.Id);
 620                         }
 621                 }
 622         }
 623
 624         TSheetIdToNameMap::const_iterator itStr = _SheetIdToName.find(_Id.Id);
 625         if (itStr != _SheetIdToName.end())
 626         {
 627                 return string((*itStr).second.Ptr);
 628         }
 629         else
 630         {
 631                 // This nlwarning is commented out because the loggers are mutexed, therefore
 632                 // you couldn't use toString() within a nlwarning().
 633                 //nlwarning("<CSheetId::toString> The sheet %08x is not in sheet_id.bin",_Id.Id);
 634                 if (ifNotFoundUseNumericId)
 635                 {
 636                         return NLMISC::toString("#%u", _Id.Id);
 637                 }
 638                 else
 639                 {
 640                         return NLMISC::toString("<Sheet %u not found in sheet_id.bin>", _Id.Id);
 641                 }
 642         }
 643
 644 } // toString //
 645
 646 void CSheetId::serial(NLMISC::IStream &f)
 647 {
 648         nlassert(!_DontHaveSheetKnowledge);
 649
 650         f.serial(_Id.Id);
 651
 652 #ifdef NL_DEBUG_SHEET_ID
 653         TSheetIdToNameMap::iterator it(_SheetIdToName.find(_Id.Id));
 654         if (it != _SheetIdToName.end())
 655                 _DebugSheetName = it->second.Ptr;
 656         else
 657                 _DebugSheetName = NULL;
 658 #endif
 659 }
 660
 661 void CSheetId::serialString(NLMISC::IStream &f, const std::string &defaultType)
 662 {
 663         nlassert(_Initialised);
 664
 665         if (f.isReading())
 666         {
 667                 std::string sheetName;
 668                 f.serial(sheetName);
 669                 *this = CSheetId(sheetName, defaultType);
 670         }
 671         else
 672         {
 673                 // if this assert fails, you may be using an outdated id bin
 674                 nlassert(*this != CSheetId::Unknown);
 675                 std::string sheetName = toString();
 676                 f.serial(sheetName);
 677         }
 678 }
 679
 680 //-----------------------------------------------
 681 //      display
 682 //
 683 //-----------------------------------------------
 684 void CSheetId::display()
 685 {
 686         if (!_Initialised)
 687                 init(false);
 688
 689         TSheetIdToNameMap::const_iterator itStr;
 690         for (itStr = _SheetIdToName.begin(); itStr != _SheetIdToName.end(); ++itStr)
 691         {
 692                 //nlinfo("%d %s",(*itStr).first,(*itStr).second.c_str());
 693                 nlinfo("SHEETID: (%08x %d) %s", (*itStr).first, (*itStr).first, (*itStr).second.Ptr);
 694         }
 695
 696 } // display //
 697
 698 //-----------------------------------------------
 699 //      display
 700 //
 701 //-----------------------------------------------
 702 void CSheetId::display(uint32 type)
 703 {
 704         if (!_Initialised)
 705                 init(false);
 706
 707         TSheetIdToNameMap::const_iterator itStr;
 708         for (itStr = _SheetIdToName.begin(); itStr != _SheetIdToName.end(); ++itStr)
 709         {
 710                 // work out the type value for this entry in the map
 711                 TSheetId sheetId;
 712                 sheetId.Id = (*itStr).first;
 713
 714                 // decide whether or not to display the entry
 715                 if (type == sheetId.IdInfos.Type)
 716                 {
 717                         //nlinfo("%d %s",(*itStr).first,(*itStr).second.c_str());
 718                         nlinfo("SHEETID: (%08x %d) %s", (*itStr).first, (*itStr).first, (*itStr).second.Ptr);
 719                 }
 720         }
 721
 722 } // display //
 723
 724 //-----------------------------------------------
 725 //      buildIdVector
 726 //
 727 //-----------------------------------------------
 728 void CSheetId::buildIdVector(std::vector<CSheetId> &result)
 729 {
 730         if (!_Initialised)
 731                 init(false);
 732
 733         TSheetIdToNameMap::const_iterator itStr;
 734         for (itStr = _SheetIdToName.begin(); itStr != _SheetIdToName.end(); ++itStr)
 735         {
 736                 result.push_back((CSheetId)(*itStr).first);
 737         }
 738
 739 } // buildIdVector //
 740
 741 //-----------------------------------------------
 742 //      buildIdVector
 743 //
 744 //-----------------------------------------------
 745 void CSheetId::buildIdVector(std::vector<CSheetId> &result, uint32 type)
 746 {
 747         if (!_Initialised)
 748                 init(false);
 749         nlassert(type < (1 << (NL_SHEET_ID_TYPE_BITS)));
 750
 751         TSheetIdToNameMap::const_iterator itStr;
 752         for (itStr = _SheetIdToName.begin(); itStr != _SheetIdToName.end(); ++itStr)
 753         {
 754                 // work out the type value for this entry in the map
 755                 TSheetId sheetId;
 756                 sheetId.Id = (*itStr).first;
 757
 758                 // decide whether or not to use the entry
 759                 if (type == sheetId.IdInfos.Type)
 760                 {
 761                         result.push_back((CSheetId)sheetId.Id);
 762                 }
 763         }
 764
 765 } // buildIdVector //
 766
 767 //-----------------------------------------------
 768 //      buildIdVector
 769 //
 770 //-----------------------------------------------
 771 void CSheetId::buildIdVector(std::vector<CSheetId> &result, std::vector<std::string> &resultFilenames, uint32 type)
 772 {
 773         if (!_Initialised)
 774                 init(false);
 775         nlassert(type < (1 << (NL_SHEET_ID_TYPE_BITS)));
 776
 777         TSheetIdToNameMap::const_iterator itStr;
 778         for (itStr = _SheetIdToName.begin(); itStr != _SheetIdToName.end(); ++itStr)
 779         {
 780                 // work out the type value for this entry in the map
 781                 TSheetId sheetId;
 782                 sheetId.Id = (*itStr).first;
 783
 784                 // decide whether or not to use the entry
 785                 if (type == sheetId.IdInfos.Type)
 786                 {
 787                         result.push_back((CSheetId)sheetId.Id);
 788                         resultFilenames.push_back((*itStr).second.Ptr);
 789                 }
 790         }
 791
 792 } // buildIdVector //
 793
 794 //-----------------------------------------------
 795 //      buildIdVector
 796 //
 797 //-----------------------------------------------
 798 void CSheetId::buildIdVector(std::vector<CSheetId> &result, const std::string &fileExtension)
 799 {
 800         uint32 type = typeFromFileExtension(fileExtension);
 801         if (type != std::numeric_limits<uint32>::max())
 802                 buildIdVector(result, type);
 803
 804 } // buildIdVector //
 805
 806 //-----------------------------------------------
 807 //      buildIdVector
 808 //
 809 //-----------------------------------------------
 810 void CSheetId::buildIdVector(std::vector<CSheetId> &result, std::vector<std::string> &resultFilenames, const std::string &fileExtension)
 811 {
 812         uint32 type = typeFromFileExtension(fileExtension);
 813         if (type != std::numeric_limits<uint32>::max())
 814                 buildIdVector(result, resultFilenames, type);
 815
 816 } // buildIdVector //
 817
 818 //-----------------------------------------------
 819 //      typeFromFileExtension
 820 //
 821 //-----------------------------------------------
 822 uint32 CSheetId::typeFromFileExtension(const std::string &fileExtension)
 823 {
 824         if (!_Initialised)
 825                 init(false);
 826
 827         uint i;
 828         for (i = 0; i < _FileExtensions.size(); i++)
 829                 if (toLowerAscii(fileExtension) == _FileExtensions[i])
 830                         return i;
 831
 832         return std::numeric_limits<uint32>::max();
 833 } // typeFromFileExtension //
 834
 835 //-----------------------------------------------
 836 //      fileExtensionFromType
 837 //
 838 //-----------------------------------------------
 839 const std::string &CSheetId::fileExtensionFromType(uint32 type)
 840 {
 841         if (!_Initialised)
 842                 init(false);
 843         nlassert(type < (1 << (NL_SHEET_ID_TYPE_BITS)));
 844
 845         return _FileExtensions[type];
 846
 847 } // fileExtensionFromType //
 848
 849 //-----------------------------------------------
 850 //      build
 851 //
 852 //-----------------------------------------------
 853 void CSheetId::buildSheetId(uint32 shortId, uint32 type)
 854 {
 855         nlassert(shortId < (1 << NL_SHEET_ID_ID_BITS));
 856         nlassert(type < (1 << (NL_SHEET_ID_TYPE_BITS)));
 857
 858         _Id.IdInfos.Id = shortId;
 859         _Id.IdInfos.Type = type;
 860
 861 #ifdef NL_DEBUG_SHEET_ID
 862         TSheetIdToNameMap::iterator it(_SheetIdToName.find(_Id.Id));
 863         if (it != _SheetIdToName.end())
 864         {
 865                 _DebugSheetName = it->second.Ptr;
 866         }
 867         else
 868                 _DebugSheetName = NULL;
 869 #endif
 870 }
 871
 872 } // NLMISC