store/source/storbios.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_STORBIOS_HXX
  21 #define INCLUDED_STORE_SOURCE_STORBIOS_HXX
  22
  23 #include <sal/types.h>
  24 #include <rtl/ref.hxx>
  25 #include <osl/mutex.hxx>
  26
  27 #include <store/types.h>
  28 #include "object.hxx"
  29 #include "storbase.hxx"
  30
  31 namespace store
  32 {
  33
  34 class ILockBytes;
  35 class PageCache;
  36 struct SuperBlockPage;
  37
  38 class OStorePageBIOS : public store::OStoreObject
  39 {
  40 public:
  41     /** Construction.
  42      */
  43     OStorePageBIOS();
  44
  45     /** Conversion into Mutex&
  46      */
  47     inline operator osl::Mutex& (void) const;
  48
  49     /** Initialization.
  50      *  @param  pLockBytes [in]
  51      *  @param  eAccessMode [in]
  52      *  @param  rnPageSize [inout]
  53      *  @return store_E_None upon success
  54      */
  55     virtual storeError initialize (
  56         ILockBytes *    pLockBytes,
  57         storeAccessMode eAccessMode,
  58         sal_uInt16 &    rnPageSize);
  59
  60     rtl::Reference< PageData::Allocator > & allocator()
  61     {
  62         return m_xAllocator;
  63     }
  64
  65     /** read.
  66      */
  67     storeError read (
  68         sal_uInt32 nAddr, void *pData, sal_uInt32 nSize) const;
  69
  70     /** write.
  71      */
  72     storeError write (
  73         sal_uInt32 nAddr, const void *pData, sal_uInt32 nSize) const;
  74
  75     /** isWriteable.
  76      */
  77     inline bool isWriteable() const;
  78
  79     /** isValid.
  80      */
  81     inline bool isValid() const;
  82
  83     /** Page Access.
  84      */
  85     storeError acquirePage (
  86         const OStorePageDescriptor& rDescr, storeAccessMode eMode);
  87
  88     storeError releasePage (const OStorePageDescriptor& rDescr);
  89
  90     storeError allocate (OStorePageObject& rPage);
  91
  92     storeError free (sal_uInt32 nAddr);
  93
  94     /** Page I/O.
  95      */
  96     storeError loadObjectAt (
  97         OStorePageObject& rPage, sal_uInt32 nAddr);
  98
  99     storeError saveObjectAt (
 100         OStorePageObject& rPage, sal_uInt32 nAddr);
 101
 102     /** close.
 103      *  @return store_E_None upon success.
 104      */
 105     storeError close();
 106
 107     /** flush.
 108      *  @return store_E_None upon success.
 109      */
 110     storeError flush();
 111
 112 protected:
 113     /** Destruction (OReference).
 114      */
 115     virtual ~OStorePageBIOS() override;
 116
 117 private:
 118     /** Representation.
 119      */
 120     rtl::Reference<ILockBytes>    m_xLockBytes;
 121     osl::Mutex                    m_aMutex;
 122
 123     std::unique_ptr<SuperBlockPage> m_pSuper;
 124
 125     bool                          m_bWriteable;
 126
 127     rtl::Reference< PageData::Allocator > m_xAllocator;
 128     rtl::Reference< PageCache >   m_xCache;
 129
 130     /** Page Access (control).
 131      */
 132 public:
 133     struct Ace
 134     {
 135         Ace *      m_next;
 136         Ace *      m_prev;
 137
 138         sal_uInt32 m_addr;
 139         sal_uInt32 m_used;
 140
 141         Ace();
 142         ~Ace();
 143
 144         static int SAL_CALL constructor (void * obj, void * arg);
 145
 146         static Ace * find   (Ace * head, sal_uInt32 addr);
 147         static void  insert (Ace * head, Ace * entry);
 148     };
 149
 150 private:
 151     Ace m_ace_head;
 152
 153     class AceCache;
 154
 155     /** Initialization.
 156      */
 157     storeError initialize_Impl (
 158         ILockBytes *    pLockBytes,
 159         storeAccessMode eAccessMode,
 160         sal_uInt16 &    rnPageSize);
 161     void cleanup_Impl();
 162
 163     /** Page Maintenance.
 164      */
 165     storeError loadObjectAt_Impl (
 166         OStorePageObject & rPage, sal_uInt32 nAddr) const;
 167     storeError saveObjectAt_Impl (
 168         OStorePageObject & rPage, sal_uInt32 nAddr) const;
 169
 170     OStorePageBIOS (const OStorePageBIOS&) = delete;
 171     OStorePageBIOS& operator= (const OStorePageBIOS&) = delete;
 172 };
 173
 174 inline OStorePageBIOS::operator osl::Mutex& (void) const
 175 {
 176     return const_cast<osl::Mutex&>(m_aMutex);
 177 }
 178 inline bool OStorePageBIOS::isWriteable() const
 179 {
 180     return m_bWriteable;
 181 }
 182 inline bool OStorePageBIOS::isValid() const
 183 {
 184     return m_xLockBytes.is();
 185 }
 186
 187 } // namespace store
 188
 189 #endif // INCLUDED_STORE_SOURCE_STORBIOS_HXX
 190
 191 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */