nel/src/misc/string_mapper.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) 2019  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
  22 #include "nel/misc/string_mapper.h"
  23
  24 using namespace std;
  25
  26 #ifdef DEBUG_NEW
  27         #define new DEBUG_NEW
  28 #endif
  29
  30 namespace NLMISC
  31 {
  32
  33 CStringMapper CStringMapper::s_GlobalMapper;
  34
  35 // ****************************************************************************
  36 CStringMapper::CStringMapper()
  37 {
  38         m_EmptyId = new string();
  39 }
  40
  41 // ****************************************************************************
  42 CStringMapper *CStringMapper::createLocalMapper()
  43 {
  44         return new CStringMapper;
  45 }
  46
  47 // ****************************************************************************
  48 TStringId CStringMapper::localMap(const std::string &str)
  49 {
  50         if (str.empty())
  51                 return NULL;
  52
  53         CAutoFastMutex autoMutex(&m_Mutex);
  54
  55         TStringTable::const_iterator it = m_StringTable.find((const std::string *)&str);
  56
  57         if (it == m_StringTable.end())
  58         {
  59                 string *pStr = new string(str);
  60                 m_StringTable.insert(pStr);
  61                 return pStr;
  62         }
  63         return (TStringId)(*it);
  64 }
  65
  66 #ifdef NL_CPP14
  67 // ****************************************************************************
  68 TStringId CStringMapper::localMap(const char *str)
  69 {
  70         if (!str[0])
  71                 return NULL;
  72
  73         CAutoFastMutex autoMutex(&m_Mutex);
  74
  75         TStringTable::const_iterator it = m_StringTable.find(str);
  76
  77         if (it == m_StringTable.end())
  78         {
  79                 string *pStr = new string(str);
  80                 m_StringTable.insert(pStr);
  81                 return pStr;
  82         }
  83         return (TStringId)(*it);
  84 }
  85 #endif
  86
  87 // ***************************************************************************
  88 void CStringMapper::localSerialString(NLMISC::IStream &f, TStringId &id)
  89 {
  90         std::string str;
  91         if (f.isReading())
  92         {
  93                 f.serial(str);
  94                 id = localMap(str);
  95         }
  96         else
  97         {
  98                 str = localUnmap(id);
  99                 f.serial(str);
 100         }
 101 }
 102
 103 // ****************************************************************************
 104 void CStringMapper::localClear()
 105 {
 106         CAutoFastMutex autoMutex(&m_Mutex);
 107
 108         TStringTable::iterator it = m_StringTable.begin();
 109         while (it != m_StringTable.end())
 110         {
 111                 const std::string *ptrTmp = (*it);
 112                 delete ptrTmp;
 113                 it++;
 114         }
 115         m_StringTable.clear();
 116 }
 117
 118 // ****************************************************************************
 119 // CStaticStringMapper
 120 // ****************************************************************************
 121
 122 // ****************************************************************************
 123 TSStringId CStaticStringMapper::add(const std::string &str)
 124 {
 125         nlassert(!_MemoryCompressed);
 126         std::map<std::string, TSStringId>::iterator it = _TempStringTable.find(str);
 127         if (it == _TempStringTable.end())
 128         {
 129                 _TempStringTable.insert(pair<string,TSStringId>(str,_IdCounter));
 130                 _TempIdTable.insert(pair<TSStringId,string>(_IdCounter,str));
 131                 _IdCounter++;
 132                 return _IdCounter-1;
 133         }
 134         else
 135         {
 136                 return it->second;
 137         }
 138 }
 139
 140 // ****************************************************************************
 141 bool CStaticStringMapper::isAdded(const std::string &str) const
 142 {
 143         nlassert(!_MemoryCompressed);
 144         return _TempStringTable.count(str) != 0;
 145 }
 146
 147 // ****************************************************************************
 148 void CStaticStringMapper::memoryUncompress()
 149 {
 150         std::map<std::string, TSStringId>       tempStringTable;
 151         std::map<TSStringId, std::string>       tempIdTable;
 152         for(uint k = 0; k < _IdToStr.size(); ++k)
 153         {
 154                 tempStringTable[_IdToStr[k]] = (TSStringId) k;
 155                 tempIdTable[(TSStringId) k] = _IdToStr[k];
 156         }
 157         delete [] _AllStrings;
 158         _AllStrings = NULL;
 159         contReset(_IdToStr);
 160         _TempStringTable.swap(tempStringTable);
 161         _TempIdTable.swap(tempIdTable);
 162         _MemoryCompressed = false;
 163 }
 164
 165 // ****************************************************************************
 166 void CStaticStringMapper::memoryCompress()
 167 {
 168         _MemoryCompressed = true;
 169         std::map<TSStringId, std::string>::iterator it = _TempIdTable.begin();
 170
 171         uint nTotalSize = 0;
 172         uint32 nNbStrings = 0;
 173         while (it != _TempIdTable.end())
 174         {
 175                 nTotalSize += (uint)it->second.size() + 1;
 176                 nNbStrings++;
 177                 it++;
 178         }
 179
 180         _AllStrings = new char[nTotalSize];
 181         _IdToStr.resize(nNbStrings);
 182         nNbStrings = 0;
 183         nTotalSize = 0;
 184         it = _TempIdTable.begin();
 185         while (it != _TempIdTable.end())
 186         {
 187                 strcpy(_AllStrings + nTotalSize, it->second.c_str());
 188                 _IdToStr[nNbStrings] = _AllStrings + nTotalSize;
 189                 nTotalSize += (uint)it->second.size() + 1;
 190                 nNbStrings++;
 191                 it++;
 192         }
 193         contReset(_TempStringTable);
 194         contReset(_TempIdTable);
 195 }
 196
 197 // ****************************************************************************
 198 const char *CStaticStringMapper::get(TSStringId stringId)
 199 {
 200         if (_MemoryCompressed)
 201         {
 202                 nlassert(stringId < _IdToStr.size());
 203                 return _IdToStr[stringId];
 204         }
 205         else
 206         {
 207                 std::map<TSStringId, std::string>::iterator it = _TempIdTable.find(stringId);
 208                 if (it != _TempIdTable.end())
 209                         return it->second.c_str();
 210                 else
 211                         return NULL;
 212         }
 213 }
 214
 215 // ****************************************************************************
 216 void CStaticStringMapper::clear()
 217 {
 218         contReset(_TempStringTable);
 219         contReset(_TempIdTable);
 220         delete [] _AllStrings;
 221         contReset(_IdToStr);
 222
 223         _IdCounter = 0;
 224         _AllStrings = NULL;
 225         _MemoryCompressed = false;
 226         add("");
 227 }
 228
 229 // ****************************************************************************
 230 void CStaticStringMapper::serial(IStream &f, TSStringId &strId)
 231 {
 232         std::string tmp;
 233         if (f.isReading())
 234         {
 235                 f.serial(tmp);
 236                 strId = add(tmp);
 237         }
 238         else
 239         {
 240                 tmp = get(strId);
 241                 f.serial(tmp);
 242         }
 243 }
 244
 245 // ****************************************************************************
 246 void CStaticStringMapper::serial(IStream &f, std::vector<TSStringId> &strIdVect)
 247 {
 248         std::vector<std::string> vsTmp;
 249         std::string sTmp;
 250         // Serialize class components.
 251         if (f.isReading())
 252         {
 253                 f.serialCont(vsTmp);
 254                 strIdVect.resize(vsTmp.size());
 255                 for(uint i = 0; i < vsTmp.size(); ++i)
 256                         strIdVect[i] = add(vsTmp[i]);
 257                         }
 258         else
 259         {
 260                 vsTmp.resize(strIdVect.size());
 261                 for (uint i = 0; i < vsTmp.size(); ++i)
 262                         vsTmp[i] = get(strIdVect[i]);
 263                 f.serialCont(vsTmp);
 264
 265         }
 266 }
 267
 268
 269
 270 } // namespace NLMISC