1 // Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).
2 // All rights reserved.
3 // This component and the accompanying materials are made available
4 // under the terms of "Eclipse Public License v1.0"
5 // which accompanies this distribution, and is available
6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".
8 // Initial Contributors:
9 // Nokia Corporation - initial contribution.
17 inline TStreamId CStreamStore::ExtendL()
18 /** Generates a new stream within this store, and returns its id. This function
19 can be used to create a new stream in advance of being written to.
21 This function is not supported by the direct file store, CDirectFileStore.
23 @return The stream id for the newly generated stream.
24 @see CDirectFileStore */
26 inline void CStreamStore::CommitL()
27 /** Commit changes and leaves if unsuccessful.
29 @see CStreamStore::Commit() */
31 inline void CStreamStore::RevertL()
32 /** Rolls back the store to its state at the last commit point and leaves if unsuccessful.
34 The function is not supported by the direct file store CDirectFileStore and
35 the non-persistent in-memory store CBufStore.
41 // Class CPersistentStore
42 inline CPersistentStore::CPersistentStore()
43 // : iRoot(KNullStreamId)
45 inline TStreamId CPersistentStore::Root() const
46 /** Returns the stream id of the root stream.
48 @return The id of the root stream. */
50 inline void CPersistentStore::SetRootL(TStreamId anId)
51 /** Sets the specified stream as the root stream.
53 @param anId The id of the stream which is to be the root stream of this store. */
56 // Class RStoreReclaim
57 inline RStoreReclaim::RStoreReclaim()
60 inline void RStoreReclaim::Close()
61 /** Stops space reclamation or compaction. All allocated resources are freed.
65 If a cleanup item was placed on the cleanup stack when the RStoreReclaim object
66 was prepared for space reclamation or compaction (i.e. by a call to OpenLC()
67 or CompactLC()), then this function need not be called explicitly; clean up
68 is implicitly done by CleanupStack::PopAndDestroy().
70 The ResetL() member function can be used to restart abandoned space reclamation
71 or compaction activity. */
73 inline TInt RStoreReclaim::Available() const
74 /** Returns the amount of free space currently available within the store. The
75 function may be called at any time during space reclamation or compaction.
77 @return The amount of free space currently available within the store. */
78 {return CONST_CAST(TPckgBuf<TInt>&,iAvail)();}
80 // Class CEmbeddedStore
81 inline TStreamPos CEmbeddedStore::Position(TStreamId anId)
82 /** Returns the position of the specified stream, within the host stream.
84 @param anId The stream id of the stream in the embedded store whose position
85 within the host stream is to be returned.
86 @return The position of the stream with id anId within the host stream. */
87 {return TStreamPos(anId.Value());}
88 inline void CEmbeddedStore::Reattach(MStreamBuf* aHost)
89 /** Takes ownership of the specified stream buffer. On return from this function,
90 the embedded store assumes this to be the host stream buffer.
92 @param aHost A pointer to the stream buffer over which the embedded store
93 is to take ownership. */
95 inline MStreamBuf* CEmbeddedStore::Host() const
96 /** Returns a pointer to the stream buffer which is acting as host to this embedded
97 store. The embedded store retains ownership of the host stream buffer.
99 @return A pointer to the stream buffer which is host to this embedded store. */
100 {return MUTABLE_CAST(TStreamExchange&,iHost).Host();}
101 inline TStreamPos CEmbeddedStore::Start() const
102 /** Returns the start position of this embedded store within the host stream.
104 @return The position of the this embedded store within the host stream. */
107 // Class RDictionaryWriteStream
108 inline RDictionaryWriteStream::RDictionaryWriteStream(const MExternalizer<TStreamRef>& anExter)
109 : RWriteStream(anExter)
110 /** Constructs the object with an externaliser. The store map CStoreMap is an example
113 @param anExter Specifies an externaliser.
117 // Class TStorePagePoolToken
118 inline TStorePagePoolToken::TStorePagePoolToken(TEmpty)
119 : iHead(KNullStreamId),iAvail(KNullPageRef)
120 /** Constructor that intialises the TStorePagePoolToken for an empty page pool.
122 @param Intialises for an empty page pool */
124 inline void TStorePagePoolToken::Touch()
125 /** Sets the available pages to 0. */
126 {iAvail=KNullPageRef;}
127 inline TBool TStorePagePoolToken::HasAvailable() const
128 /** Tests if there is a free page in the pool.
130 @return True if there is a free page in the pool, otherwise false */
131 {return iAvail!=KNullPageRef;}
132 inline TBool TStorePagePoolToken::IsEmpty() const
133 /** Tests if the page pool is empty.
135 @return True if the page pool is empty, otherwise false. */
136 {return iHead==KNullStreamId;}
138 // Class RStorePagePool
139 inline void RStorePagePool::Release()
140 /** Purges the page cache and stops using the stream store. */
141 {Purge();iStore=NULL;}
142 inline TBool RStorePagePool::IsDirty() const
143 /** Tests if the dirty flag has been set on the page pool.
145 @return True if the dirty flag has been set, otherwise false */
147 inline void RStorePagePool::MarkCurrent()
148 /** Clears the dirty flag. */
150 inline void RStorePagePool::MarkDirty()
151 /** Sets the dirty flag on the pool. */
153 inline TBool RStorePagePool::HasAvailable() const
154 /** Tests if there is a free page in the pool.
156 @return True if there is a free page in the pool, otherwise false */
157 {return iAvail!=KNullPageRef;}
158 inline void RStorePagePool::Discard()
159 /** Invalidates the list of free pages in the reclaimable set.
161 This should be done if there has been a failure in updating the BTree, as
162 this list is possibly corrupt now. The reclaimable set can be deleted using
163 ReclaimAllL(), and the BTree then repaired. */
164 {iAvail=KNullPageRef;}
165 inline TBool RStorePagePool::IsEmpty() const
166 /** Tests if the page pool is empty.
168 @return True if the page pool is empty, otherwise false */
169 {return iHead==KNullStreamId;}
171 // Class MIncrementalCollector
172 inline void MIncrementalCollector::Close()
173 /** Closes the collector after it is no longer required. The object should not
174 be referenced after calling this function. The semantics for this function
175 and Release() are effectively the same. */
177 inline void MIncrementalCollector::Release()
178 /** Releases the collector after it is no longer required. The object should not
179 be referenced after calling this function. The semantics for this function
180 and Close() are effectively the same.
184 inline void MIncrementalCollector::ResetL(TInt& aCount)
185 /** Resets the collector. This leaves the collector in a state ready to start or
186 restart reclaiming/compacting. On return aCount contains a value that can
187 be used to determine the progress of the operation the same value should
188 be passed in to subsequent calls to NextL() until it reaches 0.
190 @param aCount A progress count for the reclamation/compaction process.
193 inline void MIncrementalCollector::NextL(TInt& aStep,TInt& aTotal)
194 /** Does the next step in the reclaim synchronously.
196 aStep contains a progress value, which decreases every time the function is
197 called. aTotal contains the running total of free-space that remains in the
200 @param aStep The progress value from either the last NextL() increment of
201 from ResetL() if the reclamation/compaction was restarted. On return,
202 contains the new progress value, which can be used in subsequent calls to
203 NextL(). This will be equal to, or less than, the previous value a zero
204 value indicates that the operation is complete.
205 @param aTotal On return, contains the total amount of free space in the store.
206 This should increase every time the function is called.
208 {DoNextL(aStep,aTotal);}
209 inline void MIncrementalCollector::NextL(TPckgBuf<TInt>& aStep,TRequestStatus& aStatus,TPckgBuf<TInt>& aTotal)
210 /** Does the next step in the reclaim asynchronously.
212 aStep contains a progress value, which decreases every time the function is
213 called. aTotal contains the running total of free-space that remains in the
214 store. These parameters are asynchronous equivalents of the other NextL()
217 @param aStep The progress value from either the last NextL() increment of
218 from ResetL() if the reclamation/compaction was restarted. On return,
219 contains the new progress value, which can be used in subsequent calls to
220 NextL(). This will be equal to, or less than, the previous value a zero
221 value indicates that the operation is complete.
222 @param aStatus A status variable. KErrNone on successful completion, otherwise
223 another of the system-wide error codes.
224 @param aTotal On return, contains the total amount of free space in the store.
225 This should increase every time the function is called.
227 {DoNextL(aStep,aStatus,aTotal);}