store/source/stordata.hxx

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