store/source/stordata.hxx

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