store/source/storbase.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_STORBASE_HXX_
  30 #define _STORE_STORBASE_HXX_
  31
  32 #include "sal/types.h"
  33
  34 #include "rtl/alloc.h"
  35 #include "rtl/crc.h"
  36 #include "rtl/ref.hxx"
  37
  38 #include "osl/diagnose.h"
  39 #include "osl/endian.h"
  40
  41 #include "store/types.h"
  42
  43 #ifndef INCLUDED_STDDEF_H
  44 #include <stddef.h>
  45 #define INCLUDED_STDDEF_H
  46 #endif
  47
  48 #ifndef INCLUDED_STRING_H
  49 #include <string.h>
  50 #define INCLUDED_STRING_H
  51 #endif
  52
  53 /*========================================================================
  54  *
  55  * store common internals.
  56  *
  57  *======================================================================*/
  58
  59 #ifndef STORE_IMPL_ISP2
  60 #define STORE_IMPL_ISP2(value) (((value) & ((value) - 1)) == 0)
  61 #endif
  62
  63 #ifndef STORE_IMPL_CONCAT
  64 #define STORE_IMPL_CONCAT(x, y) STORE_IMPL_CONCAT2(x,y)
  65 #define STORE_IMPL_CONCAT2(x, y) x##y
  66 #endif
  67
  68 #ifndef STORE_STATIC_ASSERT /* Compile time assertion */
  69 namespace store
  70 {
  71     template< bool x > struct STATIC_ASSERTION_FAILURE;
  72     template<> struct STATIC_ASSERTION_FAILURE< true > { enum { value = 1 }; };
  73
  74     template< int x > struct static_assert_test{};
  75 } // namespace store
  76
  77 #define STORE_STATIC_ASSERT(pred) \
  78 typedef \
  79 store::static_assert_test< sizeof( store::STATIC_ASSERTION_FAILURE< (bool)(pred) > ) > \
  80 STORE_IMPL_CONCAT(static_assert_typedef_, __LINE__)
  81
  82 #endif  /* !STORE_STATIC_ASSERT */
  83
  84 namespace store
  85 {
  86
  87 #ifdef htons
  88 #undef htons
  89 #endif
  90 #ifdef ntohs
  91 #undef ntohs
  92 #endif
  93
  94 #ifdef htonl
  95 #undef htonl
  96 #endif
  97 #ifdef ntohl
  98 #undef ntohl
  99 #endif
 100
 101 #ifdef OSL_BIGENDIAN
 102 inline sal_uInt16 htons (sal_uInt16 h) { return OSL_SWAPWORD(h); }
 103 inline sal_uInt16 ntohs (sal_uInt16 n) { return OSL_SWAPWORD(n); }
 104
 105 inline sal_uInt32 htonl (sal_uInt32 h) { return OSL_SWAPDWORD(h); }
 106 inline sal_uInt32 ntohl (sal_uInt32 n) { return OSL_SWAPDWORD(n); }
 107 #else
 108 inline sal_uInt16 htons (sal_uInt16 h) { return (h); }
 109 inline sal_uInt16 ntohs (sal_uInt16 n) { return (n); }
 110
 111 inline sal_uInt32 htonl (sal_uInt32 h) { return (h); }
 112 inline sal_uInt32 ntohl (sal_uInt32 n) { return (n); }
 113 #endif /* OSL_BIGENDIAN */
 114
 115 /** swap.
 116  */
 117 template< typename T > void swap (T & lhs, T & rhs)
 118 {
 119     T tmp = lhs; lhs = rhs; rhs = tmp;
 120 }
 121
 122 /*========================================================================
 123  *
 124  * SharedCount.
 125  *
 126  *======================================================================*/
 127 class SharedCount
 128 {
 129     long * m_pCount;
 130
 131     class Allocator
 132     {
 133         rtl_cache_type * m_cache;
 134
 135     public:
 136         static Allocator & get();
 137
 138         long * alloc()
 139         {
 140             return static_cast<long*>(rtl_cache_alloc (m_cache));
 141         }
 142         void free (long * pCount)
 143         {
 144             rtl_cache_free (m_cache, pCount);
 145         }
 146
 147     protected:
 148         Allocator();
 149         ~Allocator();
 150     };
 151
 152 public:
 153     SharedCount()
 154         : m_pCount(Allocator::get().alloc())
 155     {
 156         if (m_pCount != 0) (*m_pCount) = 1;
 157     }
 158
 159     ~SharedCount()
 160     {
 161         if (m_pCount != 0)
 162         {
 163             long new_count = --(*m_pCount);
 164             if (new_count == 0)
 165                 Allocator::get().free(m_pCount);
 166         }
 167     }
 168
 169     void swap (SharedCount & rhs) // nothrow
 170     {
 171         store::swap(m_pCount, rhs.m_pCount);
 172     }
 173
 174     SharedCount (SharedCount const & rhs) // nothrow
 175         : m_pCount (rhs.m_pCount)
 176     {
 177         if (m_pCount != 0) ++(*m_pCount);
 178     }
 179     SharedCount & operator= (SharedCount const & rhs) // nothrow
 180     {
 181         SharedCount tmp(rhs);
 182         swap(tmp);
 183         return *this;
 184     }
 185
 186     bool operator== (long count) const
 187     {
 188         return (m_pCount != 0) ? *m_pCount == count : false;
 189     }
 190 };
 191
 192 /*========================================================================
 193  *
 194  * OStorePageGuard.
 195  *
 196  *======================================================================*/
 197 struct OStorePageGuard
 198 {
 199     /** Representation.
 200      */
 201     sal_uInt32 m_nMagic;
 202     sal_uInt32 m_nCRC32;
 203
 204     /** Construction.
 205      */
 206     explicit OStorePageGuard (sal_uInt32 nMagic = 0, sal_uInt32 nCRC32 = 0)
 207         : m_nMagic (store::htonl(nMagic)),
 208           m_nCRC32 (store::htonl(nCRC32))
 209     {}
 210
 211     void swap (OStorePageGuard & rhs)
 212     {
 213         store::swap(m_nMagic, rhs.m_nMagic);
 214         store::swap(m_nCRC32, rhs.m_nCRC32);
 215     }
 216
 217     OStorePageGuard (OStorePageGuard const & rhs)
 218         : m_nMagic (rhs.m_nMagic),
 219           m_nCRC32 (rhs.m_nCRC32)
 220     {}
 221
 222     OStorePageGuard& operator= (const OStorePageGuard& rhs)
 223     {
 224         m_nMagic = rhs.m_nMagic;
 225         m_nCRC32 = rhs.m_nCRC32;
 226         return *this;
 227     }
 228
 229     /** Comparison.
 230      */
 231     bool operator== (const OStorePageGuard& rhs) const
 232     {
 233         return ((m_nMagic == rhs.m_nMagic) &&
 234                 (m_nCRC32 == rhs.m_nCRC32)    );
 235     }
 236 };
 237
 238 /*========================================================================
 239  *
 240  * OStorePageDescriptor.
 241  *
 242  *======================================================================*/
 243 #define STORE_PAGE_NULL ((sal_uInt32)(~0))
 244
 245 struct OStorePageDescriptor
 246 {
 247     /** Representation.
 248      */
 249     sal_uInt32 m_nAddr;
 250     sal_uInt16 m_nSize;
 251     sal_uInt16 m_nUsed;
 252
 253     /** Construction.
 254      */
 255     explicit OStorePageDescriptor (
 256         sal_uInt32 nAddr = STORE_PAGE_NULL,
 257         sal_uInt16 nSize = 0,
 258         sal_uInt16 nUsed = 0)
 259         : m_nAddr (store::htonl(nAddr)),
 260           m_nSize (store::htons(nSize)),
 261           m_nUsed (store::htons(nUsed))
 262     {}
 263
 264     void swap (OStorePageDescriptor & rhs)
 265     {
 266         store::swap(m_nAddr, rhs.m_nAddr);
 267         store::swap(m_nSize, rhs.m_nSize);
 268         store::swap(m_nUsed, rhs.m_nUsed);
 269     }
 270
 271     OStorePageDescriptor (const OStorePageDescriptor & rhs)
 272         : m_nAddr (rhs.m_nAddr),
 273           m_nSize (rhs.m_nSize),
 274           m_nUsed (rhs.m_nUsed)
 275     {}
 276
 277     OStorePageDescriptor & operator= (const OStorePageDescriptor & rhs)
 278     {
 279         m_nAddr = rhs.m_nAddr;
 280         m_nSize = rhs.m_nSize;
 281         m_nUsed = rhs.m_nUsed;
 282         return *this;
 283     }
 284
 285     /** Comparison.
 286      */
 287     bool operator== (const OStorePageDescriptor & rhs) const
 288     {
 289         return ((m_nAddr == rhs.m_nAddr) &&
 290                 (m_nSize == rhs.m_nSize)    );
 291     }
 292
 293     bool operator<= (const OStorePageDescriptor & rhs) const
 294     {
 295         return ((m_nAddr               == rhs.m_nAddr              ) &&
 296                 (store::ntohs(m_nSize) <= store::ntohs(rhs.m_nSize))    );
 297     }
 298
 299     bool operator< (const OStorePageDescriptor & rhs) const
 300     {
 301         if (m_nAddr == rhs.m_nAddr)
 302             return (store::ntohs(m_nSize) < store::ntohs(rhs.m_nSize));
 303         else
 304             return (store::ntohl(m_nAddr) < store::ntohl(rhs.m_nAddr));
 305     }
 306 };
 307
 308 /*========================================================================
 309  *
 310  * OStorePageKey.
 311  *
 312  *======================================================================*/
 313 struct OStorePageKey
 314 {
 315     /** Representation.
 316      */
 317     sal_uInt32 m_nLow;
 318     sal_uInt32 m_nHigh;
 319
 320     /** Construction.
 321      */
 322     explicit OStorePageKey (sal_uInt32 nLow = 0, sal_uInt32 nHigh = 0)
 323         : m_nLow  (store::htonl(nLow)),
 324           m_nHigh (store::htonl(nHigh))
 325     {}
 326
 327     void swap (OStorePageKey & rhs)
 328     {
 329         store::swap(m_nLow,  rhs.m_nLow);
 330         store::swap(m_nHigh, rhs.m_nHigh);
 331     }
 332
 333     OStorePageKey (const OStorePageKey & rhs)
 334         : m_nLow (rhs.m_nLow), m_nHigh (rhs.m_nHigh)
 335     {}
 336
 337     OStorePageKey & operator= (const OStorePageKey & rhs)
 338     {
 339         m_nLow  = rhs.m_nLow;
 340         m_nHigh = rhs.m_nHigh;
 341         return *this;
 342     }
 343
 344     /** Comparison.
 345      */
 346     bool operator== (const OStorePageKey & rhs) const
 347     {
 348         return ((m_nLow  == rhs.m_nLow ) &&
 349                 (m_nHigh == rhs.m_nHigh)    );
 350     }
 351
 352     bool operator< (const OStorePageKey & rhs) const
 353     {
 354         if (m_nHigh == rhs.m_nHigh)
 355             return (store::ntohl(m_nLow) < store::ntohl(rhs.m_nLow));
 356         else
 357             return (store::ntohl(m_nHigh) < store::ntohl(rhs.m_nHigh));
 358     }
 359 };
 360
 361 /*========================================================================
 362  *
 363  * OStorePageLink.
 364  *
 365  *======================================================================*/
 366 struct OStorePageLink
 367 {
 368     /** Representation.
 369      */
 370     sal_uInt32 m_nAddr;
 371
 372     /** Construction.
 373      */
 374     explicit OStorePageLink (sal_uInt32 nAddr = STORE_PAGE_NULL)
 375         : m_nAddr (store::htonl(nAddr))
 376     {}
 377
 378     void swap (OStorePageLink & rhs)
 379     {
 380         store::swap(m_nAddr, rhs.m_nAddr);
 381     }
 382
 383     OStorePageLink (const OStorePageLink & rhs)
 384         : m_nAddr (rhs.m_nAddr)
 385     {}
 386
 387     OStorePageLink & operator= (const OStorePageLink & rhs)
 388     {
 389         m_nAddr = rhs.m_nAddr;
 390         return *this;
 391     }
 392
 393     OStorePageLink & operator= (sal_uInt32 nAddr)
 394     {
 395         m_nAddr = store::htonl(nAddr);
 396         return *this;
 397     }
 398
 399     /** Comparison.
 400      */
 401     bool operator== (const OStorePageLink & rhs) const
 402     {
 403         return (m_nAddr == rhs.m_nAddr);
 404     }
 405
 406     bool operator< (const OStorePageLink& rhs) const
 407     {
 408         return (store::ntohl(m_nAddr) < store::ntohl(rhs.m_nAddr));
 409     }
 410
 411     /** Operation.
 412      */
 413     sal_uInt32 location() const
 414     {
 415         return store::ntohl(m_nAddr);
 416     }
 417
 418     void link (OStorePageLink & rPred)
 419     {
 420         // @@@ swap (rPred); @@@
 421         OStorePageLink tmp (rPred);
 422         rPred = *this;
 423         *this = tmp;
 424     }
 425
 426     void unlink (OStorePageLink& rPred)
 427     {
 428         rPred = *this;
 429         *this = OStorePageLink();
 430     }
 431 };
 432
 433 /*========================================================================
 434  *
 435  * PageData.
 436  *
 437  *======================================================================*/
 438 typedef struct PageData OStorePageData; // backward compat.
 439 struct PageData
 440 {
 441     typedef OStorePageGuard      G;
 442     typedef OStorePageDescriptor D;
 443     typedef OStorePageLink       L;
 444
 445     /** Representation.
 446      */
 447     G m_aGuard;
 448     D m_aDescr;
 449     L m_aMarked;
 450     L m_aUnused;
 451
 452     /** theSize.
 453      */
 454     static const size_t     theSize     = sizeof(G) + sizeof(D) + 2 * sizeof(L);
 455     static const sal_uInt16 thePageSize = theSize;
 456     STORE_STATIC_ASSERT(STORE_MINIMUM_PAGESIZE >= thePageSize);
 457
 458     /** location.
 459      */
 460     sal_uInt32 location() const
 461     {
 462         return store::ntohl(m_aDescr.m_nAddr);
 463     }
 464     void location (sal_uInt32 nAddr)
 465     {
 466         m_aDescr.m_nAddr = store::htonl(nAddr);
 467     }
 468
 469     /** size.
 470      */
 471     sal_uInt16 size() const
 472     {
 473         return store::ntohs(m_aDescr.m_nSize);
 474     }
 475
 476     /** type.
 477      */
 478     sal_uInt32 type() const
 479     {
 480         return store::ntohl(m_aGuard.m_nMagic);
 481     }
 482
 483     /** Allocation.
 484      */
 485     class Allocator_Impl;
 486     class Allocator : public rtl::IReference
 487     {
 488     public:
 489         template< class T > T * construct()
 490         {
 491             void * page = 0; sal_uInt16 size = 0;
 492             if (allocate (&page, &size))
 493             {
 494                 return new(page) T(size);
 495             }
 496             return 0;
 497         }
 498
 499         bool allocate (void ** ppPage, sal_uInt16 * pnSize)
 500         {
 501             allocate_Impl (ppPage, pnSize);
 502             return ((*ppPage != 0) && (*pnSize != 0));
 503         }
 504
 505         void deallocate (void * pPage)
 506         {
 507             if (pPage != 0)
 508                 deallocate_Impl (pPage);
 509         }
 510
 511         static storeError createInstance (
 512             rtl::Reference< PageData::Allocator > & rxAllocator, sal_uInt16 nPageSize);
 513
 514     protected:
 515         ~Allocator() {}
 516
 517     private:
 518         /** Implementation (abstract).
 519          */
 520         virtual void allocate_Impl (void ** ppPage, sal_uInt16 * pnSize) = 0;
 521         virtual void deallocate_Impl (void * pPage) = 0;
 522     };
 523
 524     static void* operator new (size_t, void * p) { return p; }
 525     static void  operator delete (void * , void *) {}
 526
 527     /** Construction.
 528      */
 529     explicit PageData (sal_uInt16 nPageSize = thePageSize)
 530         : m_aGuard(),
 531           m_aDescr(STORE_PAGE_NULL, nPageSize, thePageSize),
 532           m_aMarked(),
 533           m_aUnused()
 534     {}
 535
 536     void swap (PageData & rhs) // nothrow
 537     {
 538         m_aGuard.swap(rhs.m_aGuard);
 539         m_aDescr.swap(rhs.m_aDescr);
 540         m_aMarked.swap(rhs.m_aMarked);
 541         m_aUnused.swap(rhs.m_aUnused);
 542     }
 543
 544     PageData (PageData const & rhs) // nothrow
 545         : m_aGuard (rhs.m_aGuard),
 546           m_aDescr (rhs.m_aDescr),
 547           m_aMarked(rhs.m_aMarked),
 548           m_aUnused(rhs.m_aUnused)
 549     {}
 550
 551     PageData & operator= (PageData const & rhs) // nothrow
 552     {
 553         PageData tmp (rhs);
 554         swap (tmp);
 555         return *this;
 556     }
 557
 558     /** guard (external representation).
 559      */
 560     void guard (sal_uInt32 nAddr)
 561     {
 562         sal_uInt32 nCRC32 = 0;
 563         nCRC32 = rtl_crc32 (nCRC32, &m_aGuard.m_nMagic, sizeof(sal_uInt32));
 564         m_aDescr.m_nAddr = store::htonl(nAddr);
 565         nCRC32 = rtl_crc32 (nCRC32, &m_aDescr, theSize - sizeof(G));
 566         m_aGuard.m_nCRC32 = store::htonl(nCRC32);
 567     }
 568
 569     /** verify (external representation).
 570      */
 571     storeError verify (sal_uInt32 nAddr) const
 572     {
 573         sal_uInt32 nCRC32 = 0;
 574         nCRC32 = rtl_crc32 (nCRC32, &m_aGuard.m_nMagic, sizeof(sal_uInt32));
 575         nCRC32 = rtl_crc32 (nCRC32, &m_aDescr, theSize - sizeof(G));
 576         if (m_aGuard.m_nCRC32 != store::htonl(nCRC32))
 577             return store_E_InvalidChecksum;
 578         if (m_aDescr.m_nAddr != store::htonl(nAddr))
 579             return store_E_InvalidAccess;
 580         return store_E_None;
 581     }
 582
 583     storeError verifyVersion (sal_uInt32 nMagic) const
 584     {
 585         if (m_aGuard.m_nMagic != store::htonl(nMagic))
 586             return store_E_WrongVersion;
 587         else
 588             return store_E_None;
 589     }
 590 };
 591
 592 /*========================================================================
 593  *
 594  * PageHolder.
 595  *
 596  *======================================================================*/
 597 class PageHolder
 598 {
 599     SharedCount m_refcount;
 600     PageData  * m_pagedata;
 601
 602     typedef rtl::Reference< PageData::Allocator > allocator_type;
 603     allocator_type m_allocator;
 604
 605 public:
 606     explicit PageHolder (PageData * pagedata = 0, allocator_type const & allocator = allocator_type())
 607         : m_refcount (),
 608           m_pagedata (pagedata),
 609           m_allocator(allocator)
 610     {
 611         OSL_ENSURE((m_pagedata == 0) || m_allocator.is(), "store::PageHolder::ctor(): pagedata w/o allocator.");
 612     }
 613
 614     ~PageHolder()
 615     {
 616         if ((m_refcount == 1) && (m_pagedata != 0))
 617         {
 618             // free pagedata.
 619             OSL_ENSURE(m_allocator.is(), "store::PageHolder::dtor(): pagedata w/o allocator.");
 620             m_allocator->deallocate (m_pagedata);
 621         }
 622     }
 623
 624     void swap (PageHolder & rhs) // nothrow
 625     {
 626         m_refcount.swap(rhs.m_refcount);
 627         store::swap(m_pagedata,  rhs.m_pagedata);
 628         store::swap(m_allocator, rhs.m_allocator);
 629     }
 630
 631     PageHolder (PageHolder const & rhs) // nothrow
 632         : m_refcount (rhs.m_refcount),
 633           m_pagedata (rhs.m_pagedata),
 634           m_allocator(rhs.m_allocator)
 635     {}
 636
 637     PageHolder & operator= (PageHolder const & rhs) // nothrow
 638     {
 639         PageHolder tmp (rhs);
 640         swap(tmp);
 641         return *this;
 642     }
 643
 644     PageData * get() { return m_pagedata; }
 645     PageData const * get() const { return m_pagedata; }
 646
 647     PageData * operator->()
 648     {
 649         OSL_PRECOND(m_pagedata != 0, "store::PageHolder::operator->(): Null pointer");
 650         return m_pagedata;
 651     }
 652     PageData const * operator->() const
 653     {
 654         OSL_PRECOND(m_pagedata != 0, "store::PageHolder::operator->(): Null pointer");
 655         return m_pagedata;
 656     }
 657
 658     PageData & operator*()
 659     {
 660         OSL_PRECOND(m_pagedata != 0, "store::PageHolder::operator*(): Null pointer");
 661         return *m_pagedata;
 662     }
 663     PageData const & operator*() const
 664     {
 665         OSL_PRECOND(m_pagedata != 0, "store::PageHolder::operator*(): Null pointer");
 666         return *m_pagedata;
 667     }
 668 };
 669
 670 /*========================================================================
 671  *
 672  * PageHolderObject.
 673  *
 674  *======================================================================*/
 675 template< class T >
 676 class PageHolderObject
 677 {
 678     /** Representation.
 679      */
 680     PageHolder m_xPage;
 681
 682     /** Checked cast.
 683      */
 684     template< class U >
 685     static bool isA (PageData const * p)
 686     {
 687         return ((p != 0) && (p->type() == U::theTypeId));
 688     }
 689
 690     template< class U >
 691     static U * dynamic_page_cast (PageData * p)
 692     {
 693         return isA<U>(p) ? static_cast<U*>(p) : 0;
 694     }
 695
 696     template< class U >
 697     static U const * dynamic_page_cast (PageData const * p)
 698     {
 699         return isA<U>(p) ? static_cast<U const *>(p) : 0;
 700     }
 701
 702 public:
 703     bool construct (rtl::Reference< PageData::Allocator > const & rxAllocator)
 704     {
 705         if ((m_xPage.get() == 0) && rxAllocator.is())
 706         {
 707             PageHolder tmp (rxAllocator->construct<T>(), rxAllocator);
 708             m_xPage.swap (tmp);
 709         }
 710         return (m_xPage.get() != 0);
 711     }
 712
 713     static PageHolderObject<T> createInstance (rtl::Reference< PageData::Allocator > const & rxAllocator)
 714     {
 715         PageHolderObject<T> tmp;
 716         (void) tmp.construct (rxAllocator);
 717         return tmp;
 718     }
 719
 720     explicit PageHolderObject (PageHolder const & rxPage = PageHolder())
 721         : m_xPage (rxPage)
 722     {}
 723
 724     void swap (PageHolderObject<T> & rhs)
 725     {
 726         m_xPage.swap (rhs.m_xPage);
 727     }
 728
 729     PageHolderObject (PageHolderObject<T> const & rhs)
 730         : m_xPage (rhs.m_xPage)
 731     {}
 732
 733     PageHolderObject<T> & operator= (PageHolderObject<T> const & rhs)
 734     {
 735         PageHolderObject<T> tmp (rhs);
 736         this->swap (tmp);
 737         return *this;
 738     }
 739
 740     bool is() const
 741     {
 742         return (m_xPage.get() != 0);
 743     }
 744
 745 #if 1  /* EXP */
 746     PageHolder & get() { return m_xPage; }
 747     PageHolder const & get() const { return m_xPage; }
 748 #endif /* EXP */
 749
 750     T * operator->()
 751     {
 752         T * pImpl = dynamic_page_cast<T>(m_xPage.get());
 753         OSL_PRECOND(pImpl != 0, "store::PageHolder<T>::operator*(): Null pointer");
 754         return pImpl;
 755     }
 756     T const * operator->() const
 757     {
 758         T const * pImpl = dynamic_page_cast<T>(m_xPage.get());
 759         OSL_PRECOND(pImpl != 0, "store::PageHolder<T>::operator*(): Null pointer");
 760         return pImpl;
 761     }
 762
 763     T & operator*()
 764     {
 765         T * pImpl = dynamic_page_cast<T>(m_xPage.get());
 766         OSL_PRECOND(pImpl != 0, "store::PageHolder<T>::operator*(): Null pointer");
 767         return (*pImpl);
 768     }
 769     T const & operator*() const
 770     {
 771         T const * pImpl = dynamic_page_cast<T>(m_xPage.get());
 772         OSL_PRECOND(pImpl != 0, "store::PageHolder<T>::operator*(): Null pointer");
 773         return (*pImpl);
 774     }
 775
 776     static storeError guard (PageHolder & rxPage, sal_uInt32 nAddr)
 777     {
 778         PageData * pHead = rxPage.get();
 779         if (!pHead)
 780             return store_E_InvalidAccess;
 781         pHead->guard(nAddr);
 782
 783         T * pImpl = dynamic_page_cast<T>(pHead);
 784         OSL_PRECOND(pImpl != 0, "store::PageHolder<T>::guard(): Null pointer");
 785         pImpl->guard();
 786
 787         return store_E_None;
 788     }
 789     static storeError verify (PageHolder const & rxPage, sal_uInt32 nAddr)
 790     {
 791         PageData const * pHead = rxPage.get();
 792         if (!pHead)
 793             return store_E_InvalidAccess;
 794
 795         storeError eErrCode = pHead->verify(nAddr);
 796         if (eErrCode != store_E_None)
 797             return eErrCode;
 798
 799         T const * pImpl = dynamic_page_cast<T>(pHead);
 800         if (!pImpl)
 801             return store_E_WrongVersion;
 802
 803         return pImpl->verify();
 804     }
 805 };
 806
 807 /*========================================================================
 808  *
 809  * PageObject.
 810  *
 811  *======================================================================*/
 812 #if 1  /* EXP */
 813 class PageObject
 814 {
 815 public:
 816     explicit PageObject (PageHolder const & rxPage = PageHolder())
 817         : m_xPage (rxPage), m_bDirty (false)
 818     {}
 819
 820     virtual ~PageObject()
 821     {}
 822
 823     PageHolder & get() { return m_xPage; }
 824     PageHolder const & get() const { return m_xPage; }
 825
 826     void clean() { m_bDirty = false; }
 827     void touch() { m_bDirty = true; }
 828
 829     sal_uInt32 location() const
 830     {
 831         PageData const * pagedata = m_xPage.get();
 832         return (pagedata != 0) ? pagedata->location() : STORE_PAGE_NULL;
 833     }
 834     void location (sal_uInt32 nAddr)
 835     {
 836         PageData * pagedata = m_xPage.get();
 837         if (pagedata != 0)
 838             pagedata->location (nAddr);
 839     }
 840
 841 protected:
 842     PageHolder m_xPage;
 843     bool       m_bDirty;
 844
 845     virtual storeError guard  (sal_uInt32 nAddr) = 0;
 846     virtual storeError verify (sal_uInt32 nAddr) const = 0;
 847 };
 848 #endif /* EXP */
 849
 850 class OStorePageBIOS;
 851
 852 class OStorePageObject
 853 {
 854     typedef OStorePageData       page;
 855
 856 public:
 857     /** Allocation.
 858      */
 859     static void * operator new (size_t n) SAL_THROW(())
 860     {
 861         return rtl_allocateMemory (sal_uInt32(n));
 862     }
 863     static void operator delete (void * p) SAL_THROW(())
 864     {
 865         rtl_freeMemory (p);
 866     }
 867
 868     /** State.
 869      */
 870     inline bool dirty (void) const;
 871     inline void clean (void);
 872     inline void touch (void);
 873
 874     /** Location.
 875      */
 876     inline sal_uInt32 location (void) const;
 877     inline void       location (sal_uInt32 nAddr);
 878
 879 protected:
 880     /** Representation.
 881      */
 882     PageHolder m_xPage;
 883     bool       m_bDirty;
 884
 885     /** Construction.
 886      */
 887     explicit OStorePageObject (PageHolder const & rxPage = PageHolder())
 888         : m_xPage (rxPage), m_bDirty (false)
 889     {}
 890
 891     /** Destruction.
 892      */
 893     virtual ~OStorePageObject (void);
 894
 895 public:
 896     template< class U >
 897     PageHolderObject<U> makeHolder() const
 898     {
 899         return PageHolderObject<U>(m_xPage);
 900     }
 901
 902     template< class U >
 903     storeError construct (rtl::Reference< PageData::Allocator > const & rxAllocator)
 904     {
 905         if (!rxAllocator.is())
 906             return store_E_InvalidAccess;
 907
 908         PageHolder tmp (rxAllocator->construct<U>(), rxAllocator);
 909         if (!tmp.get())
 910             return store_E_OutOfMemory;
 911
 912         m_xPage.swap (tmp);
 913         return store_E_None;
 914     }
 915
 916
 917     PageHolder & get() { return m_xPage; }
 918     PageHolder const & get() const { return m_xPage; }
 919
 920     virtual storeError guard  (sal_uInt32 nAddr) = 0;
 921     virtual storeError verify (sal_uInt32 nAddr) const = 0;
 922 };
 923
 924 inline bool OStorePageObject::dirty (void) const
 925 {
 926     return m_bDirty;
 927 }
 928
 929 inline void OStorePageObject::clean (void)
 930 {
 931     m_bDirty = false;
 932 }
 933
 934 inline void OStorePageObject::touch (void)
 935 {
 936     m_bDirty = true;
 937 }
 938
 939 inline sal_uInt32 OStorePageObject::location (void) const
 940 {
 941     return m_xPage->location();
 942 }
 943
 944 inline void OStorePageObject::location (sal_uInt32 nAddr)
 945 {
 946     m_xPage->location(nAddr);
 947     touch();
 948 }
 949
 950 /*========================================================================
 951  *
 952  * The End.
 953  *
 954  *======================================================================*/
 955
 956 } // namespace store
 957
 958 #endif /* !_STORE_STORBASE_HXX_ */
 959
 960 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */