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