Symaptic: os/persistentdata/persistentstorage/store/INC/S32FILE.H@260cb5ec6c19

     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".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    16 #if !defined(__S32FILE_H__)

    17 #define __S32FILE_H__

    18 #if !defined(__F32FILE_H__)

    19 #include <f32file.h>

    20 #endif

    21 #if !defined(__S32STOR_H__)

    22 #include <s32stor.h>

    23 #endif

    25 #ifndef SYMBIAN_ENABLE_SPLIT_HEADERS

    26 	#include <s32filebufsize.h>

    27 #endif

    29 template <class T>

    30 class TCapture;

    31 class RPermanentFileStoreIter;

    33 /** A stream buffer hosted by a file.

    34  * @publishedAll

    35  * @released

    37 Instances of this class are used by file based persistent stores, i.e. CFileStore

    38 type objects. An RFileBuf object is associated with a file and the file is

    39 said to be attached to the stream buffer.

    41 An RFileBuf object is also used by RFileReadStream and RFileWriteStream objects

    42 to provide buffered file I/O.

    44 The stream buffer has intermediate buffering capabilities.

    46 When used as the basis for a file store, it hosts multiple streams through

    47 the TStreamExchange and RShareBuf classes.

    49 Open(), Close(), Attach(), Detach(), File() and Reattach() usage patterns:

    51 Pattern 1: RFileBuf owns the file

    52 step 1a: Open()/Create()/Temp() is used to connect the buffer to a file

    53 step 1b: Use the file buffer

    54 step 1c: Close() releases this resource.

    56 Pattern 2: RFile is opened elsewhere and ownership is handed over to RFileBuf

    57 This may happen if the file is already opened by another API, or from another process for example

    58 step 2a: Attach() is used to hand ownership of the opened file to the buffer. After Attach() the supplied file handle is NULLed.

    59 step 2b: Use the file buffer

    60 step 2c: Close() releases the file resource.

    62 Pattern 3: RFileBuf is used transiently to manage an existing opened file:

    63 step 3a: Attach() is used to bind the buffer to the already open file. After Attach() the supplied file handle is NULLed.

    64 step 3b: Use the file buffer

    65 step 3c: RFileBuf::File() is used to retrieve the file handle again, then Detach() is called to disconnect the buffer from the file.

    66 At this point, the destruction of the file buffer will have no effect on the file. The retrieved file handle in step 3c must be used to close the file.

    68 Pattern 4: Transient direct file access to a buffered file

    69 step 4a: RFileBuf::File() is used to retrieve the file handle. [Optional: Detach() is used to disconnect the file buffer]

    70 step 4b: Use the file directly. Note that writing to the file may cause coherency problems with the RFileBuf buffer - in which case you need to Reset() the buffer as well.

    71 step 4c: [Optional: Reattach() is used to hand the file back to the buffer]. Use of the buffer is resumed

    73 @see CFileStore

    74 @see RFileReadStream

    75 @see RFileWriteStream */

    76 class RFileBuf : public TStreamBuf

    77 	{

    78 public:

    79 	IMPORT_C RFileBuf();

    80 	IMPORT_C RFileBuf(TInt aSize);

    81 	RFileBuf(TCapture<RFileBuf> aCapture);

    82 	IMPORT_C void Reset();

    83 	inline void Reset(TInt aSize);

    84 //

    85 	IMPORT_C TInt Open(RFs& aFs,const TDesC& aName,TUint aFileMode);

    86 	IMPORT_C TInt Create(RFs& aFs,const TDesC& aName,TUint aFileMode);

    87 	IMPORT_C TInt Replace(RFs& aFs,const TDesC& aName,TUint aFileMode);

    88 	IMPORT_C TInt Temp(RFs& aFs,const TDesC& aPath,TFileName& aName,TUint aFileMode);

    89 	IMPORT_C void Attach(RFile& aFile,TInt aPos=0);

    90 	IMPORT_C void Close();

    91 	inline void Detach();

    92 	inline void Reattach(RFile& aFile);

    93 //

    94 	IMPORT_C void SetSizeL(TInt aSize);

    95 	inline RFile& File() const;

    96 protected:

    97 	IMPORT_C TInt UnderflowL(TInt aMaxLength);

    98 	IMPORT_C void OverflowL();

    99 	IMPORT_C void DoRelease();

   100 	IMPORT_C void DoSynchL();

   101 	IMPORT_C TInt DoReadL(TAny* aPtr,TInt aMaxLength);

   102 	IMPORT_C TInt DoReadL(TDes8& aDes,TInt aMaxLength,TRequestStatus& aStatus);

   103 	IMPORT_C void DoWriteL(const TAny* aPtr,TInt aLength);

   104 	IMPORT_C TInt DoWriteL(const TDesC8& aDes,TInt aMaxLength,TRequestStatus& aStatus);

   105 	IMPORT_C TStreamPos DoSeekL(TMark aMark,TStreamLocation aLocation,TInt anOffset);

   106 //

   107 	inline void SetBuf(TRead,TUint8* aPtr,TUint8* anEnd);

   108 	inline void SetBuf(TWrite,TUint8* aPtr,TUint8* anEnd);

   109 	inline void SetBuf(TArea anArea,TUint8* aPtr,TUint8* anEnd);

   110 private:

   111 	TUint8* AllocL();

   112 	void Free();

   113 //

   114 	void SetPos(TMark aMark,TInt aPos);

   115 	inline void SetPos(TRead,TInt aPos);

   116 	inline void SetPos(TWrite,TInt aPos);

   117 	inline TInt Pos(TRead) const;

   118 	inline TInt Pos(TWrite) const;

   119 	inline TInt MovePos(TRead,TInt anOffset);

   120 	inline TInt MovePos(TWrite,TInt anOffset);

   121 	TInt FileReadL(TAny* aPtr,TInt aMaxLength);

   122 	void FileWriteL(const TAny* aPtr,TInt aLength,TInt aSeek);

   123 	void FileWriteL(const TAny* aPtr,TInt aLength);

   124 	TInt EndL();

   125 //

   126 	inline TInt Lag(TRead) const;

   127 	inline TInt Lag(TWrite) const;

   128 	TInt Mark(TMark aMark) const;

   129 	inline TInt Mark(TRead) const;

   130 	inline TInt Mark(TWrite) const;

   131 	inline TUint8* Limit(TWrite) const;

   132 	inline void SetLimit(TWrite,TUint8* aLimit);

   133 	inline TInt Span(TWrite) const;

   134 	inline TInt Reach(TWrite) const;

   135 private:

   136 	TUint8* iBase;

   137 	TInt iSize;

   138 	__MUTABLE RFile iFile;

   139 	TInt iRPos;

   140 	TInt iWPos;

   141 	TInt iExt;

   142 	TUint8* iWLim;

   143 	friend class CFileStore;

   144 	};

   146 /**

   147  * @publishedAll

   148  * @released

   149  * Supports the reading of a stream from a file.

   150  */

   151 class RFileReadStream : public RReadStream

   152 	{

   153 public:

   154 	/** Constructs an empty read stream object. */

   155 	RFileReadStream() {}

   156 	IMPORT_C RFileReadStream(RFile& aFile,TInt aPos=0);

   157 	IMPORT_C TInt Open(RFs& aFs,const TDesC& aName,TUint aFileMode);

   158 	IMPORT_C void Attach(RFile& aFile,TInt aPos=0);

   159 private:

   160 	RFileBuf iSource;

   161 	};

   163 /**

   164  * @publishedAll

   165  * @released

   166  * Supports the writing of a stream to a file.

   167  */

   168 class RFileWriteStream : public RWriteStream

   169 	{

   170 public:

   171 	/** Constructs an empty write stream object. */

   172 	RFileWriteStream() {}

   173 	inline RFileWriteStream(const MExternalizer<TStreamRef>& anExter);

   174 	IMPORT_C RFileWriteStream(RFile& aFile,TInt aPos=0);

   175 	IMPORT_C TInt Open(RFs& aFs,const TDesC& aName,TUint aFileMode);

   176 	IMPORT_C TInt Create(RFs& aFs,const TDesC& aName,TUint aFileMode);

   177 	IMPORT_C TInt Replace(RFs& aFs,const TDesC& aName,TUint aFileMode);

   178 	IMPORT_C TInt Temp(RFs& aFs,const TDesC& aPath,TFileName& aName,TUint aFileMode);

   179 	IMPORT_C void Attach(RFile& aFile,TInt aPos=0);

   180 private:

   181 	RFileBuf iSink;

   182 	};

   183 //

   184 class CFileStore;

   186 /**

   187  * @publishedAll

   188  * @released

   189  * A class containing a set of factory functions for opening an existing direct

   190  file store and an existing permanent file store identified using a Uidtype.

   191  */

   192 class FileStoreFactory

   193 	{

   194 public:

   195 	IMPORT_C static CFileStore* DirectLC(RFileBuf& aBuf,const TUidType& aType);

   196 	IMPORT_C static CFileStore* PermanentLC(RFileBuf& aBuf,const TUidType& aType);

   197 	};

   198 //

   199 const TInt KDirectFileStoreLayoutUidValue=268435511;

   200 /** The value of the KPermanentFileStoreLayoutUidValue UID. */

   201 const TInt KPermanentFileStoreLayoutUidValue=268435536;

   202 /** The UID that identifies a file store as being a direct file store. */

   203 const TUid KDirectFileStoreLayoutUid={KDirectFileStoreLayoutUidValue};

   204 /** The UID that identifies a file store as being a permanent file store. */

   205 const TUid KPermanentFileStoreLayoutUid={KPermanentFileStoreLayoutUidValue};

   206 //

   207 typedef CFileStore* (*TFileStoreFactoryFunction)(RFileBuf& aBuf,const TUidType& aType);

   208 //

   209 #define KDirectFileStoreFactoryFunction (&FileStoreFactory::DirectLC)

   210 #define KPermanentFileStoreFactoryFunction (&FileStoreFactory::PermanentLC)

   212 /**

   213  * @publishedAll

   214  * @released

   215  * File based persistent store abstract base class.

   217 The class encapsulates the basic behaviour of file based stores. File based

   218 stores are persistent stores, i.e. they have the ability to keep the external

   219 representation of objects for longer than the lifetime of the applications

   220 which created those objects.

   222 The class forms the base for the direct file store, CDirectFileStore, and

   223 the permanent file store, CPermanentFileStore. In general, it is sufficient

   224 for pointers to file based store objects to be of type CFileStore, rather

   225 than of the concrete file store type.

   227 Existing file stores can be opened using the member functions OpenL(), OpenLC(),

   228 FromL() and FromLC(). New file stores, however, must be created using the

   229 appropriate member function of the concrete type.

   230 */

   231 class CFileStore : public CPersistentStore

   232 	{

   233 public:

   234 	IMPORT_C static CFileStore* OpenL(RFs& aFs,const TDesC& aName,TUint aFileMode);

   235 	IMPORT_C static CFileStore* OpenLC(RFs& aFs,const TDesC& aName,TUint aFileMode);

   236 	IMPORT_C static CFileStore* FromL(RFile& aFile);

   237 	IMPORT_C static CFileStore* FromLC(RFile& aFile);

   238 //

   239 	IMPORT_C static CFileStore* OpenL(RFs& aFs,const TDesC& aName,TUint aFileMode,const TFileStoreFactoryFunction aFactory[]);

   240 	IMPORT_C static CFileStore* OpenLC(RFs& aFs,const TDesC& aName,TUint aFileMode,const TFileStoreFactoryFunction aFactory[]);

   241 	IMPORT_C static CFileStore* FromL(RFile& aFile,const TFileStoreFactoryFunction aFactory[]);

   242 	IMPORT_C static CFileStore* FromLC(RFile& aFile,const TFileStoreFactoryFunction aFactory[]);

   243 //

   244 	inline const TUidType& Type() const;

   245 	IMPORT_C void SetTypeL(const TUidType& aType);

   246 	/** Gets the UID that uniquely identifies the specific type of this file store.

   248 	This function must be defined and implemented by classes derived from CFileStore.

   249 	The direct file store, CDirectFileStore and the permanent file store, CPermanentFileStore

   250 	both implement suitable functions.

   252 	@return The UID that uniquely identifies the specific type of file store.

   253 	@see KDirectFileStoreLayoutUid

   254 	@see KPermanentFileStoreLayoutUid */

   255 	virtual TUid Layout() const=0;

   256 //

   257 	inline void Reset();

   258 	inline void Reset(TInt aSize);

   259 	inline void Detach();

   260 	inline void Reattach(RFile& aFile);

   261 	inline RFile& File() const;

   262 //

   263 	IMPORT_C void MarshalL();

   264 	IMPORT_C ~CFileStore();

   265 protected:

   266 	typedef CFileStore* (*TNewFunction)(RFile& aFile);

   267 protected:

   268 	IMPORT_C static CFileStore* OpenL(RFs& aFs,const TDesC& aName,TUint aFileMode,TFileStoreFactoryFunction aFunction);

   269 	IMPORT_C static CFileStore* OpenLC(RFs& aFs,const TDesC& aName,TUint aFileMode,TFileStoreFactoryFunction aFunction);

   270 	IMPORT_C static CFileStore* CreateL(RFs& aFs,const TDesC& aName,TUint aFileMode,TNewFunction aFunction);

   271 	IMPORT_C static CFileStore* CreateLC(RFs& aFs,const TDesC& aName,TUint aFileMode,TNewFunction aFunction);

   272 	IMPORT_C static CFileStore* ReplaceL(RFs& aFs,const TDesC& aName,TUint aFileMode,TNewFunction aFunction);

   273 	IMPORT_C static CFileStore* ReplaceLC(RFs& aFs,const TDesC& aName,TUint aFileMode,TNewFunction aFunction);

   274 	IMPORT_C static CFileStore* TempL(RFs& aFs,const TDesC& aPath,TFileName& aName,TUint aFileMode,TNewFunction aFunction);

   275 	IMPORT_C static CFileStore* TempLC(RFs& aFs,const TDesC& aPath,TFileName& aName,TUint aFileMode,TNewFunction aFunction);

   276 //

   277 	IMPORT_C static CFileStore* FromL(RFile& aFile,TFileStoreFactoryFunction aFunction);

   278 	IMPORT_C static CFileStore* FromLC(RFile& aFile,TFileStoreFactoryFunction aFunction);

   279 	IMPORT_C static CFileStore* NewL(RFile& aFile,TNewFunction aFunction);

   280 	IMPORT_C static CFileStore* NewLC(RFile& aFile,TNewFunction aFunction);

   281 //

   282 	IMPORT_C CFileStore(RFile& aFile);

   283 	IMPORT_C CFileStore(RFileBuf& aBuf,const TUidType& aType);

   284 	IMPORT_C void Destruct();

   285 //

   286 	inline TStreamExchange& Host() const;

   287 	inline TBool IsHost(const MStreamBuf* aBuf) const;

   288 	IMPORT_C void SynchL();

   289 	inline void SetSizeL(TInt aSize);

   290 	IMPORT_C void ChangedL();

   291 	IMPORT_C void RefreshL();

   292 //

   293 	IMPORT_C void DoCommitL();

   294 	IMPORT_C void DoRevertL();

   295 private:

   296 	virtual void ExternalizeL(RWriteStream& aStream) const=0;

   297 	virtual void InternalizeL(RReadStream& aStream)=0;

   298 //

   299 	static CFileStore* DoNewL(RFile& aFile,TNewFunction aFunction);

   300 private:

   301 	RFileBuf iBuf;

   302 	TUidType iType;

   303 	__MUTABLE TStreamExchange iHost;

   304 	};

   305 const TInt KFileStoreStartOffset=sizeof(TCheckedUid);

   306 #if defined(__NO_CLASS_CONSTS__)

   307 #define KFileStoreStart TStreamPos(KFileStoreStartOffset)

   308 #else

   309 const TStreamPos KFileStoreStart=TStreamPos(KFileStoreStartOffset);

   310 #endif

   312 /**

   313  * @publishedAll

   314  * @released

   315  * Direct file store.

   317 A direct file store implements a subset of the operations defined by the store

   318 abstract framework. Direct file stores allow streams to be created and objects

   319 externalised to them however once the streams have been committed and

   320 closed, they cannot subsequently be changed, i.e. streams cannot be replaced,

   321 deleted, extended or changed in any way.

   322 */

   323 class CDirectFileStore : public CFileStore

   324 	{

   325 public:

   326 	inline static CDirectFileStore* OpenL(RFs& aFs,const TDesC& aName,TUint aFileMode);

   327 	inline static CDirectFileStore* OpenLC(RFs& aFs,const TDesC& aName,TUint aFileMode);

   328 	inline static CDirectFileStore* CreateL(RFs& aFs,const TDesC& aName,TUint aFileMode);

   329 	inline static CDirectFileStore* CreateLC(RFs& aFs,const TDesC& aName,TUint aFileMode);

   330 	inline static CDirectFileStore* ReplaceL(RFs& aFs,const TDesC& aName,TUint aFileMode);

   331 	inline static CDirectFileStore* ReplaceLC(RFs& aFs,const TDesC& aName,TUint aFileMode);

   332 	inline static CDirectFileStore* TempL(RFs& aFs,const TDesC& aPath,TFileName& aName,TUint aFileMode);

   333 	inline static CDirectFileStore* TempLC(RFs& aFs,const TDesC& aPath,TFileName& aName,TUint aFileMode);

   334 //

   335 	inline static CDirectFileStore* FromL(RFile& aFile);

   336 	inline static CDirectFileStore* FromLC(RFile& aFile);

   337 	inline static CDirectFileStore* NewL(RFile& aFile);

   338 	inline static CDirectFileStore* NewLC(RFile& aFile);

   339 //

   340 	IMPORT_C TUid Layout() const;

   341 //

   342 	IMPORT_C CDirectFileStore(RFile& aFile);

   343 	IMPORT_C CDirectFileStore(RFileBuf& aBuf,const TUidType& aType);

   344 protected:

   345 	IMPORT_C MStreamBuf* DoReadL(TStreamId anId) const;

   346 	IMPORT_C MStreamBuf* DoCreateL(TStreamId& anId);

   347 private:

   348 	IMPORT_C void ExternalizeL(RWriteStream& aStream) const;

   349 	IMPORT_C void InternalizeL(RReadStream& aStream);

   350 	IMPORT_C void DoSetRootL(TStreamId anId);

   351 //

   352 	IMPORT_C static CFileStore* DoNewL(RFile& aFile);

   353 	};

   354 //

   355 class CPermanentStoreCoord;

   357 /**

   358  * @publishedAll

   359  * @released

   360  * Permanent file store.

   362 This type of store supports full manipulation of store contents. Existing

   363 streams within this type of store can be changed.

   364  */

   365 class CPermanentFileStore : public CFileStore

   366 	{

   367 	friend class RPermanentFileStoreIter;

   368 public:

   369 	inline static CPermanentFileStore* OpenL(RFs& aFs,const TDesC& aName,TUint aFileMode);

   370 	inline static CPermanentFileStore* OpenLC(RFs& aFs,const TDesC& aName,TUint aFileMode);

   371 	inline static CPermanentFileStore* CreateL(RFs& aFs,const TDesC& aName,TUint aFileMode);

   372 	inline static CPermanentFileStore* CreateLC(RFs& aFs,const TDesC& aName,TUint aFileMode);

   373 	inline static CPermanentFileStore* ReplaceL(RFs& aFs,const TDesC& aName,TUint aFileMode);

   374 	inline static CPermanentFileStore* ReplaceLC(RFs& aFs,const TDesC& aName,TUint aFileMode);

   375 	inline static CPermanentFileStore* TempL(RFs& aFs,const TDesC& aPath,TFileName& aName,TUint aFileMode);

   376 	inline static CPermanentFileStore* TempLC(RFs& aFs,const TDesC& aPath,TFileName& aName,TUint aFileMode);

   377 //

   378 	inline static CPermanentFileStore* FromL(RFile& aFile);

   379 	inline static CPermanentFileStore* FromLC(RFile& aFile);

   380 	inline static CPermanentFileStore* NewL(RFile& aFile);

   381 	inline static CPermanentFileStore* NewLC(RFile& aFile);

   382 //

   383 	IMPORT_C TUid Layout() const;

   384 //

   385 	IMPORT_C CPermanentFileStore(RFile& aFile);

   386 	IMPORT_C CPermanentFileStore(RFileBuf& aBuf,const TUidType& aType);

   387 	IMPORT_C void MarshalL();

   388 	IMPORT_C ~CPermanentFileStore();

   389 protected:

   390 	IMPORT_C MStreamBuf* DoReadL(TStreamId anId) const;

   391 	IMPORT_C MStreamBuf* DoCreateL(TStreamId& anId);

   392 	IMPORT_C MStreamBuf* DoWriteL(TStreamId anId);

   393 	IMPORT_C MStreamBuf* DoReplaceL(TStreamId anId);

   394 private:

   395 	IMPORT_C void ExternalizeL(RWriteStream& aStream) const;

   396 	IMPORT_C void InternalizeL(RReadStream& aStream);

   397 	IMPORT_C void DoSetRootL(TStreamId anId);

   398 	IMPORT_C TStreamId DoExtendL();

   399 	IMPORT_C void DoDeleteL(TStreamId anId);

   400 	IMPORT_C void DoCommitL();

   401 	IMPORT_C void DoRevertL();

   402 	IMPORT_C MIncrementalCollector* DoReclaimL();

   403 	IMPORT_C MIncrementalCollector* DoCompactL();

   404 //

   405 	inline CPermanentStoreCoord& Coord() const;

   406 	CPermanentStoreCoord& CoordL() const;

   407 	CPermanentStoreCoord& TrimL();

   408 //

   409 	IMPORT_C static CFileStore* DoNewL(RFile& aFile);

   410 private:

   411 	__MUTABLE CPermanentStoreCoord* iCoord;

   412 	};

   414 /**

   415  * @publishedAll

   416  * @released

   417  * File based dictionary store.

   419 A dictionary store is a store where a stream is accessed by UID, rather than

   420 directly by stream ID. A dictionary store contains streams in the usual way

   421 but, in addition, the root stream is a stream dictionary, i.e. a CStreamDictionary

   422 type.

   423 */

   424 class CDictionaryFileStore : public CDictionaryStore

   425 	{

   426 public:

   427 	IMPORT_C static CDictionaryFileStore* SystemL(RFs& aFs);

   428 	IMPORT_C static CDictionaryFileStore* SystemLC(RFs& aFs);

   429 	IMPORT_C static CDictionaryFileStore* OpenL(RFs& aFs,const TDesC& aName,TUid aUid3);

   430 	IMPORT_C static CDictionaryFileStore* OpenLC(RFs& aFs,const TDesC& aName,TUid aUid3);

   431 private:

   432 	void ConstructL(RFs& aFs,const TDesC& aName,TUid aUid3);

   433 	void CreateStoreL(RFile& aFile,const TUidType& aType);

   434 	};

   436 /**

   437  * @publishedAll

   438  * @released

   439  * Uses a file directly to implement the page pool interface MPagePool.

   441 The pages are written sequentially through the file. You should call Close()

   442 to release the file resource after CreateL(), OpenL(), ReplaceL() or Temp().

   444 A file page pool uses a cache to store pages in-memory and to cache frequently

   445 accessed pages. You should provide a cache object (CPageCache) to the pool

   446 for this purpose.

   448 @see CPageCache

   449 @see RFile

   450 */

   451 class RFilePagePool : public TCachePagePool

   452 	{

   453 public:

   454 	IMPORT_C RFilePagePool();

   455 	IMPORT_C RFilePagePool(CPageCache& aCache);

   456 //

   457 	inline TInt Open(RFs& aFs,const TDesC& aName,TUint aFileMode);

   458 	inline TInt Create(RFs& aFs,const TDesC& aName,TUint aFileMode);

   459 	inline TInt Replace(RFs& aFs,const TDesC& aName,TUint aFileMode);

   460 	inline TInt Temp(RFs& aFs,const TDesC& aPath,TFileName& aName,TUint aFileMode);

   461 	inline void Attach(RFile& aFile);

   462 	IMPORT_C void Close();

   463 	IMPORT_C void Release();

   464 	IMPORT_C TInt Flush();

   465 	IMPORT_C void FlushL();

   466 	inline void Detach();

   467 //

   468 	inline RFile& File() const;

   469 protected:

   470 	IMPORT_C TPageRef ExtendL(const TAny* aPage,TPageReclamation aReclamation);

   471 	IMPORT_C void WriteL(TPageRef aRef,const TAny* aPage,TPageChange aChange);

   472 	IMPORT_C void ReadL(TPageRef aRef,TAny* aPage);

   473 private:

   474 	__MUTABLE RFile iFile;

   475 	};

   477 #include <s32file.inl>

   478 #endif

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--