ryzom/server/src/server_share/stat_db_tree.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 #include "stdpch.h"
  19 #include "stat_db_tree.h"
  20 #include "game_share/utils.h"
  21
  22 using namespace std;
  23 using namespace NLMISC;
  24
  25
  26 // ****************************************************************************
  27 // CStatDBTableLeaf
  28 // ****************************************************************************
  29
  30 // ****************************************************************************
  31 void CStatDBTableLeaf::playerAdd(NLMISC::CEntityId playerId, sint32 val)
  32 {
  33         TPlayerValues::iterator it = _PlayerValues.find(playerId);
  34         if (it != _PlayerValues.end())
  35         {
  36                 sint32 & playerValue = (*it).second;
  37
  38                 // avoid overflow
  39                 if (val > 0 && (playerValue + val) < playerValue)
  40                 {
  41                         playerValue = 0x7FFFFFFF;
  42                         return;
  43                 }
  44
  45                 // add the value and remove the entry if the result is <= 0
  46                 playerValue += val;
  47                 if (playerValue <= 0)
  48                 {
  49                         _PlayerValues.erase(it);
  50                 }
  51         }
  52         else
  53         {
  54                 if (val > 0)
  55                 {
  56                         _PlayerValues[playerId] = val;
  57                 }
  58         }
  59 }
  60
  61 // ****************************************************************************
  62 void CStatDBTableLeaf::playerSet(NLMISC::CEntityId playerId, sint32 val)
  63 {
  64         TPlayerValues::iterator it = _PlayerValues.find(playerId);
  65         if (it != _PlayerValues.end())
  66         {
  67                 sint32 & playerValue = (*it).second;
  68
  69                 // set the value and remove the entry if the result is <= 0
  70                 if (val > 0)
  71                 {
  72                         playerValue = val;
  73                 }
  74                 else
  75                 {
  76                         _PlayerValues.erase(it);
  77                 }
  78         }
  79         else
  80         {
  81                 if (val > 0)
  82                 {
  83                         _PlayerValues[playerId] = val;
  84                 }
  85         }
  86 }
  87
  88 // ****************************************************************************
  89 void CStatDBTableLeaf::guildAdd(EGSPD::TGuildId guildId, sint32 val)
  90 {
  91         TGuildValues::iterator it = _GuildValues.find(guildId);
  92         if (it != _GuildValues.end())
  93         {
  94                 sint32 & guildValue = (*it).second;
  95
  96                 // avoid overflow
  97                 if (val > 0 && (guildValue + val) < guildValue)
  98                 {
  99                         guildValue = 0x7FFFFFFF;
 100                         return;
 101                 }
 102
 103                 // add the value and remove the entry if the result is <= 0
 104                 guildValue += val;
 105                 if (guildValue <= 0)
 106                 {
 107                         _GuildValues.erase(it);
 108                 }
 109         }
 110         else
 111         {
 112                 if (val > 0)
 113                 {
 114                         _GuildValues[guildId] = val;
 115                 }
 116         }
 117 }
 118
 119 // ****************************************************************************
 120 void CStatDBTableLeaf::guildSet(EGSPD::TGuildId guildId, sint32 val)
 121 {
 122         TGuildValues::iterator it = _GuildValues.find(guildId);
 123         if (it != _GuildValues.end())
 124         {
 125                 sint32 & guildValue = (*it).second;
 126
 127                 // set the value and remove the entry if the result is <= 0
 128                 if (val > 0)
 129                 {
 130                         guildValue = val;
 131                 }
 132                 else
 133                 {
 134                         _GuildValues.erase(it);
 135                 }
 136         }
 137         else
 138         {
 139                 if (val > 0)
 140                 {
 141                         _GuildValues[guildId] = val;
 142                 }
 143         }
 144 }
 145
 146 // ****************************************************************************
 147 bool CStatDBTableLeaf::playerGet(NLMISC::CEntityId playerId, sint32 & val) const
 148 {
 149         TPlayerValues::const_iterator it = _PlayerValues.find(playerId);
 150         if (it == _PlayerValues.end())
 151                 return false;
 152
 153         val = (*it).second;
 154         return true;
 155 }
 156
 157 // ****************************************************************************
 158 bool CStatDBTableLeaf::guildGet(EGSPD::TGuildId guildId, sint32 & val) const
 159 {
 160         TGuildValues::const_iterator it = _GuildValues.find(guildId);
 161         if (it == _GuildValues.end())
 162                 return false;
 163
 164         val = (*it).second;
 165         return true;
 166 }
 167
 168 // ****************************************************************************
 169 void CStatDBTableLeaf::removePlayer(NLMISC::CEntityId playerId)
 170 {
 171         TPlayerValues::iterator it = _PlayerValues.find(playerId);
 172         if (it != _PlayerValues.end())
 173                 _PlayerValues.erase(it);
 174 }
 175
 176 // ****************************************************************************
 177 void CStatDBTableLeaf::removeGuild(EGSPD::TGuildId guildId)
 178 {
 179         TGuildValues::iterator it = _GuildValues.find(guildId);
 180         if (it != _GuildValues.end())
 181                 _GuildValues.erase(it);
 182 }
 183
 184 // ****************************************************************************
 185 // CStatDBBranch
 186 // ****************************************************************************
 187
 188 // ****************************************************************************
 189 bool CStatDBBranch::setNode(const std::string & path, IStatDBNodePtr node)
 190 {
 191         BOMB_IF(path.empty(), "empty path!", return false);
 192         BOMB_IF(node == NULL, "NULL node!", return false);
 193
 194         string token;
 195         string rest;
 196         splitPath(path, token, rest);
 197
 198         if (!isValidToken(token))
 199                 return false;
 200
 201         if (rest.empty())
 202         {
 203                 _Children.add(make_pair(token, node));
 204                 return true;
 205         }
 206
 207         IStatDBNodePtr nextNode;
 208         TChildren::iterator it = _Children.find(token);
 209         if (it == _Children.end())
 210         {
 211                 nextNode = new CStatDBBranch;
 212                 _Children.add(make_pair(token, nextNode));
 213         }
 214         else
 215         {
 216                 nextNode = (*it).second;
 217         }
 218
 219         return nextNode->setNode(rest, node);
 220 }
 221
 222 // ****************************************************************************
 223 IStatDBNodePtr CStatDBBranch::getNode(const std::string & path)
 224 {
 225         BOMB_IF(path.empty(), "empty path!", return NULL);
 226
 227         string token;
 228         string rest;
 229         splitPath(path, token, rest);
 230
 231         TChildren::iterator it = _Children.find(token);
 232         if (it == _Children.end())
 233                 return NULL;
 234
 235         if (rest.empty())
 236                 return (*it).second;
 237
 238         return (*it).second->getNode(rest);
 239 }
 240
 241 // ****************************************************************************
 242 void CStatDBBranch::getNodes(const std::string & pathPattern, std::vector<CMatchingNode> & matchingNodes,
 243                                                          const std::string & currentPath)
 244 {
 245         BOMB_IF(pathPattern.empty(), "empty path!", return);
 246
 247         // DO NOT clear the vector 'matchingNodes' here because this method is recursive
 248
 249         string token;
 250         string rest;
 251         splitPath(pathPattern, token, rest);
 252
 253         string pathPrefix = currentPath;
 254         if (!pathPrefix.empty())
 255                 pathPrefix += ".";
 256
 257         // check wildcard
 258         if (token == "*")
 259         {
 260                 if (rest.empty())
 261                 {
 262                         for (TChildren::iterator it = _Children.begin(); it != _Children.end(); ++it)
 263                         {
 264                                 CMatchingNode matchingNode;
 265                                 matchingNode.Path = pathPrefix + (*it).first;
 266                                 matchingNode.Node = (*it).second;
 267                                 matchingNodes.push_back(matchingNode);
 268                         }
 269                 }
 270                 else
 271                 {
 272                         for (TChildren::iterator it = _Children.begin(); it != _Children.end(); ++it)
 273                         {
 274                                 (*it).second->getNodes(rest, matchingNodes, pathPrefix + (*it).first);
 275                         }
 276                 }
 277                 return;
 278         }
 279
 280         TChildren::iterator it = _Children.find(token);
 281         if (it == _Children.end())
 282                 return;
 283
 284         if (rest.empty())
 285         {
 286                 CMatchingNode matchingNode;
 287                 matchingNode.Path = pathPrefix + (*it).first;
 288                 matchingNode.Node = (*it).second;
 289                 matchingNodes.push_back(matchingNode);
 290         }
 291         else
 292         {
 293                 (*it).second->getNodes(rest, matchingNodes, pathPrefix + (*it).first);
 294         }
 295 }
 296
 297 // ****************************************************************************
 298 IStatDBNodePtr CStatDBBranch::removeNode(const std::string & path)
 299 {
 300         BOMB_IF(path.empty(), "empty path!", return NULL);
 301
 302         string token;
 303         string rest;
 304         splitPath(path, token, rest);
 305
 306         TChildren::iterator it = _Children.find(token);
 307         if (it == _Children.end())
 308                 return NULL;
 309
 310         if (rest.empty())
 311         {
 312                 IStatDBNodePtr removedNode = (*it).second;
 313                 _Children.del(it);
 314                 return removedNode;
 315         }
 316
 317         return (*it).second->removeNode(rest);
 318 }
 319
 320 // ****************************************************************************
 321 void CStatDBBranch::acceptVisitor(CStatDBNodeVisitor & visitor, const std::string & currentPath)
 322 {
 323         string childPathPrefix;
 324         if (!currentPath.empty())
 325                 childPathPrefix = currentPath + ".";
 326
 327         visitor.visitBranch(this, currentPath);
 328
 329         for (TChildren::iterator it = _Children.begin(); it != _Children.end(); ++it)
 330         {
 331                 (*it).second->acceptVisitor(visitor, childPathPrefix + (*it).first);
 332         }
 333 }
 334
 335 // ****************************************************************************
 336 bool CStatDBBranch::isValidToken(const std::string & token) const
 337 {
 338         if (token.empty())
 339                 return false;
 340
 341         for (string::const_iterator it = token.begin(); it != token.end(); ++it)
 342         {
 343                 if (!isalnum(*it) && (*it) != '_')
 344                         return false;
 345         }
 346
 347         return true;
 348 }
 349
 350 // ****************************************************************************
 351 void CStatDBBranch::splitPath(const std::string & path, std::string & token, std::string & rest) const
 352 {
 353         string::size_type i = path.find('.');
 354         if (i == string::npos)
 355         {
 356                 token = path;
 357                 rest.clear();
 358         }
 359         else
 360         {
 361                 token = path.substr(0, i);
 362                 rest = path.substr(i+1);
 363         }
 364 }
 365
 366 // ****************************************************************************
 367 // CStatDBEntitiesRemoval
 368 // ****************************************************************************
 369
 370 // ****************************************************************************
 371 void CStatDBEntitiesRemoval::addPlayerToRemove(NLMISC::CEntityId playerId)
 372 {
 373         for (uint i = 0; i < _PlayersToRemove.size(); i++)
 374         {
 375                 if (_PlayersToRemove[i] == playerId)
 376                         return;
 377         }
 378
 379         _PlayersToRemove.push_back(playerId);
 380 }
 381
 382 // ****************************************************************************
 383 void CStatDBEntitiesRemoval::addGuildToRemove(EGSPD::TGuildId guildId)
 384 {
 385         for (uint i = 0; i < _GuildsToRemove.size(); i++)
 386         {
 387                 if (_GuildsToRemove[i] == guildId)
 388                         return;
 389         }
 390
 391         _GuildsToRemove.push_back(guildId);
 392 }
 393
 394 // ****************************************************************************
 395 void CStatDBEntitiesRemoval::processRemoval(IStatDBNodePtr root)
 396 {
 397         nlassert(root != NULL);
 398
 399         if (_PlayersToRemove.empty() && _GuildsToRemove.empty())
 400                 return;
 401
 402         root->acceptVisitor(*this, "");
 403
 404         _PlayersToRemove.clear();
 405         _GuildsToRemove.clear();
 406 }
 407
 408 // ****************************************************************************
 409 void CStatDBEntitiesRemoval::visitTableLeaf(CStatDBTableLeaf * tableLeaf, const std::string & path)
 410 {
 411         for (uint i = 0; i < _PlayersToRemove.size(); i++)
 412         {
 413                 tableLeaf->removePlayer(_PlayersToRemove[i]);
 414         }
 415
 416         for (uint i = 0; i < _GuildsToRemove.size(); i++)
 417         {
 418                 tableLeaf->removeGuild(_GuildsToRemove[i]);
 419         }
 420 }
 421