LCOV - code coverage report
Current view: top level - libreoffice/store/source - stordata.hxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 208 217 95.9 %
Date: 2012-12-27 Functions: 61 65 93.8 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10