1*b1cdbd2cSJim Jagielski /**************************************************************
2*b1cdbd2cSJim Jagielski *
3*b1cdbd2cSJim Jagielski * Licensed to the Apache Software Foundation (ASF) under one
4*b1cdbd2cSJim Jagielski * or more contributor license agreements. See the NOTICE file
5*b1cdbd2cSJim Jagielski * distributed with this work for additional information
6*b1cdbd2cSJim Jagielski * regarding copyright ownership. The ASF licenses this file
7*b1cdbd2cSJim Jagielski * to you under the Apache License, Version 2.0 (the
8*b1cdbd2cSJim Jagielski * "License"); you may not use this file except in compliance
9*b1cdbd2cSJim Jagielski * with the License. You may obtain a copy of the License at
10*b1cdbd2cSJim Jagielski *
11*b1cdbd2cSJim Jagielski * http://www.apache.org/licenses/LICENSE-2.0
12*b1cdbd2cSJim Jagielski *
13*b1cdbd2cSJim Jagielski * Unless required by applicable law or agreed to in writing,
14*b1cdbd2cSJim Jagielski * software distributed under the License is distributed on an
15*b1cdbd2cSJim Jagielski * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16*b1cdbd2cSJim Jagielski * KIND, either express or implied. See the License for the
17*b1cdbd2cSJim Jagielski * specific language governing permissions and limitations
18*b1cdbd2cSJim Jagielski * under the License.
19*b1cdbd2cSJim Jagielski *
20*b1cdbd2cSJim Jagielski *************************************************************/
21*b1cdbd2cSJim Jagielski
22*b1cdbd2cSJim Jagielski
23*b1cdbd2cSJim Jagielski #ifndef _SWCACHE_HXX
24*b1cdbd2cSJim Jagielski #define _SWCACHE_HXX
25*b1cdbd2cSJim Jagielski
26*b1cdbd2cSJim Jagielski
27*b1cdbd2cSJim Jagielski
28*b1cdbd2cSJim Jagielski /*
29*b1cdbd2cSJim Jagielski * Es werden Pointer auf Objekte verwaltet. Diese werden in einem einfachen
30*b1cdbd2cSJim Jagielski * PtrArray verwaltet.
31*b1cdbd2cSJim Jagielski * Angelegt (new) werden die Objekte von Cache-Zugriffsklassen, zuerstoert
32*b1cdbd2cSJim Jagielski * werden die Objekte vom Cache.
33*b1cdbd2cSJim Jagielski *
34*b1cdbd2cSJim Jagielski * Auf die Objekte kann wahlweise per Index in das Array oder per Suche
35*b1cdbd2cSJim Jagielski * zugegriffen werden. Soll per Index zugegriffen werden, so obliegt die
36*b1cdbd2cSJim Jagielski * Verwaltung des Index dem Anwender des Cache.
37*b1cdbd2cSJim Jagielski *
38*b1cdbd2cSJim Jagielski * Fuer die verwalteten Cache-Objekte gibt es eine Basisklasse, von dieser
39*b1cdbd2cSJim Jagielski * sind spezifische Klassen abzuleiten.
40*b1cdbd2cSJim Jagielski * In der Basisklasse werden die Cache-Objekte eines Cache doppelt verkettet,
41*b1cdbd2cSJim Jagielski * das ermoeglich die Implementierung eines LRU-Algorithmus.
42*b1cdbd2cSJim Jagielski *
43*b1cdbd2cSJim Jagielski * Der LRU kann in der Cache-Basisklasse manipuliert werden, indem ein
44*b1cdbd2cSJim Jagielski * virtueller First-Pointer gesetzt wird. Dieser kann auf den echten ersten
45*b1cdbd2cSJim Jagielski * plus einem Ofst gesetzt werden. Dadurch kann man den Anfangsbereich des
46*b1cdbd2cSJim Jagielski * Cache sichern und so dafuer sorgen, dass man waehrend bestimmter
47*b1cdbd2cSJim Jagielski * Operationen nicht den Cache versaut. Beispiel: Der Idle-Handler sollte nicht
48*b1cdbd2cSJim Jagielski * den Cache fuer den sichtbaren Bereich vernichten.
49*b1cdbd2cSJim Jagielski *
50*b1cdbd2cSJim Jagielski * Der Cache kann in der Groesse erweitert und wieder verkleinert werden.
51*b1cdbd2cSJim Jagielski * Beispiel: Fuer jede neue Shell wird der Cache fuer FormatInfo vergrossert
52*b1cdbd2cSJim Jagielski * und beim Destruieren der Shell wieder verkleinert.
53*b1cdbd2cSJim Jagielski *
54*b1cdbd2cSJim Jagielski */
55*b1cdbd2cSJim Jagielski
56*b1cdbd2cSJim Jagielski #ifdef DBG_UTIL
57*b1cdbd2cSJim Jagielski #ifndef _STRING_HXX //autogen
58*b1cdbd2cSJim Jagielski #include <tools/string.hxx>
59*b1cdbd2cSJim Jagielski #endif
60*b1cdbd2cSJim Jagielski #endif
61*b1cdbd2cSJim Jagielski
62*b1cdbd2cSJim Jagielski #ifndef _SVSTDARR_HXX
63*b1cdbd2cSJim Jagielski #define _SVSTDARR_USHORTS
64*b1cdbd2cSJim Jagielski #include <svl/svstdarr.hxx>
65*b1cdbd2cSJim Jagielski #endif
66*b1cdbd2cSJim Jagielski
67*b1cdbd2cSJim Jagielski class SwCacheObj;
68*b1cdbd2cSJim Jagielski
69*b1cdbd2cSJim Jagielski SV_DECL_PTRARR_DEL(SwCacheObjArr,SwCacheObj*,1,1)
70*b1cdbd2cSJim Jagielski
71*b1cdbd2cSJim Jagielski class SwCache : public SwCacheObjArr
72*b1cdbd2cSJim Jagielski {
73*b1cdbd2cSJim Jagielski SvUShorts aFreePositions; //Freie Positionen fuer das Insert wenn
74*b1cdbd2cSJim Jagielski //die Maximalgrenze nicht erreicht ist.
75*b1cdbd2cSJim Jagielski //Immer wenn ein Objekt ausgetragen wird,
76*b1cdbd2cSJim Jagielski //so wird seine Position hier eingetragen.
77*b1cdbd2cSJim Jagielski
78*b1cdbd2cSJim Jagielski SwCacheObj *pRealFirst; //_immer_ der echte LRU-erste
79*b1cdbd2cSJim Jagielski SwCacheObj *pFirst; //der virtuelle erste.
80*b1cdbd2cSJim Jagielski SwCacheObj *pLast;
81*b1cdbd2cSJim Jagielski
82*b1cdbd2cSJim Jagielski const sal_uInt16 nMax; //Mehr sollen nicht aufgenommen werden,
83*b1cdbd2cSJim Jagielski //der Cache kann aber dynamisch um jeweils
84*b1cdbd2cSJim Jagielski //nMax vergroessert werden.
85*b1cdbd2cSJim Jagielski sal_uInt16 nCurMax; //Mehr werden nicht aufgenommen.
86*b1cdbd2cSJim Jagielski
87*b1cdbd2cSJim Jagielski
88*b1cdbd2cSJim Jagielski void DeleteObj( SwCacheObj *pObj );
89*b1cdbd2cSJim Jagielski
90*b1cdbd2cSJim Jagielski #ifdef DBG_UTIL
91*b1cdbd2cSJim Jagielski ByteString aName;
92*b1cdbd2cSJim Jagielski long nAppend; //Anzahl der Eintragungen durch Erweiterung.
93*b1cdbd2cSJim Jagielski long nInsertFree; //Anzahl der Eintragungen auf freie Plaetze.
94*b1cdbd2cSJim Jagielski long nReplace; //Anzahl der Ersetzungen durch ein neues Objekt
95*b1cdbd2cSJim Jagielski long nGetSuccess; //Anzahl der Erfolgreichen Get's
96*b1cdbd2cSJim Jagielski long nGetFail; //Anzahl der nicht Erfolgreichen Get's
97*b1cdbd2cSJim Jagielski long nToTop; //Anzahl der Umsortierungen (LRU)
98*b1cdbd2cSJim Jagielski long nDelete; //Anzahl der Loeschungen (von Aussen)
99*b1cdbd2cSJim Jagielski long nGetSeek; //Anzahl der Get's ohne Index
100*b1cdbd2cSJim Jagielski long nAverageSeekCnt; //Anzahl der Seek's fuer alle Get's ohne Index
101*b1cdbd2cSJim Jagielski long nFlushCnt; //Anzahl von Flush-Aufrufen.
102*b1cdbd2cSJim Jagielski long nFlushedObjects; //Anzahl der wg. Flush vernichteten Objekte
103*b1cdbd2cSJim Jagielski long nIncreaseMax; //Anzahl Cache-Erweiterungen
104*b1cdbd2cSJim Jagielski long nDecreaseMax; //Anzahl Cache-Verkleinerungen
105*b1cdbd2cSJim Jagielski
106*b1cdbd2cSJim Jagielski void Check(); //Wird bei swcache.cxx mit DEBUG aktiv!
107*b1cdbd2cSJim Jagielski #endif
108*b1cdbd2cSJim Jagielski
109*b1cdbd2cSJim Jagielski public:
110*b1cdbd2cSJim Jagielski
111*b1cdbd2cSJim Jagielski //nur sal_uInt8 hineinstecken!!!
112*b1cdbd2cSJim Jagielski #ifdef DBG_UTIL
113*b1cdbd2cSJim Jagielski SwCache( const sal_uInt16 nInitSize, const sal_uInt16 nGrowSize,
114*b1cdbd2cSJim Jagielski const ByteString &rNm );
115*b1cdbd2cSJim Jagielski ~SwCache();
116*b1cdbd2cSJim Jagielski #else
117*b1cdbd2cSJim Jagielski SwCache( const sal_uInt16 nInitSize, const sal_uInt16 nGrowSize );
118*b1cdbd2cSJim Jagielski #endif
119*b1cdbd2cSJim Jagielski
120*b1cdbd2cSJim Jagielski void Flush( const sal_uInt8 nPercent = 100 );
121*b1cdbd2cSJim Jagielski
122*b1cdbd2cSJim Jagielski //bToTop == sal_False -> Keine LRU-Umsortierung!
123*b1cdbd2cSJim Jagielski SwCacheObj *Get( const void *pOwner, const sal_Bool bToTop = sal_True );
124*b1cdbd2cSJim Jagielski SwCacheObj *Get( const void *pOwner, const sal_uInt16 nIndex,
125*b1cdbd2cSJim Jagielski const sal_Bool bToTop = sal_True );
126*b1cdbd2cSJim Jagielski void ToTop( SwCacheObj *pObj );
127*b1cdbd2cSJim Jagielski
128*b1cdbd2cSJim Jagielski sal_Bool Insert( SwCacheObj *pNew );
129*b1cdbd2cSJim Jagielski void Delete( const void *pOwner );
130*b1cdbd2cSJim Jagielski // void Delete( const void *pOwner, const sal_uInt16 nIndex );
131*b1cdbd2cSJim Jagielski
132*b1cdbd2cSJim Jagielski void SetLRUOfst( const sal_uInt16 nOfst ); //nOfst sagt wieviele unangetastet
133*b1cdbd2cSJim Jagielski //bleiben sollen.
ResetLRUOfst()134*b1cdbd2cSJim Jagielski void ResetLRUOfst() { pFirst = pRealFirst; }
135*b1cdbd2cSJim Jagielski
136*b1cdbd2cSJim Jagielski inline void IncreaseMax( const sal_uInt16 nAdd );
137*b1cdbd2cSJim Jagielski inline void DecreaseMax( const sal_uInt16 nSub );
GetCurMax() const138*b1cdbd2cSJim Jagielski sal_uInt16 GetCurMax() const { return nCurMax; }
First()139*b1cdbd2cSJim Jagielski inline SwCacheObj *First() { return pRealFirst; }
Last()140*b1cdbd2cSJim Jagielski inline SwCacheObj *Last() { return pLast; }
141*b1cdbd2cSJim Jagielski inline SwCacheObj *Next( SwCacheObj *pCacheObj);
142*b1cdbd2cSJim Jagielski };
143*b1cdbd2cSJim Jagielski
144*b1cdbd2cSJim Jagielski //Cache-Manipulation auf die sichere Art.
145*b1cdbd2cSJim Jagielski class SwSaveSetLRUOfst
146*b1cdbd2cSJim Jagielski {
147*b1cdbd2cSJim Jagielski SwCache &rCache;
148*b1cdbd2cSJim Jagielski public:
SwSaveSetLRUOfst(SwCache & rC,const sal_uInt16 nOfst)149*b1cdbd2cSJim Jagielski SwSaveSetLRUOfst( SwCache &rC, const sal_uInt16 nOfst )
150*b1cdbd2cSJim Jagielski : rCache( rC ) { rCache.SetLRUOfst( nOfst ); }
151*b1cdbd2cSJim Jagielski
~SwSaveSetLRUOfst()152*b1cdbd2cSJim Jagielski ~SwSaveSetLRUOfst() { rCache.ResetLRUOfst(); }
153*b1cdbd2cSJim Jagielski };
154*b1cdbd2cSJim Jagielski
155*b1cdbd2cSJim Jagielski //Das allgemeine CacheObjekt. Anwender des Cache muessen eine Klasse vom
156*b1cdbd2cSJim Jagielski //CacheObjekt ableiten und dort die Nutzdaten unterbringen.
157*b1cdbd2cSJim Jagielski
158*b1cdbd2cSJim Jagielski class SwCacheObj
159*b1cdbd2cSJim Jagielski {
160*b1cdbd2cSJim Jagielski friend class SwCache; //Der darf alles
161*b1cdbd2cSJim Jagielski
162*b1cdbd2cSJim Jagielski SwCacheObj *pNext; //Fuer die LRU-Verkettung.
163*b1cdbd2cSJim Jagielski SwCacheObj *pPrev;
164*b1cdbd2cSJim Jagielski
165*b1cdbd2cSJim Jagielski sal_uInt16 nCachePos; //Position im Cache-Array.
166*b1cdbd2cSJim Jagielski
167*b1cdbd2cSJim Jagielski sal_uInt8 nLock;
168*b1cdbd2cSJim Jagielski
GetNext()169*b1cdbd2cSJim Jagielski inline SwCacheObj *GetNext() { return pNext; }
GetPrev()170*b1cdbd2cSJim Jagielski inline SwCacheObj *GetPrev() { return pPrev; }
SetNext(SwCacheObj * pNew)171*b1cdbd2cSJim Jagielski inline void SetNext( SwCacheObj *pNew ) { pNext = pNew; }
SetPrev(SwCacheObj * pNew)172*b1cdbd2cSJim Jagielski inline void SetPrev( SwCacheObj *pNew ) { pPrev = pNew; }
173*b1cdbd2cSJim Jagielski
SetCachePos(const sal_uInt16 nNew)174*b1cdbd2cSJim Jagielski inline void SetCachePos( const sal_uInt16 nNew ) { nCachePos = nNew; }
175*b1cdbd2cSJim Jagielski
176*b1cdbd2cSJim Jagielski protected:
177*b1cdbd2cSJim Jagielski const void *pOwner;
SetOwner(const void * pNew)178*b1cdbd2cSJim Jagielski inline void SetOwner( const void *pNew ) { pOwner = pNew; }
179*b1cdbd2cSJim Jagielski
180*b1cdbd2cSJim Jagielski public:
181*b1cdbd2cSJim Jagielski
182*b1cdbd2cSJim Jagielski SwCacheObj( const void *pOwner );
183*b1cdbd2cSJim Jagielski virtual ~SwCacheObj();
184*b1cdbd2cSJim Jagielski
GetOwner() const185*b1cdbd2cSJim Jagielski inline const void *GetOwner() const { return pOwner; }
186*b1cdbd2cSJim Jagielski inline sal_Bool IsOwner( const void *pNew ) const;
187*b1cdbd2cSJim Jagielski
GetCachePos() const188*b1cdbd2cSJim Jagielski inline sal_uInt16 GetCachePos() const { return nCachePos; }
Invalidate()189*b1cdbd2cSJim Jagielski inline void Invalidate() { pOwner = 0; }
190*b1cdbd2cSJim Jagielski
IsLocked() const191*b1cdbd2cSJim Jagielski inline sal_Bool IsLocked() const { return 0 != nLock; }
192*b1cdbd2cSJim Jagielski
193*b1cdbd2cSJim Jagielski #ifndef DBG_UTIL
Lock()194*b1cdbd2cSJim Jagielski inline void Lock() { ++nLock; }
Unlock()195*b1cdbd2cSJim Jagielski inline void Unlock() { --nLock; }
196*b1cdbd2cSJim Jagielski #else
197*b1cdbd2cSJim Jagielski void Lock();
198*b1cdbd2cSJim Jagielski void Unlock();
199*b1cdbd2cSJim Jagielski #endif
200*b1cdbd2cSJim Jagielski
Next()201*b1cdbd2cSJim Jagielski SwCacheObj *Next() { return pNext; }
Prev()202*b1cdbd2cSJim Jagielski SwCacheObj *Prev() { return pPrev; }
203*b1cdbd2cSJim Jagielski
204*b1cdbd2cSJim Jagielski };
205*b1cdbd2cSJim Jagielski
206*b1cdbd2cSJim Jagielski //Zugriffsklasse fuer den Cache. Im CTor wird das CacheObjekt erzeugt.
207*b1cdbd2cSJim Jagielski //Wenn der Cache keines herausrueckt wird der Member zunaechst auf 0 gesetzt.
208*b1cdbd2cSJim Jagielski //Beim Get wird dann eines erzeugt und, falls moeglich, in den Cache
209*b1cdbd2cSJim Jagielski //eingetragen.
210*b1cdbd2cSJim Jagielski //Anwender der des Cache muessen eine Klasse vom Access ableiten um
211*b1cdbd2cSJim Jagielski //fuer Typsicherheit zu sorgen, die Basisklasse sollte fuer das Get aber immer
212*b1cdbd2cSJim Jagielski //gerufen werden, ein Abgeleitetes Get sollte nur der Typsicherheit dienen.
213*b1cdbd2cSJim Jagielski //Cache-Objekte werden stets gelockt solange die Instanz lebt.
214*b1cdbd2cSJim Jagielski
215*b1cdbd2cSJim Jagielski class SwCacheAccess
216*b1cdbd2cSJim Jagielski {
217*b1cdbd2cSJim Jagielski SwCache &rCache;
218*b1cdbd2cSJim Jagielski
219*b1cdbd2cSJim Jagielski void _Get();
220*b1cdbd2cSJim Jagielski
221*b1cdbd2cSJim Jagielski protected:
222*b1cdbd2cSJim Jagielski SwCacheObj *pObj;
223*b1cdbd2cSJim Jagielski const void *pOwner; //Kann ggf. in NewObj benutzt werden.
224*b1cdbd2cSJim Jagielski
225*b1cdbd2cSJim Jagielski virtual SwCacheObj *NewObj() = 0;
226*b1cdbd2cSJim Jagielski
227*b1cdbd2cSJim Jagielski inline SwCacheObj *Get();
228*b1cdbd2cSJim Jagielski
229*b1cdbd2cSJim Jagielski inline SwCacheAccess( SwCache &rCache, const void *pOwner, sal_Bool bSeek = sal_True );
230*b1cdbd2cSJim Jagielski inline SwCacheAccess( SwCache &rCache, const void *pOwner, const sal_uInt16 nIndex );
231*b1cdbd2cSJim Jagielski
232*b1cdbd2cSJim Jagielski public:
233*b1cdbd2cSJim Jagielski virtual ~SwCacheAccess();
234*b1cdbd2cSJim Jagielski
235*b1cdbd2cSJim Jagielski virtual sal_Bool IsAvailable() const;
236*b1cdbd2cSJim Jagielski
237*b1cdbd2cSJim Jagielski //Abkuerzung fuer diejenigen, die wissen, das die Ableitung das IsAvailable
238*b1cdbd2cSJim Jagielski //nicht ueberladen haben.
IsAvail() const239*b1cdbd2cSJim Jagielski sal_Bool IsAvail() const { return pObj != 0; }
240*b1cdbd2cSJim Jagielski };
241*b1cdbd2cSJim Jagielski
IncreaseMax(const sal_uInt16 nAdd)242*b1cdbd2cSJim Jagielski inline void SwCache::IncreaseMax( const sal_uInt16 nAdd )
243*b1cdbd2cSJim Jagielski {
244*b1cdbd2cSJim Jagielski nCurMax = nCurMax + sal::static_int_cast< sal_uInt16 >(nAdd);
245*b1cdbd2cSJim Jagielski #ifdef DBG_UTIL
246*b1cdbd2cSJim Jagielski ++nIncreaseMax;
247*b1cdbd2cSJim Jagielski #endif
248*b1cdbd2cSJim Jagielski }
DecreaseMax(const sal_uInt16 nSub)249*b1cdbd2cSJim Jagielski inline void SwCache::DecreaseMax( const sal_uInt16 nSub )
250*b1cdbd2cSJim Jagielski {
251*b1cdbd2cSJim Jagielski if ( nCurMax > nSub )
252*b1cdbd2cSJim Jagielski nCurMax = nCurMax - sal::static_int_cast< sal_uInt16 >(nSub);
253*b1cdbd2cSJim Jagielski #ifdef DBG_UTIL
254*b1cdbd2cSJim Jagielski ++nDecreaseMax;
255*b1cdbd2cSJim Jagielski #endif
256*b1cdbd2cSJim Jagielski }
257*b1cdbd2cSJim Jagielski
IsOwner(const void * pNew) const258*b1cdbd2cSJim Jagielski inline sal_Bool SwCacheObj::IsOwner( const void *pNew ) const
259*b1cdbd2cSJim Jagielski {
260*b1cdbd2cSJim Jagielski return pOwner && pOwner == pNew;
261*b1cdbd2cSJim Jagielski }
262*b1cdbd2cSJim Jagielski
Next(SwCacheObj * pCacheObj)263*b1cdbd2cSJim Jagielski inline SwCacheObj *SwCache::Next( SwCacheObj *pCacheObj)
264*b1cdbd2cSJim Jagielski {
265*b1cdbd2cSJim Jagielski if ( pCacheObj )
266*b1cdbd2cSJim Jagielski return pCacheObj->GetNext();
267*b1cdbd2cSJim Jagielski else
268*b1cdbd2cSJim Jagielski return NULL;
269*b1cdbd2cSJim Jagielski }
270*b1cdbd2cSJim Jagielski
SwCacheAccess(SwCache & rC,const void * pOwn,sal_Bool bSeek)271*b1cdbd2cSJim Jagielski inline SwCacheAccess::SwCacheAccess( SwCache &rC, const void *pOwn, sal_Bool bSeek ) :
272*b1cdbd2cSJim Jagielski rCache( rC ),
273*b1cdbd2cSJim Jagielski pObj( 0 ),
274*b1cdbd2cSJim Jagielski pOwner( pOwn )
275*b1cdbd2cSJim Jagielski {
276*b1cdbd2cSJim Jagielski if ( bSeek && pOwner && 0 != (pObj = rCache.Get( pOwner )) )
277*b1cdbd2cSJim Jagielski pObj->Lock();
278*b1cdbd2cSJim Jagielski }
279*b1cdbd2cSJim Jagielski
SwCacheAccess(SwCache & rC,const void * pOwn,const sal_uInt16 nIndex)280*b1cdbd2cSJim Jagielski inline SwCacheAccess::SwCacheAccess( SwCache &rC, const void *pOwn,
281*b1cdbd2cSJim Jagielski const sal_uInt16 nIndex ) :
282*b1cdbd2cSJim Jagielski rCache( rC ),
283*b1cdbd2cSJim Jagielski pObj( 0 ),
284*b1cdbd2cSJim Jagielski pOwner( pOwn )
285*b1cdbd2cSJim Jagielski {
286*b1cdbd2cSJim Jagielski if ( pOwner && 0 != (pObj = rCache.Get( pOwner, nIndex )) )
287*b1cdbd2cSJim Jagielski pObj->Lock();
288*b1cdbd2cSJim Jagielski }
289*b1cdbd2cSJim Jagielski
Get()290*b1cdbd2cSJim Jagielski inline SwCacheObj *SwCacheAccess::Get()
291*b1cdbd2cSJim Jagielski {
292*b1cdbd2cSJim Jagielski if ( !pObj )
293*b1cdbd2cSJim Jagielski _Get();
294*b1cdbd2cSJim Jagielski return pObj;
295*b1cdbd2cSJim Jagielski }
296*b1cdbd2cSJim Jagielski
297*b1cdbd2cSJim Jagielski
298*b1cdbd2cSJim Jagielski #endif
299