store/source/stordata.hxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: stordata.hxx,v $
  10  * $Revision: 1.6 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #ifndef _STORE_STORDATA_HXX_
  32 #define _STORE_STORDATA_HXX_ "$Revision: 1.6.8.2 $"
  33
  34 #include "sal/types.h"
  35 #include "sal/macros.h"
  36
  37 #include "store/types.h"
  38 #include "storbase.hxx"
  39
  40 namespace store
  41 {
  42
  43 /*========================================================================
  44  *
  45  * OStoreDataPageData.
  46  *
  47  *======================================================================*/
  48 #define STORE_MAGIC_DATAPAGE sal_uInt32(0x94190310)
  49
  50 struct OStoreDataPageData : public store::OStorePageData
  51 {
  52     typedef OStorePageData       base;
  53     typedef OStoreDataPageData   self;
  54
  55     typedef OStorePageDescriptor D;
  56
  57     /** Representation.
  58     */
  59     sal_uInt8 m_pData[1];
  60
  61     /** type.
  62      */
  63     static const sal_uInt32 theTypeId = STORE_MAGIC_DATAPAGE;
  64
  65     /** size.
  66     */
  67     static const size_t     theSize     = 0;
  68     static const sal_uInt16 thePageSize = base::theSize + self::theSize;
  69     STORE_STATIC_ASSERT(STORE_MINIMUM_PAGESIZE >= self::thePageSize);
  70
  71     /** capacity.
  72     */
  73     static sal_uInt16 capacity (const D& rDescr) // @see inode::ChunkDescriptor
  74     {
  75         return (store::ntohs(rDescr.m_nSize) - self::thePageSize);
  76     }
  77     sal_uInt16 capacity() const
  78     {
  79         return self::capacity (base::m_aDescr);
  80     }
  81
  82     /** usage.
  83     */
  84     sal_uInt16 usage() const
  85     {
  86         return (store::ntohs(base::m_aDescr.m_nUsed) - self::thePageSize);
  87     }
  88
  89     /** Construction.
  90     */
  91     explicit OStoreDataPageData (sal_uInt16 nPageSize = self::thePageSize)
  92         : base (nPageSize)
  93     {
  94         base::m_aGuard.m_nMagic = store::htonl(self::theTypeId);
  95         base::m_aDescr.m_nUsed  = store::htons(self::thePageSize);
  96         memset (m_pData, 0, capacity());
  97     }
  98
  99     /** guard (external representation).
 100     */
 101     void guard() {}
 102
 103     /** verify (external representation).
 104     */
 105     storeError verify() const { return store_E_None; }
 106 };
 107
 108 /*========================================================================
 109  *
 110  * OStoreDataPageObject.
 111  *
 112  *======================================================================*/
 113 class OStoreDataPageObject : public store::OStorePageObject
 114 {
 115     typedef OStorePageObject     base;
 116     typedef OStoreDataPageData   page;
 117
 118 public:
 119     /** Construction.
 120     */
 121     explicit OStoreDataPageObject (PageHolder const & rxPage = PageHolder())
 122         : OStorePageObject (rxPage)
 123     {}
 124
 125     /** External representation.
 126      */
 127     virtual storeError guard  (sal_uInt32 nAddr);
 128     virtual storeError verify (sal_uInt32 nAddr) const;
 129 };
 130
 131 /*========================================================================
 132  *
 133  * OStoreIndirectionPageData.
 134  *
 135  *======================================================================*/
 136 #define STORE_MAGIC_INDIRECTPAGE sal_uInt32(0x89191107)
 137
 138 struct OStoreIndirectionPageData : public store::OStorePageData
 139 {
 140     typedef OStorePageData            base;
 141     typedef OStoreIndirectionPageData self;
 142
 143     typedef OStorePageGuard           G;
 144     typedef OStorePageDescriptor      D;
 145
 146     /** Representation.
 147     */
 148     G          m_aGuard;
 149     sal_uInt32 m_pData[1];
 150
 151     /** type.
 152      */
 153     static const sal_uInt32 theTypeId = STORE_MAGIC_INDIRECTPAGE;
 154
 155     /** size.
 156      */
 157     static const size_t     theSize     = sizeof(G);
 158     static const sal_uInt16 thePageSize = base::theSize + self::theSize;
 159     STORE_STATIC_ASSERT(STORE_MINIMUM_PAGESIZE >= self::thePageSize);
 160
 161     /** capacity.
 162     */
 163     static sal_uInt16 capacity (const D& rDescr)
 164     {
 165         return (store::ntohs(rDescr.m_nSize) - self::thePageSize);
 166     }
 167     sal_uInt16 capacity() const
 168     {
 169         return self::capacity (base::m_aDescr);
 170     }
 171
 172     /** capacityCount.
 173     */
 174     static sal_uInt16 capacityCount (const D& rDescr) // @see DirectoryPageObject::scope()
 175     {
 176         return sal_uInt16(capacity(rDescr) / sizeof(sal_uInt32));
 177     }
 178     sal_uInt16 capacityCount() const
 179     {
 180         return sal_uInt16(capacity() / sizeof(sal_uInt32));
 181     }
 182
 183     /** Construction.
 184     */
 185     explicit OStoreIndirectionPageData (sal_uInt16 nPageSize)
 186         : base (nPageSize)
 187     {
 188         base::m_aGuard.m_nMagic = store::htonl(self::theTypeId);
 189         base::m_aDescr.m_nUsed  = store::htons(self::thePageSize);
 190         self::m_aGuard.m_nMagic = store::htonl(0);
 191         memset (m_pData, STORE_PAGE_NULL, capacity());
 192     }
 193
 194     /** guard (external representation).
 195     */
 196     void guard()
 197     {
 198         sal_uInt32 nCRC32 = 0;
 199         nCRC32 = rtl_crc32 (nCRC32, &m_aGuard.m_nMagic, sizeof(sal_uInt32));
 200         nCRC32 = rtl_crc32 (nCRC32, m_pData, capacity());
 201         m_aGuard.m_nCRC32 = store::htonl(nCRC32);
 202     }
 203
 204     /** verify (external representation).
 205     */
 206     storeError verify() const
 207     {
 208         return store_E_None;
 209         sal_uInt32 nCRC32 = 0;
 210         nCRC32 = rtl_crc32 (nCRC32, &m_aGuard.m_nMagic, sizeof(sal_uInt32));
 211         nCRC32 = rtl_crc32 (nCRC32, m_pData, capacity());
 212         if (m_aGuard.m_nCRC32 != store::htonl(nCRC32))
 213             return store_E_InvalidChecksum;
 214         else
 215             return store_E_None;
 216     }
 217 };
 218
 219 /*========================================================================
 220  *
 221  * OStoreIndirectionPageObject.
 222  *
 223  *======================================================================*/
 224 class OStoreIndirectionPageObject : public store::OStorePageObject
 225 {
 226     typedef OStorePageObject          base;
 227     typedef OStoreIndirectionPageData page;
 228
 229 public:
 230     /** Construction.
 231     */
 232     explicit OStoreIndirectionPageObject (PageHolder const & rxPage = PageHolder())
 233         : OStorePageObject (rxPage)
 234     {}
 235
 236     /** External representation.
 237     */
 238     storeError loadOrCreate (
 239         sal_uInt32       nAddr,
 240         OStorePageBIOS & rBIOS);
 241
 242     virtual storeError guard  (sal_uInt32 nAddr);
 243     virtual storeError verify (sal_uInt32 nAddr) const;
 244
 245     /** read (indirect data page).
 246     */
 247     storeError read (
 248         sal_uInt16             nSingle,
 249         OStoreDataPageObject  &rData,
 250         OStorePageBIOS        &rBIOS);
 251
 252     storeError read (
 253         sal_uInt16             nDouble,
 254         sal_uInt16             nSingle,
 255         OStoreDataPageObject  &rData,
 256         OStorePageBIOS        &rBIOS);
 257
 258     storeError read (
 259         sal_uInt16             nTriple,
 260         sal_uInt16             nDouble,
 261         sal_uInt16             nSingle,
 262         OStoreDataPageObject  &rData,
 263         OStorePageBIOS        &rBIOS);
 264
 265     /** write (indirect data page).
 266     */
 267     storeError write (
 268         sal_uInt16             nSingle,
 269         OStoreDataPageObject  &rData,
 270         OStorePageBIOS        &rBIOS);
 271
 272     storeError write (
 273         sal_uInt16             nDouble,
 274         sal_uInt16             nSingle,
 275         OStoreDataPageObject  &rData,
 276         OStorePageBIOS        &rBIOS);
 277
 278     storeError write (
 279         sal_uInt16             nTriple,
 280         sal_uInt16             nDouble,
 281         sal_uInt16             nSingle,
 282         OStoreDataPageObject  &rData,
 283         OStorePageBIOS        &rBIOS);
 284
 285     /** truncate (indirect data page).
 286     */
 287     storeError truncate (
 288         sal_uInt16             nSingle,
 289         OStorePageBIOS        &rBIOS);
 290
 291     storeError truncate (
 292         sal_uInt16             nDouble,
 293         sal_uInt16             nSingle,
 294         OStorePageBIOS        &rBIOS);
 295
 296     storeError truncate (
 297         sal_uInt16             nTriple,
 298         sal_uInt16             nDouble,
 299         sal_uInt16             nSingle,
 300         OStorePageBIOS        &rBIOS);
 301 };
 302
 303 /*========================================================================
 304  *
 305  * OStorePageNameBlock.
 306  *
 307  *======================================================================*/
 308 struct OStorePageNameBlock
 309 {
 310     typedef OStorePageGuard G;
 311     typedef OStorePageKey   K;
 312
 313     /** Representation.
 314     */
 315     G          m_aGuard;
 316     K          m_aKey;
 317     sal_uInt32 m_nAttrib;
 318     sal_Char   m_pData[STORE_MAXIMUM_NAMESIZE];
 319
 320     /** size.
 321     */
 322     static const size_t theSize = sizeof(G) + sizeof(K) + sizeof(sal_uInt32) + sizeof(sal_Char[STORE_MAXIMUM_NAMESIZE]);
 323
 324     /** initialize.
 325     */
 326     void initialize (void)
 327     {
 328         m_aGuard  = G();
 329         m_aKey    = K();
 330         m_nAttrib = 0;
 331         memset (m_pData, 0, sizeof(m_pData));
 332     }
 333
 334     /** Construction.
 335     */
 336     OStorePageNameBlock (void)
 337         : m_aGuard(), m_aKey(), m_nAttrib (0)
 338     {
 339         memset (m_pData, 0, sizeof(m_pData));
 340     }
 341
 342     /** guard (external representation).
 343     */
 344     void guard()
 345     {
 346         sal_uInt32 nCRC32 = 0;
 347         nCRC32 = rtl_crc32 (nCRC32, &m_aGuard.m_nMagic, sizeof(sal_uInt32));
 348         nCRC32 = rtl_crc32 (nCRC32, &m_aKey, theSize - sizeof(G));
 349         m_aGuard.m_nCRC32 = store::htonl(nCRC32);
 350     }
 351
 352     /** verify (external representation).
 353     */
 354     storeError verify() const
 355     {
 356         sal_uInt32 nCRC32 = 0;
 357         nCRC32 = rtl_crc32 (nCRC32, &m_aGuard.m_nMagic, sizeof(sal_uInt32));
 358         nCRC32 = rtl_crc32 (nCRC32, &m_aKey, theSize - sizeof(G));
 359         if (m_aGuard.m_nCRC32 != store::htonl(nCRC32))
 360             return store_E_InvalidChecksum;
 361         else
 362             return store_E_None;
 363     }
 364 };
 365
 366 /*========================================================================
 367  *
 368  * OStoreDirectoryDataBlock.
 369  *
 370  *======================================================================*/
 371 #define STORE_LIMIT_DATAPAGE_DIRECT 16
 372 #define STORE_LIMIT_DATAPAGE_SINGLE  8
 373 #define STORE_LIMIT_DATAPAGE_DOUBLE  1
 374 #define STORE_LIMIT_DATAPAGE_TRIPLE  1
 375
 376 struct OStoreDirectoryDataBlock
 377 {
 378     typedef OStorePageGuard G;
 379
 380     /** LinkDescriptor.
 381     */
 382     struct LinkDescriptor
 383     {
 384         /** Representation.
 385         */
 386         sal_uInt16 m_nIndex0;
 387         sal_uInt16 m_nIndex1;
 388         sal_uInt16 m_nIndex2;
 389         sal_uInt16 m_nIndex3;
 390
 391         /** Construction.
 392         */
 393         LinkDescriptor (void)
 394             : m_nIndex0 ((sal_uInt16)(~0)),
 395               m_nIndex1 ((sal_uInt16)(~0)),
 396               m_nIndex2 ((sal_uInt16)(~0)),
 397               m_nIndex3 ((sal_uInt16)(~0))
 398         {}
 399     };
 400
 401     /** LinkTable.
 402     */
 403     struct LinkTable
 404     {
 405         /** Representation.
 406         */
 407         sal_uInt32 m_pDirect[STORE_LIMIT_DATAPAGE_DIRECT];
 408         sal_uInt32 m_pSingle[STORE_LIMIT_DATAPAGE_SINGLE];
 409         sal_uInt32 m_pDouble[STORE_LIMIT_DATAPAGE_DOUBLE];
 410         sal_uInt32 m_pTriple[STORE_LIMIT_DATAPAGE_TRIPLE];
 411
 412         /** initialize.
 413         */
 414         void initialize (void)
 415         {
 416           memset(m_pDirect, STORE_PAGE_NULL, sizeof(m_pDirect));
 417           memset(m_pSingle, STORE_PAGE_NULL, sizeof(m_pSingle));
 418           memset(m_pDouble, STORE_PAGE_NULL, sizeof(m_pDouble));
 419           memset(m_pTriple, STORE_PAGE_NULL, sizeof(m_pTriple));
 420         }
 421
 422         /** Construction.
 423         */
 424         LinkTable (void)
 425         {
 426           initialize();
 427         }
 428     };
 429
 430     /** Representation.
 431     */
 432     G          m_aGuard;
 433     LinkTable  m_aTable;
 434     sal_uInt32 m_nDataLen;
 435
 436     /** size.
 437      */
 438     static const size_t theSize = sizeof(G) + sizeof(LinkTable) + sizeof(sal_uInt32);
 439
 440     /** initialize.
 441     */
 442     void initialize (void)
 443     {
 444         m_aGuard = G();
 445         m_aTable.initialize();
 446         m_nDataLen = 0;
 447     }
 448
 449     /** Construction.
 450     */
 451     OStoreDirectoryDataBlock (void)
 452         : m_aGuard(), m_aTable(), m_nDataLen (0)
 453     {}
 454
 455     /** guard (external representation).
 456     */
 457     void guard()
 458     {
 459         sal_uInt32 nCRC32 = 0;
 460         nCRC32 = rtl_crc32 (nCRC32, &m_aGuard.m_nMagic, sizeof(sal_uInt32));
 461         nCRC32 = rtl_crc32 (nCRC32, &m_aTable, theSize - sizeof(G));
 462         m_aGuard.m_nCRC32 = store::htonl(nCRC32);
 463     }
 464
 465     /** verify (external representation).
 466     */
 467     storeError verify() const
 468     {
 469         sal_uInt32 nCRC32 = 0;
 470         nCRC32 = rtl_crc32 (nCRC32, &m_aGuard.m_nMagic, sizeof(sal_uInt32));
 471         nCRC32 = rtl_crc32 (nCRC32, &m_aTable, theSize - sizeof(G));
 472         if (m_aGuard.m_nCRC32 != store::htonl(nCRC32))
 473             return store_E_InvalidChecksum;
 474         else
 475             return store_E_None;
 476     }
 477
 478     /** direct.
 479     */
 480     static sal_uInt16 directCount (void)
 481     {
 482         return ((sal_uInt16)(STORE_LIMIT_DATAPAGE_DIRECT));
 483     }
 484     sal_uInt32 directLink (sal_uInt16 nIndex) const
 485     {
 486         if (nIndex < directCount())
 487             return store::ntohl(m_aTable.m_pDirect[nIndex]);
 488         else
 489             return STORE_PAGE_NULL;
 490     }
 491     void directLink (sal_uInt16 nIndex, sal_uInt32 nAddr)
 492     {
 493         if (nIndex < directCount())
 494             m_aTable.m_pDirect[nIndex] = store::htonl(nAddr);
 495     }
 496
 497     /** single.
 498     */
 499     static sal_uInt16 singleCount (void)
 500     {
 501         return ((sal_uInt16)(STORE_LIMIT_DATAPAGE_SINGLE));
 502     }
 503     sal_uInt32 singleLink (sal_uInt16 nIndex) const
 504     {
 505         if (nIndex < singleCount())
 506             return store::ntohl(m_aTable.m_pSingle[nIndex]);
 507         else
 508             return STORE_PAGE_NULL;
 509     }
 510     void singleLink (sal_uInt16 nIndex, sal_uInt32 nAddr)
 511     {
 512         if (nIndex < singleCount())
 513             m_aTable.m_pSingle[nIndex] = store::htonl(nAddr);
 514     }
 515
 516     /** double.
 517     */
 518     static sal_uInt16 doubleCount (void)
 519     {
 520         return ((sal_uInt16)(STORE_LIMIT_DATAPAGE_DOUBLE));
 521     }
 522     sal_uInt32 doubleLink (sal_uInt16 nIndex) const
 523     {
 524         if (nIndex < doubleCount())
 525             return store::ntohl(m_aTable.m_pDouble[nIndex]);
 526         else
 527             return STORE_PAGE_NULL;
 528     }
 529     void doubleLink (sal_uInt16 nIndex, sal_uInt32 nAddr)
 530     {
 531         if (nIndex < doubleCount())
 532             m_aTable.m_pDouble[nIndex] = store::htonl(nAddr);
 533     }
 534
 535     /** triple.
 536     */
 537     static sal_uInt16 tripleCount (void)
 538     {
 539         return ((sal_uInt16)(STORE_LIMIT_DATAPAGE_TRIPLE));
 540     }
 541     sal_uInt32 tripleLink (sal_uInt16 nIndex) const
 542     {
 543         if (nIndex < tripleCount())
 544             return store::ntohl(m_aTable.m_pTriple[nIndex]);
 545         else
 546             return STORE_PAGE_NULL;
 547     }
 548     void tripleLink (sal_uInt16 nIndex, sal_uInt32 nAddr)
 549     {
 550         if (nIndex < tripleCount())
 551             m_aTable.m_pTriple[nIndex] = store::htonl(nAddr);
 552     }
 553 };
 554
 555 /*========================================================================
 556  *
 557  * OStoreDirectoryPageData.
 558  *
 559  *======================================================================*/
 560 #define STORE_MAGIC_DIRECTORYPAGE sal_uInt32(0x62190120)
 561
 562 struct OStoreDirectoryPageData : public store::OStorePageData
 563 {
 564     typedef OStorePageData           base;
 565     typedef OStoreDirectoryPageData  self;
 566
 567     typedef OStorePageDescriptor     D;
 568     typedef OStorePageNameBlock      NameBlock;
 569     typedef OStoreDirectoryDataBlock DataBlock;
 570
 571     /** Representation.
 572      */
 573     NameBlock m_aNameBlock;
 574     DataBlock m_aDataBlock;
 575     sal_uInt8 m_pData[1];
 576
 577     /** type.
 578      */
 579     static const sal_uInt32 theTypeId = STORE_MAGIC_DIRECTORYPAGE;
 580
 581     /** size.
 582      */
 583     static const size_t     theSize     = NameBlock::theSize + DataBlock::theSize;
 584     static const sal_uInt16 thePageSize = base::theSize + self::theSize;
 585     STORE_STATIC_ASSERT(STORE_MINIMUM_PAGESIZE >= self::thePageSize);
 586
 587     /** capacity.
 588     */
 589     sal_uInt16 capacity() const
 590     {
 591         return (store::ntohs(base::m_aDescr.m_nSize) - self::thePageSize);
 592     }
 593
 594     /** usage.
 595     */
 596     sal_uInt16 usage() const
 597     {
 598         return (store::ntohs(base::m_aDescr.m_nUsed) - self::thePageSize);
 599     }
 600
 601     /** initialize.
 602     */
 603     void initialize (void)
 604     {
 605         base::m_aGuard.m_nMagic = store::htonl(self::theTypeId);
 606         base::m_aDescr.m_nUsed  = store::htons(self::thePageSize);
 607
 608         m_aNameBlock.initialize();
 609         m_aDataBlock.initialize();
 610
 611         memset (m_pData, 0, capacity());
 612     }
 613
 614     /** Construction.
 615     */
 616     explicit OStoreDirectoryPageData (sal_uInt16 nPageSize)
 617         : base (nPageSize), m_aNameBlock(), m_aDataBlock()
 618     {
 619         base::m_aGuard.m_nMagic = store::htonl(self::theTypeId);
 620         base::m_aDescr.m_nUsed  = store::htons(self::thePageSize);
 621         memset (m_pData, 0, capacity());
 622     }
 623
 624     /** guard (external representation).
 625     */
 626     void guard()
 627     {
 628         m_aNameBlock.guard();
 629         m_aDataBlock.guard();
 630     }
 631
 632     /** verify (external representation).
 633     */
 634     storeError verify() const
 635     {
 636         storeError eErrCode = m_aNameBlock.verify();
 637         if (eErrCode == store_E_None)
 638             eErrCode = m_aDataBlock.verify();
 639         return eErrCode;
 640     }
 641
 642     /** ChunkDescriptor.
 643     */
 644     struct ChunkDescriptor
 645     {
 646         /** Representation.
 647         */
 648         sal_uInt32 m_nPage;
 649         sal_uInt16 m_nOffset;
 650         sal_uInt16 m_nLength;
 651
 652         /** Construction.
 653         */
 654         ChunkDescriptor (sal_uInt32 nPosition, sal_uInt16 nCapacity)
 655         {
 656             m_nPage   = nPosition / nCapacity;
 657             m_nOffset = (sal_uInt16)((nPosition % nCapacity) & 0xffff);
 658             m_nLength = nCapacity - m_nOffset;
 659         }
 660     };
 661
 662     /** ChunkScope.
 663     */
 664     enum ChunkScope
 665     {
 666         SCOPE_INTERNAL,
 667         SCOPE_EXTERNAL,
 668         SCOPE_DIRECT,
 669         SCOPE_SINGLE,
 670         SCOPE_DOUBLE,
 671         SCOPE_TRIPLE,
 672         SCOPE_UNREACHABLE,
 673         SCOPE_UNKNOWN
 674     };
 675
 676     /** scope (internal).
 677     */
 678     ChunkScope scope (sal_uInt32 nPosition) const
 679     {
 680         sal_uInt32 nCapacity = capacity();
 681         if (nPosition < nCapacity)
 682             return SCOPE_INTERNAL;
 683         else
 684             return SCOPE_EXTERNAL;
 685     }
 686 };
 687
 688 /*========================================================================
 689  *
 690  * OStoreDirectoryPageObject.
 691  *
 692  *======================================================================*/
 693 class OStoreDirectoryPageObject : public store::OStorePageObject
 694 {
 695     typedef OStorePageObject          base;
 696     typedef OStoreDirectoryPageData   page;
 697     typedef OStoreIndirectionPageData indirect;
 698
 699     typedef OStorePageDescriptor      D;
 700
 701 public:
 702     /** Construction.
 703     */
 704     explicit OStoreDirectoryPageObject (PageHolder const & rxPage = PageHolder())
 705         : OStorePageObject (rxPage)
 706     {}
 707
 708     /** External representation.
 709     */
 710     virtual storeError guard  (sal_uInt32 nAddr);
 711     virtual storeError verify (sal_uInt32 nAddr) const;
 712
 713     /** attrib.
 714     */
 715     sal_uInt32 attrib (void) const
 716     {
 717         return store::ntohl(PAGE().m_aNameBlock.m_nAttrib);
 718     }
 719     void attrib (sal_uInt32 nAttrib)
 720     {
 721         PAGE().m_aNameBlock.m_nAttrib = store::htonl(nAttrib);
 722         touch();
 723     }
 724
 725     /** key.
 726     */
 727     OStorePageKey key (void) const
 728     {
 729         return PAGE().m_aNameBlock.m_aKey;
 730     }
 731     void key (OStorePageKey const & rKey)
 732     {
 733         PAGE().m_aNameBlock.m_aKey = rKey;
 734         touch();
 735     }
 736
 737     /** path.
 738     */
 739     sal_uInt32 path (void) const
 740     {
 741         page const & rPage = PAGE();
 742         const sal_Char * pszName = rPage.m_aNameBlock.m_pData;
 743         sal_uInt32       nPath   = store::ntohl(rPage.m_aNameBlock.m_aKey.m_nHigh);
 744         return rtl_crc32 (nPath, pszName, rtl_str_getLength(pszName));
 745     }
 746
 747     sal_Size getName (sal_Char * pBuffer, sal_Size nBufsiz) const
 748     {
 749         sal_Char const * pszName = PAGE().m_aNameBlock.m_pData;
 750         sal_Size nLength = rtl_str_getLength(pszName);
 751         memcpy (pBuffer, pszName, SAL_MIN(nLength, nBufsiz));
 752         return nLength;
 753     }
 754
 755     /** dataLength.
 756     */
 757     sal_uInt32 dataLength (void) const
 758     {
 759         return store::ntohl(PAGE().m_aDataBlock.m_nDataLen);
 760     }
 761     void dataLength (sal_uInt32 nLength)
 762     {
 763         PAGE().m_aDataBlock.m_nDataLen = store::htonl(nLength);
 764         touch();
 765     }
 766
 767     /** direct.
 768     */
 769     sal_uInt32 directLink (sal_uInt16 nIndex) const
 770     {
 771         return PAGE().m_aDataBlock.directLink (nIndex);
 772     }
 773     void directLink (sal_uInt16 nIndex, sal_uInt32 nAddr)
 774     {
 775         PAGE().m_aDataBlock.directLink (nIndex, nAddr);
 776         touch();
 777     }
 778
 779     /** single indirect.
 780     */
 781     sal_uInt32 singleLink (sal_uInt16 nIndex) const
 782     {
 783         return PAGE().m_aDataBlock.singleLink (nIndex);
 784     }
 785     void singleLink (sal_uInt16 nIndex, sal_uInt32 nAddr)
 786     {
 787         PAGE().m_aDataBlock.singleLink (nIndex, nAddr);
 788         touch();
 789     }
 790
 791     /** double indirect.
 792     */
 793     sal_uInt32 doubleLink (sal_uInt16 nIndex) const
 794     {
 795         return PAGE().m_aDataBlock.doubleLink (nIndex);
 796     }
 797     void doubleLink (sal_uInt16 nIndex, sal_uInt32 nAddr)
 798     {
 799         PAGE().m_aDataBlock.doubleLink (nIndex, nAddr);
 800         touch();
 801     }
 802
 803     /** triple indirect.
 804     */
 805     sal_uInt32 tripleLink (sal_uInt16 nIndex) const
 806     {
 807         return PAGE().m_aDataBlock.tripleLink (nIndex);
 808     }
 809     void tripleLink (sal_uInt16 nIndex, sal_uInt32 nAddr)
 810     {
 811         PAGE().m_aDataBlock.tripleLink (nIndex, nAddr);
 812         touch();
 813     }
 814
 815     /** read (external data page).
 816     */
 817     storeError read (
 818         sal_uInt32             nPage,
 819         OStoreDataPageObject  &rData,
 820         OStorePageBIOS        &rBIOS);
 821
 822     /** write (external data page).
 823     */
 824     storeError write (
 825         sal_uInt32             nPage,
 826         OStoreDataPageObject  &rData,
 827         OStorePageBIOS        &rBIOS);
 828
 829     /** truncate (external data page).
 830     */
 831     storeError truncate (
 832         sal_uInt32             nPage,
 833         OStorePageBIOS        &rBIOS);
 834
 835 private:
 836     /** Representation.
 837     */
 838     page & PAGE()
 839     {
 840         page * pImpl = static_cast<page*>(m_xPage.get());
 841         OSL_PRECOND(pImpl != 0, "OStoreDirectoryPageObject::PAGE(): Null pointer");
 842         return (*pImpl);
 843     }
 844     page const & PAGE() const
 845     {
 846         page const * pImpl = static_cast<page const *>(m_xPage.get());
 847         OSL_PRECOND(pImpl != 0, "OStoreDirectoryPageObject::PAGE(): Null pointer");
 848         return (*pImpl);
 849     }
 850
 851     /** scope (external data page; private).
 852     */
 853     page::ChunkScope scope (
 854         sal_uInt32                       nPage,
 855         page::DataBlock::LinkDescriptor &rDescr) const;
 856
 857     /** truncate (external data page scope; private).
 858     */
 859     storeError truncate (
 860         page::ChunkScope       eScope,
 861         sal_uInt16             nRemain,
 862         OStorePageBIOS        &rBIOS);
 863 };
 864
 865 /*========================================================================
 866  *
 867  * The End.
 868  *
 869  *======================================================================*/
 870
 871 } // namespace store
 872
 873 #endif /* !_STORE_STORDATA_HXX_ */
 874