sw/source/core/inc/swcache.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 #ifndef INCLUDED_SW_SOURCE_CORE_INC_SWCACHE_HXX
  20 #define INCLUDED_SW_SOURCE_CORE_INC_SWCACHE_HXX
  21
  22 /**
  23  * Here, we manage pointers in a simple PtrArray to objects.
  24  * These objects are created (using new) in cache access classes; they are
  25  * destroyed by the cache.
  26  *
  27  * One can access these objects by array index or by searching in the array.
  28  * If you access it by index, managing the index is the responsibility of
  29  * the cache user.
  30  *
  31  * The cached objects are derived from the base class SwCacheObj.
  32  * In it, the cache objects are doubly-linked which allows for the use of
  33  * an LRU algorithm.
  34  *
  35  * The LRU algorithm can be changed in the base class, by setting a virtual
  36  * First Pointer. It can be set to the first real one plus an offset.
  37  * By doing so we can protect the start area of the cache and make sure we
  38  * don't mess up the cache during some special operations.
  39  * E.g.: the Idle Handler should not destroy the cache for the visible area.
  40  *
  41  * The cache can be grown and shrunk in size.
  42  * E.g.: The cache for FormatInfo is grown for every new Shell and shrunk
  43  * when destroying them.
  44  */
  45
  46 #include <memory>
  47 #include <vector>
  48
  49 #include <rtl/string.hxx>
  50 #include <tools/long.hxx>
  51
  52 class SwCacheObj;
  53
  54 class SwCache
  55 {
  56     std::vector<std::unique_ptr<SwCacheObj>> m_aCacheObjects;
  57     std::vector<sal_uInt16> m_aFreePositions; /// Free positions for the Insert if the maximum has not been reached
  58                                               /// Every time an object is deregistered, its position is added here
  59     SwCacheObj *m_pRealFirst;                 /// _ALWAYS_ the real first LRU
  60     SwCacheObj *m_pFirst;                     /// The virtual first, only different to m_pRealFirst when SetLRUOfst has been called
  61     SwCacheObj *m_pLast;
  62
  63     sal_uInt16 m_nCurMax;                     // Maximum of accepted objects
  64
  65     void DeleteObj( SwCacheObj *pObj );
  66
  67 #ifdef DBG_UTIL
  68     OString m_aName;
  69     tools::Long m_nAppend;           /// number of entries appended
  70     tools::Long m_nInsertFree;       /// number of entries inserted on freed position
  71     tools::Long m_nReplace;          /// number of LRU replacements
  72     tools::Long m_nGetSuccess;
  73     tools::Long m_nGetFail;
  74     tools::Long m_nToTop;            /// number of reordering (LRU)
  75     tools::Long m_nDelete;           /// number of explicit deletes
  76     tools::Long m_nGetSeek;          /// number of gets without index
  77     tools::Long m_nAverageSeekCnt;   /// number of seeks for all gets without index
  78     tools::Long m_nFlushCnt;         /// number of flush calls
  79     tools::Long m_nFlushedObjects;
  80     tools::Long m_nIncreaseMax;      /// number of cache size increases
  81     tools::Long m_nDecreaseMax;      /// number of cache size decreases
  82
  83     void Check();
  84 #endif
  85
  86 public:
  87
  88 // Only add sal_uInt8!!!
  89 #ifdef DBG_UTIL
  90     SwCache( const sal_uInt16 nInitSize, OString aNm );
  91 #else
  92     SwCache( const sal_uInt16 nInitSize );
  93 #endif
  94     /// The dtor will free all objects still in the vector
  95     ~SwCache();
  96
  97     void Flush();
  98
  99     //bToTop == false -> No LRU resorting!
 100     SwCacheObj *Get( const void *pOwner, const bool bToTop = true );
 101     SwCacheObj *Get( const void *pOwner, const sal_uInt16 nIndex,
 102                      const bool bToTop = true );
 103     void ToTop( SwCacheObj *pObj );
 104
 105     bool Insert(SwCacheObj *pNew, bool isDuplicateOwnerAllowed);
 106     void Delete(const void * pOwner, sal_uInt16 nIndex);
 107     void Delete( const void *pOwner );
 108
 109     /// Mark some entries as "do not delete"
 110     /// @param nOfst determines how many are not to be touched
 111     void SetLRUOfst( const sal_uInt16 nOfst );
 112     void ResetLRUOfst() { m_pFirst = m_pRealFirst; }
 113
 114     void IncreaseMax( const sal_uInt16 nAdd );
 115     void DecreaseMax( const sal_uInt16 nSub );
 116     sal_uInt16 GetCurMax() const { return m_nCurMax; }
 117     SwCacheObj *First() { return m_pRealFirst; }
 118     static inline SwCacheObj *Next( SwCacheObj *pCacheObj);
 119     SwCacheObj* operator[](sal_uInt16 nIndex) { return m_aCacheObjects[nIndex].get(); }
 120     sal_uInt16 size() { return m_aCacheObjects.size(); }
 121 };
 122
 123 /// Try to prevent visible SwParaPortions from being deleted.
 124 class SwSaveSetLRUOfst
 125 {
 126 public:
 127     SwSaveSetLRUOfst();
 128     ~SwSaveSetLRUOfst();
 129 };
 130
 131 /**
 132  * The Cache object base class
 133  * Users of the Cache must derive a class from the SwCacheObj and store
 134  * their payload there
 135  */
 136 class SwCacheObj
 137 {
 138     friend class SwCache;   /// Can do everything
 139
 140     SwCacheObj *m_pNext;      /// For the LRU chaining
 141     SwCacheObj *m_pPrev;
 142
 143     sal_uInt16 m_nCachePos;   /// Position in the Cache array
 144
 145     sal_uInt8       m_nLock;
 146
 147     SwCacheObj *GetNext() { return m_pNext; }
 148     SwCacheObj *GetPrev() { return m_pPrev; }
 149     void SetNext( SwCacheObj *pNew )  { m_pNext = pNew; }
 150     void SetPrev( SwCacheObj *pNew )  { m_pPrev = pNew; }
 151
 152     void SetCachePos(const sal_uInt16 nNew)
 153     {
 154         if (m_nCachePos != nNew)
 155         {
 156             m_nCachePos = nNew;
 157             UpdateCachePos();
 158         }
 159     }
 160     virtual void UpdateCachePos() { }
 161
 162 protected:
 163     const void *m_pOwner;
 164
 165 public:
 166
 167     SwCacheObj( const void *pOwner );
 168     virtual ~SwCacheObj();
 169
 170     const void *GetOwner() const { return m_pOwner; }
 171     inline bool IsOwner( const void *pNew ) const;
 172
 173     sal_uInt16 GetCachePos() const { return m_nCachePos; }
 174
 175     bool IsLocked() const { return 0 != m_nLock; }
 176
 177 #ifdef DBG_UTIL
 178     void Lock();
 179     void Unlock();
 180 #else
 181     void Lock() { ++m_nLock; }
 182     void Unlock() { --m_nLock; }
 183 #endif
 184 };
 185
 186 /**
 187  * Access class for the Cache
 188  *
 189  * The Cache object is created in the ctor.
 190  * If the Cache does not return one, the member is set to 0 and one is
 191  * created on the Get() and added to the Cache (if possible).
 192  * Cache users must derive a class from SwCacheAccess in order to
 193  * guarantee type safety. The base class should always be called for the
 194  * Get(). A derived Get() should only ever guarantee type safety.
 195  * Cache objects are always locked for the instance's life time.
 196  */
 197 class SwCacheAccess
 198 {
 199     SwCache &m_rCache;
 200
 201     void Get_(bool isDuplicateOwnerAllowed);
 202
 203 protected:
 204     SwCacheObj *m_pObj;
 205     const void *m_pOwner; /// Can be use in NewObj
 206
 207     virtual SwCacheObj *NewObj() = 0;
 208
 209     inline SwCacheObj *Get(bool isDuplicateOwnerAllowed);
 210
 211     inline SwCacheAccess( SwCache &rCache, const void *pOwner, bool bSeek );
 212     inline SwCacheAccess( SwCache &rCache, const void* nCacheId, const sal_uInt16 nIndex );
 213
 214 public:
 215     virtual ~SwCacheAccess();
 216 };
 217
 218
 219 inline bool SwCacheObj::IsOwner( const void *pNew ) const
 220 {
 221     return m_pOwner && m_pOwner == pNew;
 222 }
 223
 224 inline SwCacheObj *SwCache::Next( SwCacheObj *pCacheObj)
 225 {
 226     if ( pCacheObj )
 227         return pCacheObj->GetNext();
 228     else
 229         return nullptr;
 230 }
 231
 232 inline SwCacheAccess::SwCacheAccess( SwCache &rC, const void *pOwn, bool bSeek ) :
 233     m_rCache( rC ),
 234     m_pObj( nullptr ),
 235     m_pOwner( pOwn )
 236 {
 237     if ( bSeek && m_pOwner )
 238     {
 239         m_pObj = m_rCache.Get( m_pOwner );
 240         if (m_pObj)
 241             m_pObj->Lock();
 242     }
 243 }
 244
 245 inline SwCacheAccess::SwCacheAccess( SwCache &rC, const void* nCacheId,
 246                               const sal_uInt16 nIndex ) :
 247     m_rCache( rC ),
 248     m_pObj( nullptr ),
 249     m_pOwner( nCacheId )
 250 {
 251     if ( m_pOwner )
 252     {
 253         m_pObj = m_rCache.Get( m_pOwner, nIndex );
 254         if (m_pObj)
 255             m_pObj->Lock();
 256     }
 257 }
 258
 259 inline SwCacheObj *SwCacheAccess::Get(bool const isDuplicateOwnerAllowed = true)
 260 {
 261     if ( !m_pObj )
 262         Get_(isDuplicateOwnerAllowed);
 263     return m_pObj;
 264 }
 265
 266 #endif
 267
 268 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */