swcache.hxx

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */
#ifndef INCLUDED_SW_SOURCE_CORE_INC_SWCACHE_HXX
#define INCLUDED_SW_SOURCE_CORE_INC_SWCACHE_HXX
 
#include <memory>
#include <vector>
 
#include <rtl/string.hxx>
#include <tools/long.hxx>
 
class SwCacheObj;
 
class SwCache
{
    std::vector<std::unique_ptr<SwCacheObj>> m_aCacheObjects;
    std::vector<sal_uInt16> m_aFreePositions; 
    SwCacheObj *m_pRealFirst;                 
    SwCacheObj *m_pFirst;                     
    SwCacheObj *m_pLast;
 
    sal_uInt16 m_nCurMax;                     // Maximum of accepted objects
 
    void DeleteObj( SwCacheObj *pObj );
 
#ifdef DBG_UTIL
    OString m_aName;
    tools::Long m_nAppend;           
    tools::Long m_nInsertFree;       
    tools::Long m_nReplace;          
    tools::Long m_nGetSuccess;
    tools::Long m_nGetFail;
    tools::Long m_nToTop;            
    tools::Long m_nDelete;           
    tools::Long m_nGetSeek;          
    tools::Long m_nAverageSeekCnt;   
    tools::Long m_nFlushCnt;         
    tools::Long m_nFlushedObjects;
    tools::Long m_nIncreaseMax;      
    tools::Long m_nDecreaseMax;      
 
    void Check();
#endif
 
public:
 
// Only add sal_uInt8!!!
#ifdef DBG_UTIL
    SwCache( const sal_uInt16 nInitSize, OString aNm );
#else
    SwCache( const sal_uInt16 nInitSize );
#endif
    ~SwCache();
 
    void Flush();
 
    //bToTop == false -> No LRU resorting!
    SwCacheObj *Get( const void *pOwner, const bool bToTop = true );
    SwCacheObj *Get( const void *pOwner, const sal_uInt16 nIndex,
                     const bool bToTop = true );
    void ToTop( SwCacheObj *pObj );
 
    bool Insert(SwCacheObj *pNew, bool isDuplicateOwnerAllowed);
    void Delete(const void * pOwner, sal_uInt16 nIndex);
    void Delete( const void *pOwner );
 
    void SetLRUOfst( const sal_uInt16 nOfst );
    void ResetLRUOfst() { m_pFirst = m_pRealFirst; }
 
    void IncreaseMax( const sal_uInt16 nAdd );
    void DecreaseMax( const sal_uInt16 nSub );
    sal_uInt16 GetCurMax() const { return m_nCurMax; }
    SwCacheObj *First() { return m_pRealFirst; }
    static inline SwCacheObj *Next( SwCacheObj *pCacheObj);
    SwCacheObj* operator[](sal_uInt16 nIndex) { return m_aCacheObjects[nIndex].get(); }
    sal_uInt16 size() { return m_aCacheObjects.size(); }
};
 
class SwSaveSetLRUOfst
{
public:
    SwSaveSetLRUOfst();
    ~SwSaveSetLRUOfst();
};
 
class SwCacheObj
{
    friend class SwCache;   
 
    SwCacheObj *m_pNext;      
    SwCacheObj *m_pPrev;
 
    sal_uInt16 m_nCachePos;   
 
    sal_uInt8       m_nLock;
 
    SwCacheObj *GetNext() { return m_pNext; }
    SwCacheObj *GetPrev() { return m_pPrev; }
    void SetNext( SwCacheObj *pNew )  { m_pNext = pNew; }
    void SetPrev( SwCacheObj *pNew )  { m_pPrev = pNew; }
 
    void SetCachePos(const sal_uInt16 nNew)
    {
        if (m_nCachePos != nNew)
        {
            m_nCachePos = nNew;
            UpdateCachePos();
        }
    }
    virtual void UpdateCachePos() { }
 
protected:
    const void *m_pOwner;
 
public:
 
    SwCacheObj( const void *pOwner );
    virtual ~SwCacheObj();
 
    const void *GetOwner() const { return m_pOwner; }
    inline bool IsOwner( const void *pNew ) const;
 
    sal_uInt16 GetCachePos() const { return m_nCachePos; }
 
    bool IsLocked() const { return 0 != m_nLock; }
 
#ifdef DBG_UTIL
    void Lock();
    void Unlock();
#else
    void Lock() { ++m_nLock; }
    void Unlock() { --m_nLock; }
#endif
};
 
class SwCacheAccess
{
    SwCache &m_rCache;
 
    void Get_(bool isDuplicateOwnerAllowed);
 
protected:
    SwCacheObj *m_pObj;
    const void *m_pOwner; 
 
    virtual SwCacheObj *NewObj() = 0;
 
    inline SwCacheObj *Get(bool isDuplicateOwnerAllowed);
 
    inline SwCacheAccess( SwCache &rCache, const void *pOwner, bool bSeek );
    inline SwCacheAccess( SwCache &rCache, const void* nCacheId, const sal_uInt16 nIndex );
 
public:
    virtual ~SwCacheAccess();
};
 
 
inline bool SwCacheObj::IsOwner( const void *pNew ) const
{
    return m_pOwner && m_pOwner == pNew;
}
 
inline SwCacheObj *SwCache::Next( SwCacheObj *pCacheObj)
{
    if ( pCacheObj )
        return pCacheObj->GetNext();
    else
        return nullptr;
}
 
inline SwCacheAccess::SwCacheAccess( SwCache &rC, const void *pOwn, bool bSeek ) :
    m_rCache( rC ),
    m_pObj( nullptr ),
    m_pOwner( pOwn )
{
    if ( bSeek && m_pOwner )
    {
        m_pObj = m_rCache.Get( m_pOwner );
        if (m_pObj)
            m_pObj->Lock();
    }
}
 
inline SwCacheAccess::SwCacheAccess( SwCache &rC, const void* nCacheId,
                              const sal_uInt16 nIndex ) :
    m_rCache( rC ),
    m_pObj( nullptr ),
    m_pOwner( nCacheId )
{
    if ( m_pOwner )
    {
        m_pObj = m_rCache.Get( m_pOwner, nIndex );
        if (m_pObj)
            m_pObj->Lock();
    }
}
 
inline SwCacheObj *SwCacheAccess::Get(bool const isDuplicateOwnerAllowed = true)
{
    if ( !m_pObj )
        Get_(isDuplicateOwnerAllowed);
    return m_pObj;
}
 
#endif
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */