ryzom/server/src/pd_lib/pd_utils.h

   1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This source file has been modified by the following contributors:
   5 // Copyright (C) 2015  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 #ifndef RY_PDS_UTILS_H
  21 #define RY_PDS_UTILS_H
  22
  23 /*
  24  * NeL Includes
  25  */
  26 #include <nel/misc/types_nl.h>
  27 #include <nel/misc/common.h>
  28 #include <nel/misc/time_nl.h>
  29 #include <nel/misc/stream.h>
  30 #include <nel/misc/entity_id.h>
  31 #include <nel/misc/sheet_id.h>
  32 #include <nel/misc/variable.h>
  33
  34
  35 namespace RY_PDS
  36 {
  37
  38 /**
  39  * Definition of streamable persistent data.
  40  * Used to fetch data from PDS to service classes
  41  */
  42 typedef NLMISC::IStream         CPData;
  43
  44
  45
  46
  47
  48 /**
  49  * PD System Verbosity control
  50  */
  51 extern NLMISC::CVariable<bool>  PDVerbose;
  52
  53 /**
  54  * PD System Verbosity level
  55  */
  56 extern NLMISC::CVariable<sint>  PDVerboseLevel;
  57
  58 /**
  59  * PDS Resolve Unmapped rows
  60  * If true, PDS continue loading when it finds a row not mapped in a mapped table,
  61  * and keeps it unmapped.
  62  * Otherwise, loading fails.
  63  */
  64 extern NLMISC::CVariable<bool>  ResolveUnmappedRows;
  65
  66 /**
  67  * PDS Resolve Double Mapped Rows
  68  * If true, PDS continue loading when it finds a row already mapped, and keeps it unmapped.
  69  * Otherwise, loading fails.
  70  * See also ResolveDoubleMappedKeepOlder
  71  */
  72 extern NLMISC::CVariable<bool>  ResolveDoubleMappedRows;
  73
  74 /**
  75  * PDS Resolve Double Mapped Keep Older
  76  * If true, when finds a doubly mapped row at loading, keep only older row as mapped (lesser row index)
  77  * See also ResolveDoubleMappedRows.
  78  */
  79 extern NLMISC::CVariable<bool>  ResolveDoubleMappedKeepOlder;
  80
  81 /**
  82  * PDS Resolve Unallocated rows
  83  * If true, when finds a reference to an unallocated row or an invalid row, force reference to null.
  84  */
  85 extern NLMISC::CVariable<bool>  ResolveInvalidRow;
  86
  87
  88
  89
  90
  91
  92 /**
  93  * Definition of Table indices
  94  */
  95 typedef uint16                  TTableIndex;
  96
  97 /**
  98  * Definition of Row indices
  99  */
 100 typedef uint32                  TRowIndex;
 101
 102 /**
 103  * Definition of Column indices
 104  */
 105 typedef uint16                  TColumnIndex;
 106
 107 /**
 108  * Definition of index Checksum validator
 109  */
 110 typedef uint16                  TIndexChecksum;
 111
 112
 113 /**
 114  * Table & Row indices constants
 115  */
 116 const TTableIndex               INVALID_TABLE_INDEX = 0xffff;
 117 const TRowIndex                 INVALID_ROW_INDEX = 0xffffffff;
 118 const TColumnIndex              INVALID_COLUMN_INDEX = 0xffff;
 119
 120 /**
 121  * Checksum
 122  */
 123 const TIndexChecksum    VALID_INDEX_CHECKSUM = 0xdead;
 124
 125 /**
 126  * Default Hashing Function
 127  */
 128 /*template<typename T>
 129 class CDefaultHash
 130 {
 131 public:
 132         size_t  operator() (const T& value) const       { return (uint32)value; }
 133 };*/
 134
 135 /**
 136  * Table Container Interface
 137  */
 138 class ITableContainer
 139 {
 140 public:
 141
 142         /// Get Table Index
 143         virtual TTableIndex             getTableIndex(const std::string& tableName) const = 0;
 144
 145         /// Get Table Name
 146         virtual std::string             getTableName(TTableIndex tableIndex) const = 0;
 147 };
 148
 149
 150
 151 /**
 152  * Definition of Object indices
 153  * An object is pointed by a table index and a row index
 154  * \author Benjamin Legros
 155  * \author Nevrax France
 156  * \date 2004
 157  */
 158 class CObjectIndex
 159 {
 160 public:
 161
 162         /// Constructor of invalid index
 163         explicit CObjectIndex(bool validateChecksum = false) : _Row(INVALID_ROW_INDEX), _Table(INVALID_TABLE_INDEX), _Checksum((TIndexChecksum)~VALID_INDEX_CHECKSUM)
 164         {
 165                 if (validateChecksum)
 166                         validate();
 167                 else
 168                         invalidate();
 169         }
 170
 171         /// Constructor
 172         CObjectIndex(TTableIndex table, TRowIndex row) : _Row(row), _Table(table)               { validate(); }
 173
 174         /// Constructor
 175         CObjectIndex(const CObjectIndex &index)                                                                                 { *this = index; }
 176
 177
 178
 179
 180
 181         /// Cast operator
 182         operator uint64 () const                                                                                                                { return _FullIndex; }
 183
 184         /// Get Table index
 185         TTableIndex             table() const                                                                                                   { return _Table; }
 186
 187         /// Get Row index
 188         TRowIndex               row() const                                                                                                             { return _Row; }
 189
 190
 191
 192
 193         /// Copy
 194         CObjectIndex    & operator = (const CObjectIndex &index)                                                { _FullIndex = index._FullIndex; return *this; }
 195
 196         /// Equal?
 197         bool                    operator == (const CObjectIndex &index) const                                   { return _FullIndex == index._FullIndex; }
 198
 199         /// Not equal?
 200         bool                    operator != (const CObjectIndex &index) const                                   { return !(*this == index); }
 201
 202
 203
 204         /// Return null
 205         static CObjectIndex             null()
 206         {
 207                 return CObjectIndex(true);
 208         }
 209
 210
 211
 212         /// Checksum valid?
 213         bool                    isChecksumValid() const
 214         {
 215                 return getChecksum() == VALID_INDEX_CHECKSUM;
 216         }
 217
 218         /// Is it Null Ptr?
 219         bool                    isNull() const
 220         {
 221                 return _Table == INVALID_TABLE_INDEX && _Row == INVALID_ROW_INDEX && isChecksumValid();
 222         }
 223
 224         /// Validity check
 225         bool                    isValid() const
 226         {
 227                 return _Table != INVALID_TABLE_INDEX && _Row != INVALID_ROW_INDEX && isChecksumValid();
 228         }
 229
 230
 231
 232
 233         /// transform to string
 234         std::string             toString(const ITableContainer* container = NULL) const
 235         {
 236                 if (isValid())
 237                 {
 238                         if (container != NULL)
 239                         {
 240                                 return NLMISC::toString("(%s:%u)", container->getTableName(_Table).c_str(), _Row);
 241                         }
 242                         else
 243                         {
 244                                 return NLMISC::toString("(%u:%u)", _Table, _Row);
 245                         }
 246                 }
 247                 else if (isNull())
 248                 {
 249                         return "<Null>";
 250                 }
 251                 else
 252                 {
 253                         return NLMISC::toString("(%u:%u <invalid>)", _Table, _Row);
 254                 }
 255         }
 256
 257         /// get from string
 258         void                    fromString(const char* str, const ITableContainer* container = NULL)
 259         {
 260                 uint            table;
 261                 uint            row;
 262                 uint            valid;
 263
 264                 if (sscanf(str, "(%d:%d:%d)", &table, &row, &valid) == 3)
 265                 {
 266                         _Table = (TTableIndex)table;
 267                         _Row = (TRowIndex)row;
 268
 269                         if (valid != 0)
 270                                 validate();
 271                         else
 272                                 invalidate();
 273
 274                         return;
 275                 }
 276                 else if (sscanf(str, "(%d:%d)", &table, &row) == 2)
 277                 {
 278                         _Table = (TTableIndex)table;
 279                         _Row = (TRowIndex)row;
 280                         validate();
 281
 282                         return;
 283                 }
 284                 else if (container != NULL && parseIndexWithName(str, container))
 285                 {
 286                         validate();
 287                         return;
 288                 }
 289
 290                 *this = CObjectIndex::null();
 291                 return;
 292         }
 293
 294         void                    serial(NLMISC::IStream& f)
 295         {
 296                 f.serial(_FullIndex);
 297         }
 298
 299 private:
 300
 301         bool                    parseIndexWithName(const char* str, const ITableContainer* container)
 302         {
 303                 TRowIndex       row;
 304                 TTableIndex     table;
 305
 306                 if (*(str++) != '(')
 307                         return false;
 308
 309                 std::string     tableName;
 310
 311                 while (*str != '\0' && *str != ':')
 312                         tableName += *(str++);
 313
 314                 if (*(str++) != ':')
 315                         return false;
 316
 317                 table = container->getTableIndex(tableName);
 318                 if (table == INVALID_TABLE_INDEX)
 319                         return false;
 320
 321                 NLMISC::fromString(std::string(str), row);
 322
 323                 while (*str >= '0' && *str <= '9')
 324                         ++str;
 325
 326                 if (*str != ')')
 327                         return false;
 328
 329                 _Row = row;
 330                 _Table = table;
 331
 332                 return true;
 333         }
 334
 335
 336 #ifdef NL_OS_WINDOWS
 337
 338         #define PDS_ROW_LO_WORD         0
 339         #define PDS_ROW_HI_WORD         1
 340         #define PDS_TABLE_WORD          2
 341         #define PDS_CHECKSUM_WORD       3
 342
 343 #else
 344
 345         #define PDS_ROW_LO_WORD         0
 346         #define PDS_ROW_HI_WORD         1
 347         #define PDS_TABLE_WORD          2
 348         #define PDS_CHECKSUM_WORD       3
 349
 350 #endif
 351
 352         union
 353         {
 354                 struct
 355                 {
 356                         TRowIndex                       _Row;
 357                         TTableIndex                     _Table;
 358                         TIndexChecksum          _Checksum;
 359                 };
 360                 uint64                                  _FullIndex;
 361                 uint16                                  _Words[4];
 362         };
 363
 364         /// Compute partial checksum of the index
 365         TIndexChecksum          getPartialChecksum() const
 366         {
 367                 return _Words[PDS_ROW_LO_WORD] ^ _Words[PDS_ROW_HI_WORD] ^ _Words[PDS_TABLE_WORD];
 368         }
 369
 370         /// Get checksum of the index
 371         TIndexChecksum          getChecksum() const
 372         {
 373                 return getPartialChecksum() ^ _Words[PDS_CHECKSUM_WORD];
 374         }
 375
 376         /// Force validation of an index
 377         void                            validate()
 378         {
 379                 _Checksum = getPartialChecksum() ^ VALID_INDEX_CHECKSUM;
 380         }
 381
 382         /// Force invalidation of an index
 383         void                            invalidate()
 384         {
 385                 _Checksum = getPartialChecksum() ^ (~VALID_INDEX_CHECKSUM);
 386         }
 387 };
 388
 389
 390
 391 /**
 392  * Definition of column index
 393  * \author Benjamin Legros
 394  * \author Nevrax France
 395  * \date 2004
 396  */
 397 class CColumnIndex
 398 {
 399 public:
 400
 401         /// Constructor
 402         explicit CColumnIndex(TTableIndex table = INVALID_TABLE_INDEX, TRowIndex row = INVALID_ROW_INDEX, TColumnIndex column = INVALID_COLUMN_INDEX)
 403                 : _Table(table), _Column(column), _Row(row)
 404         {
 405         }
 406
 407         /// Constructor
 408         explicit CColumnIndex(const CObjectIndex& object, TColumnIndex column)
 409                 : _Table(INVALID_TABLE_INDEX), _Column(INVALID_COLUMN_INDEX), _Row(INVALID_ROW_INDEX)
 410         {
 411                 if (!object.isValid())
 412                         return;
 413
 414                 _Table = object.table();
 415                 _Row = object.row();
 416                 _Column = column;
 417         }
 418
 419
 420         /// Get Table Index
 421         TTableIndex             table() const                                   { return _Table; }
 422         /// Get Row Index
 423         TRowIndex               row() const                                             { return _Row; }
 424         /// Get Column Index
 425         TColumnIndex    column() const                                  { return _Column; }
 426
 427         /// Test if is null
 428         bool                    isNull() const                                  { return _Table == INVALID_TABLE_INDEX && _Row == INVALID_ROW_INDEX && _Column == INVALID_COLUMN_INDEX; }
 429
 430
 431         /// Cast to 64 bits
 432         operator uint64() const                                                 { return _FullIndex; }
 433
 434         /// 32 bits hash key
 435         uint32                  hash() const                                    { return (uint32) ((_Table<<2) ^ (_Row<<1) ^ _Column); }
 436
 437         /// Operator <
 438         bool                    operator < (const CColumnIndex& b) const        { return _FullIndex < b._FullIndex; }
 439
 440         /// transform to string
 441         std::string             toString(const ITableContainer* container = NULL) const
 442         {
 443                 if (isNull())
 444                 {
 445                         return "<Null>";
 446                 }
 447                 else if (container != NULL)
 448                 {
 449                         return NLMISC::toString("(%s:%u:%u)", container->getTableName(_Table).c_str(), _Row, _Column);
 450                 }
 451                 else
 452                 {
 453                         return NLMISC::toString("(%u:%u:%u)", _Table, _Row, _Column);
 454                 }
 455         }
 456
 457 private:
 458
 459         union
 460         {
 461                 struct
 462                 {
 463                         /// Table Index
 464                         TTableIndex             _Table;
 465
 466                         /// Column Index in row
 467                         TColumnIndex    _Column;
 468
 469                         /// Row Index in table
 470                         TRowIndex               _Row;
 471                 };
 472
 473                 /// Full 64 bits index
 474                 uint64                          _FullIndex;
 475         };
 476 };
 477
 478 /**
 479  * Definition of set of object indexes
 480  * This is actually a index on the first element of a list contained in each database
 481  */
 482 typedef std::vector<CObjectIndex>               TIndexList;
 483
 484
 485 /**
 486  * A container of index lists
 487  * \author Benjamin Legros
 488  * \author Nevrax France
 489  * \date 2004
 490  */
 491
 492 //#define DEBUG_SETMAP_ACCESSOR
 493
 494 struct CColumnIndexHashMapTraits
 495 {
 496         enum { bucket_size = 4, min_buckets = 8 };
 497         CColumnIndexHashMapTraits() { }
 498         size_t operator() (const CColumnIndex &id) const
 499         {
 500                 return id.hash();
 501         }
 502         bool operator()(const CColumnIndex &left, const CColumnIndex &right)
 503         {
 504                 return left < right;
 505         }
 506 };
 507
 508 class CSetMap
 509 {
 510 public:
 511
 512         /// Hash Key
 513         /*class CKeyHash
 514         {
 515         public:
 516                 size_t  operator() (const CColumnIndex& key) const      { return (uint32)(key.hash()); }
 517         };*/
 518
 519         /// Map of lists
 520         typedef CHashMap<CColumnIndex, TIndexList, CColumnIndexHashMapTraits>                   TListMap;
 521
 522         /// An Accessor on a list
 523         class CAccessor
 524         {
 525         public:
 526
 527                 /// Constructor, only builds invalid accessor
 528                 CAccessor() : _Valid(false)                                                                             { }
 529
 530                 /// Is Valid
 531                 bool                            isValid() const                                                         { return _Valid; }
 532
 533                 /// Get whole list
 534                 const TIndexList&       get() const                                                                     { nlassert(isValid()); return (*_It).second; }
 535
 536                 /// Test if object belongs to list
 537                 bool                            belongsTo(const CObjectIndex& test) const
 538                 {
 539                         nlassert(isValid());
 540                         return std::find((*_It).second.begin(), (*_It).second.end(), test) != (*_It).second.end();
 541                 }
 542
 543                 /// Add index to list
 544                 void                            add(const CObjectIndex& index)
 545                 {
 546                         nlassert(isValid());
 547                         if (!belongsTo(index))
 548                         {
 549                                 (*_It).second.push_back(index);
 550                         }
 551                 }
 552
 553                 /// Remove index from list
 554                 void                            erase(const CObjectIndex& index)
 555                 {
 556                         nlassert(isValid());
 557
 558                         TIndexList&                    iList = (*_It).second;
 559                         TIndexList::iterator     itr;
 560                         for (itr=iList.begin(); itr!=iList.end(); )
 561                                 itr = ((*itr == index) ? iList.erase(itr) : (itr+1));
 562
 563                         // gcc can't resolve this:
 564                         //(*_It).second.erase(std::remove((*_It).second.begin(), (*_It).second.end(), index), (*_It).second.end());
 565                 }
 566
 567                 /// Dump list
 568                 void                            display() const
 569                 {
 570                         if (!isValid())
 571                         {
 572                                 nlinfo("<can't display set>");
 573                                 return;
 574                         }
 575
 576 #ifdef DEBUG_SETMAP_ACCESSOR
 577                         nlinfo("Set '%s' content:", _Debug.toString().c_str());
 578 #else
 579                         nlinfo("Set content:");
 580 #endif
 581                         TIndexList::const_iterator      it;
 582                         for (it=(*_It).second.begin(); it!=(*_It).second.end(); ++it)
 583                                 nlinfo("%s", (*it).toString().c_str());
 584                 }
 585
 586         private:
 587
 588                 friend class CSetMap;
 589
 590                 /// Internal pointer to list
 591                 TListMap::iterator      _It;
 592
 593                 /// Is Valid
 594                 bool                            _Valid;
 595
 596 #ifdef DEBUG_SETMAP_ACCESSOR
 597
 598                 CColumnIndex            _Debug;
 599
 600                 /// constructor for CIndexListMap
 601                 CAccessor(TListMap::iterator it, const CColumnIndex& index) : _It(it), _Valid(true), _Debug(index)              { }
 602
 603 #else
 604
 605                 /// constructor for CIndexListMap
 606                 CAccessor(TListMap::iterator it, const CColumnIndex& index) : _It(it), _Valid(true)                                             { }
 607
 608 #endif
 609
 610         };
 611
 612
 613         /// Get the list associated to this column
 614         CAccessor                               get(const CColumnIndex& index)
 615         {
 616                 TListMap::iterator      it = _Map.find(index);
 617                 if (it == _Map.end())
 618                 {
 619                         it = _Map.insert(TListMap::value_type(index, TIndexList())).first;
 620                 }
 621                 return CAccessor(it, index);
 622         }
 623
 624         /// Clear up whole map
 625         void                                    clear()                                                                         { _Map.clear(); }
 626
 627 private:
 628
 629         friend class CAccessor;
 630
 631         TListMap                _Map;
 632
 633 };
 634
 635
 636
 637
 638
 639 /**
 640  * Base class for Row accessible objects.
 641  * Contains a Row index, used to represent the object in the database
 642  * Classes that derive from this class are assumed to know their own Table index.
 643  * \author Benjamin Legros
 644  * \author Nevrax France
 645  * \date 2004
 646  */
 647 class IPDBaseData
 648 {
 649 public:
 650
 651         /// Constructor
 652         IPDBaseData() : __BaseRow(INVALID_ROW_INDEX), __BaseTable(INVALID_TABLE_INDEX) {}
 653
 654         /// Get Row index
 655         TRowIndex       getRow() const  { return __BaseRow; }
 656
 657         /// Get Table index
 658         TTableIndex     getTable() const        { return __BaseTable; }
 659
 660 protected:
 661
 662         TRowIndex       __BaseRow;
 663         TTableIndex     __BaseTable;
 664
 665         friend class CPDSLib;
 666 };
 667
 668
 669
 670 /**
 671  * A class that allocates and deallocate indices in PDS database.
 672  * The allocator is able to init itself from a PDS command
 673  * \author Benjamin Legros
 674  * \author Nevrax France
 675  * \date 2004
 676  */
 677 class CIndexAllocator
 678 {
 679 public:
 680
 681         CIndexAllocator() : _NextIndex(0)       { }
 682
 683         TRowIndex                       allocate()
 684         {
 685                 // no index in stack, get next
 686                 if (_FreeIndices.empty())
 687                         return _NextIndex++;
 688
 689                 // pop a free index
 690                 TRowIndex       index = _FreeIndices.front();
 691                 _FreeIndices.pop_front();
 692                 return index;
 693         }
 694
 695         void                            deallocate(TRowIndex index)
 696         {
 697                 // push index on stack
 698                 _FreeIndices.push_back(index);
 699         }
 700
 701         void                            forceAllocated(TRowIndex index)
 702         {
 703                 for (; _NextIndex<index; ++_NextIndex)
 704                         _FreeIndices.push_back(_NextIndex);
 705
 706                 // remove index from free if was there
 707                 std::deque<TRowIndex>::iterator it = std::find(_FreeIndices.begin(), _FreeIndices.end(), index);
 708                 if (it != _FreeIndices.end())
 709                         _FreeIndices.erase(it);
 710
 711                 if (_NextIndex < index+1)
 712                         _NextIndex = index+1;
 713         }
 714
 715         void                            clear()
 716         {
 717                 _NextIndex = 0;
 718                 _FreeIndices.clear();
 719         }
 720
 721         void                            serial(NLMISC::IStream& f)
 722         {
 723                 f.serialCheck(NELID("IALC"));
 724                 f.serialVersion(0);
 725
 726                 f.serial(_NextIndex);
 727                 f.serialCont(_FreeIndices);
 728         }
 729
 730 private:
 731
 732         /// Next free index
 733         TRowIndex                                               _NextIndex;
 734
 735         /// Free items
 736         std::deque<TRowIndex>                   _FreeIndices;
 737 };
 738
 739
 740
 741
 742
 743
 744 typedef IPDBaseData*    (*TPDFactory)();
 745 typedef void                    (*TPDFetch)(IPDBaseData*, CPData&);
 746 typedef void                    (*TPDFetchFailure)(uint64 key);
 747
 748
 749
 750 /**
 751  * Get Value as String
 752  */
 753 template<typename T>
 754 std::string                     pdsToString(const T& value)                                     { return NLMISC::toString(value); }
 755
 756 inline std::string      pdsToString(const bool& value)                          { return value ? std::string("true") : std::string("false"); }
 757 inline std::string      pdsToString(const CObjectIndex& value)          { return value.toString(); }
 758 inline std::string      pdsToString(const CColumnIndex& value)          { return value.toString(); }
 759 inline std::string      pdsToString(const NLMISC::CSheetId& value)      { return value.toString(); }
 760 inline std::string      pdsToString(const NLMISC::CEntityId& value)     { return value.toString(); }
 761
 762
 763 }; // RY_PDS
 764
 765 #endif //RY_PDS_UTILS_H
 766
 767
 768