// Copyright (c) 1995-2009 Nokia Corporation and/or its subsidiary(-ies).

 // All rights reserved.

 // This component and the accompanying materials are made available

 // under the terms of the License "Symbian Foundation License v1.0" to Symbian Foundation members and "Symbian Foundation End User License Agreement v1.0" to non-members

 // which accompanies this distribution, and is available

 // at the URL "http://www.symbianfoundation.org/legal/licencesv10.html".

 //

 // Initial Contributors:

 // Nokia Corporation - initial contribution.

 //

 // Contributors:

 //

 // Description:

 //

 /**

  @file

  @publishedAll

  @released

 */

 #if !defined(__F32FILE_H__)

 #define __F32FILE_H__

 #if !defined(__E32BASE_H__)

 #include <e32base.h>

 #endif

 #if !defined(__E32SVR_H__)

 #include <e32svr.h>

 #endif

 #include <e32ldr.h>

 /**

 @publishedAll

 @released

 The session default drive.

 */

 const TInt KDefaultDrive=KMaxTInt;

 /**

 @publishedAll

 @released

 Indicates a drive letter which is not in use. 

 This is useful when scanning a drive list to find which drives are available.

 */

 const TInt KDriveAbsent=0x00;

 /**

 @publishedAll

 @released

 The default value for the number of message slots passed to RFs::Connect().

 @see RFs::Connect

 */

 const TInt KFileServerDefaultMessageSlots=-1;

 /**

 @publishedAll

 @released

 The size of the array of TEntry items contained in a TEntryArray object.

 @see TEntryArray

 @see TEntry

 */

 const TInt KEntryArraySize=(0x200*sizeof(TText));

 /**

 @publishedAll

 @released

 The character used to separate directories in the path name.

 */

 const TInt KPathDelimiter='\\';

 /**

 @publishedAll

 @released

 The character used to separate the drive letter from the path.

 */

 const TInt KDriveDelimiter=':';

 /**

 @publishedAll

 @released

 The character used to separate the filename from the extension.

 */

 const TInt KExtDelimiter='.';

 /**

 @publishedAll

 @released

 The maximum number of available drives.

 */

 const TInt KMaxDrives=26;

 /**

 @publishedAll

 @released

 Defines a modifiable buffer descriptor to contain a drive list.

 The descriptor has maximum length KMaxDrives, sufficient to contain

 all possible drive letters.

 @see RFs::DriveList

 @see KMaxDrives

 */

 typedef TBuf8<KMaxDrives> TDriveList;

 /**

 @publishedAll

 @released

 The maximum length of a drivename.

 Sufficient for a drive letter and colon.

 */

 const TInt KMaxDriveName=0x02;

 /**

 @publishedAll

 @released

 Defines a modifiable buffer descriptor to contain a drive name.

 A drive name comprises a drive letter (A through Z) and a colon.

 KMaxDriveName (2 bytes) is sufficient for a drive letter and colon.

 @see TDriveUnit::Name

 @see KMaxDriveName

 */

 typedef TBuf<KMaxDriveName> TDriveName;

 /**

 @publishedAll

 @released

 The maximum length of a file system name or file system sub type name.

 32 characters is sufficient for a file system or sub type name.

 */

 const TInt KMaxFSNameLength=0x0020;

 /**

 @publishedAll

 @released

 Defines a modifiable buffer descriptor to contain a file system or file system sub type name.

 @see KMaxFSNameLength

 */

 typedef TBuf<KMaxFSNameLength> TFSName;

 /**

 @publishedAll

 @released

 File/directory attribute: any file without the hidden or system attribute.

 */

 const TUint KEntryAttNormal=0x0000;

 /**

 @publishedAll

 @released

 File/directory attribute: read-only file or directory.

 */

 const TUint KEntryAttReadOnly=0x0001;

 /**

 @publishedAll

 @released

 File/directory attribute: hidden file or directory.

 */

 const TUint KEntryAttHidden=0x0002;

 /**

 @publishedAll

 @released

 File/directory attribute: system file.

 */

 const TUint KEntryAttSystem=0x0004;

 /**

 @publishedAll

 @released

 File/directory attribute: volume name directory.

 */

 const TUint KEntryAttVolume=0x0008;

 /**

 @publishedAll

 @released

 File/directory attribute: a directory without the hidden or system attribute.

 */

 const TUint KEntryAttDir=0x0010;

 /**

 @publishedAll

 @released

 File/directory attribute: an archive file.

 */

 const TUint KEntryAttArchive=0x0020;

 /**

 @publishedAll

 @released

 File/directory attribute: ROM eXecute In Place file

 */

 const TUint KEntryAttXIP=0x0080;

 /**

 @publishedAll

 @released

 This file attribute bit is set if the file exists only on a remote file 

 system and is not locally cached.

 Due to the potential high-latency of remote file systems, applications 

 (or users of applications) may make use of this bit to modify their 

 behaviour when working with remote files.

 This is a read-only attribute, so any attempt to set this attribute will

 will be ignored.

 */

 const TUint KEntryAttRemote=0x0100;

 /**

 @publishedAll

 @released

 The range of entry attributes reserved for file-system specific meanings.

 File systems may assign meaning to these bits, but their definition will

 not be supported nor maintained by Symbian.

 All other file attribute bits are reserved for use by Symbian.

 The following table summarises the assignment of attribute bits:

 	 0 - KEntryAttReadOnly

 	 1 - KEntryAttHidden

 	 2 - KEntryAttSystem

 	 3 - KEntryAttVolume

 	 4 - KEntryAttDir

 	 6 - KEntryAttArchive

 	 7 - KEntryAttXIP

 	 8 - KEntryAttRemote

 	 9 - Reserved

 	10 - Reserved

 	11 - Reserved

 	12 - Reserved

 	13 - Reserved

 	14 - Reserved

 	15 - Reserved

 	16 - File System Specific

 	17 - File System Specific

 	18 - File System Specific

 	19 - File System Specific

 	20 - File System Specific

 	22 - File System Specific

 	22 - File System Specific

 	23 - File System Specific

 	24 - Reserved

 	25 - Reserved

 	26 - Reserved

 	27 - KEntryAttMatchExclude

 	28 - KEntryAttAllowUid

 	29 - Reserved

 	30 - KEntryAttMatchExclusive

 	31 - Reserved

 */

 const TUint KEntryAttMaskFileSystemSpecific=0x00FF0000;

 /**

 @publishedAll

 @released

 Bit mask for matching file and directory entries.

 This mask ensures that directories and hidden and

 system files are matched.

 (Note that KEntryAttNormal matches all entry types except directories, hidden

 and system entries).

 @see RFs::GetDir

 */

 const TUint KEntryAttMatchMask=(KEntryAttHidden|KEntryAttSystem|KEntryAttDir);

 /**

 @publishedAll

 @released

 Bit mask for matching file and directory entries.

 This is used when all entry types, including hidden and system files,

 but excluding the volume entry are to be matched.

 @see RFs::GetDir

 */

 const TUint KEntryAttMaskSupported=0x3f;

 /**

 @publishedAll

 @released

 Bit mask for matching file and directory entries.

 This is used for exclusive matching. When OR'ed with one or more file attribute

 constants, for example, KEntryAttNormal, it ensures that only the files with

 those attributes are matched.

 When OR’ed with KEntryAttDir, directories only (not hidden or system) are matched.

 @see KEntryAttDir

 @see KEntryAttNormal

 @see RFs::GetDir

 */

 const TUint KEntryAttMatchExclusive=0x40000000;

 /**

 @publishedAll

 @released

 Bit mask for feature manager file entries.

 It is used in order to identify each ROM feature set data file 

 uniquely in the mount order of ROM sections.

 */

 const TUint KEntryAttUnique=0x01000000;

 /**

 @publishedAll

 @released

 Bit mask for matching file and directory entries.

 It is used to exclude files or directories with certain attributes from

 directory listings. This bitmask has the opposite effect

 to KEntryAttMatchExclusive. For example:

 @code

 KEntryAttMatchExclude|KEntryAttReadOnly

 @endcode

 excludes all read only entries from the directory listing.

 @code

 KEntryAttMatchExclusive|KEntryAttReadOnly

 @endcode

 lists only read only entries.

 @see KEntryAttMatchExclusive

 @see RFs::GetDir

 */

 const TUint KEntryAttMatchExclude=0x08000000;

 /**

 @publishedAll

 @released

 Bit mask for matching file and directory entries.

 Bit mask flag used when UID information should be included in the directory

 entry listing.

 @see RFs::GetDir

 */

 const TUint KEntryAttAllowUid=0x10000000;

 /**

 @publishedPartner

 @released

 Bit mask used when evaluating whether or not a session gets notified of a 

 debug event.

 @see DebugNotifySessions

 */

 const TUint KDebugNotifyMask=0xFF000000; // Reserved for debug notification

 /**

 */

 const TUint KMaxMapsPerCall = 0x8;

 /** 

 @publishedPartner 

 @released 

 The default blocksize value.

 This value is returned when you query the blocksize for a media type that does not 

 support the concept of 'block' (e.g. NOR flash media).

 @see TVolumeIOParamInfo 

 */

 const TUint KDefaultVolumeBlockSize = 512;

 enum TNotifyType

 /**

 @publishedAll

 @released

 A set of change notification flags.

 These flags indicate the kind of change that should result in notification.

 This is useful for programs that maintain displays of file lists that

 must be dynamically updated.

 @see RFs::NotifyChange

 @see RFs

 @see RFile

 @see RRawDisk

 */

 	{

 	/**

 	Any change, including mounting and unmounting drives.

 	*/

 	ENotifyAll=0x01,

 	/**

 	Addition or deletion of a directory entry, or changing or formatting a disk.

 	*/

 	ENotifyEntry=0x02,

 	/**

 	Change resulting from file requests:

 	RFile::Create(), RFile::Replace(), RFile::Rename(), RFs::Delete(),

 	RFs::Replace(), and RFs::Rename().

 	*/

 	ENotifyFile=0x04,

 	/**

 	Change resulting from directory requests:

 	RFs::MkDir(), RFs::RmDir(), and RFs::Rename().

 	*/

 	ENotifyDir=0x08,

 	/**

 	Change resulting from: RFs::SetEntry(), RFile::Set(), RFile::SetAtt(),

 	RFile::SetModified() and RFile::SetSize() requests.

 	*/

 	ENotifyAttributes=0x10,

 	/**

 	Change resulting from the RFile::Write() request.

 	*/

 	ENotifyWrite=0x20,

 	/**

 	Change resulting from the RRawDisk::Write() request.

 	*/

 	ENotifyDisk=0x40

 	};

 enum TNotifyDismountMode

 /**

 @publishedAll

 @released

 Notification modes for safe media removal notification API

 @see RFs::NotifyDismount

 */

 	{

 	/**

 	Used by a client to register for notification of pending dismount.

 		- This is the default behaviour for RFs::NotifyDismount

 	*/

 	EFsDismountRegisterClient=0x01,

 	/**

 	Used to notify clients of a pending dismount.

 	*/

 	EFsDismountNotifyClients=0x02,

 	/**

 	Used to forcibly dismount the file system without notifying clients.

 	*/

 	EFsDismountForceDismount=0x03,

 	};

 enum TFileCacheFlags

 /**

 @publishedPartner

 @released

 Flags used to enable file server drive-specific caching 

 */

 	{

 	/**

 	Enable read caching - if file explicitly opened in EFileReadBuffered mode

 	*/

 	EFileCacheReadEnabled = 0x01,

 	/**

 	Enable read caching for all files, regardless of file open mode

 	*/

 	EFileCacheReadOn = 0x02,

 	/**

 	Enable read-ahead caching - if file explicitly opened in EFileReadAheadOn mode

 	*/

 	EFileCacheReadAheadEnabled = 0x04,	

 	/**

 	Enable read-ahead caching, regardless of file open mode

 	*/

 	EFileCacheReadAheadOn = 0x08,	

 	/**

 	Enable write caching, if file explicitly opened in EFileWriteBuffered mode

 	*/

 	EFileCacheWriteEnabled = 0x10,	

 	/**

 	Enable write caching for all files, regardless of file open mode

 	*/

 	EFileCacheWriteOn = 0x20,	

 	};

 enum TStartupConfigurationCmd

 /**

 @publishedPartner

 @released

 Command used to set file server configuration at startup.

 @see RFs::SetStartupConfiguration()

 */

     {

     /**

     Set loader thread priority

     */

     ELoaderPriority,

     /**

     Set TDrive flags. Value should be ETrue or EFalse

     */

     ESetRugged,

     /**

     Command upper boundary

     */

     EMaxStartupConfigurationCmd

     };

 /**

 @publishedPartner

 @released

 Commands to query specific volume information.

 @see TVolumeIOParamInfo

 */

 enum TQueryVolumeInfoExtCmd

 	{

 	/**

     Queries the sub type of the file system mounted on a specified volume.

     For example, FAT12, FAT16 or FAT32.

     */

     EFileSystemSubType,

     /**

     Queries the I/O parameters of a specificed volume.

     This includes the block size, the cluster size and the recommended read and write sizes for the media.    

     */

     EIOParamInfo,

     /** 

     This command determines whether the volume is synchronous or asynchronous.

     A boolean value is returned within the buffer defined as TPckgBuf<TBool>. 

     ETrue for Synchronous and EFalse for Asynchronous.

     */

     EIsDriveSync,

     /**

     Query if the given drive is finalised. See RFs::FinaliseDrive() 

     Not all file systems may support this query.

     A boolean value is returned within the buffer defined as TPckgBuf<TBool>. 

     ETrue value means that the drive is finalised

     */

     EIsDriveFinalised,

 	};

 /**

 @publishedAll

 @released

 Volume IO parameter information.

 This class is used to return IO parameter information for a specified volume.

 The volume parameter information holds recommended buffer sizes for the creation of efficient buffers for

 reading and writing.

 @see RFs::VolumeIOParam()

 */

 class TVolumeIOParamInfo

 	{

 public:

 	/**

 	The size of a block in bytes.

 	Reads and writes that are aligned on block boundaries are up to twice as fast as when 

 	mis-aligned.	

 	Read and write operations on certain underlying media is done in blocks.

 	A write operation that modifies only part of a block is less efficient, in general, than

 	one that modifies an entire block. Data throughput degrades linearly for reads and writes in smaller

 	sized units. 

 	*/

 	TInt iBlockSize;

 	/**

 	The size in bytes of a single disk cluster.

 	Read and write operations that are aligned on cluster boundaries are more efficient.

 	The file system organises and allocates the file data on the disk in clusters where each cluster is

 	one or more blocks. Files that are not zero length occupy at least one cluster of the disk, 

 	so large numbers of very small files use up more disk space than expected. 

 	*/

 	TInt iClusterSize;

 	/**

 	The recommended buffer size for optimised reading performance. 

 	The given buffer size is based on sensible benchmark testing results produced by the mobile device vendor.

 	The buffer size is then added to the estart.txt file

 	The figure is included in the estart.txt file along with the drive number and the variable name. 

 	The example below shows the required format:

 	[DriveC]

 	RecReadBufSize 8192

 	When no value is provided, value KErrNotSupported is returned.

 	*/

 	TInt iRecReadBufSize;

 	/**

 	The recommended buffer size for optimised writing performance. 

 	The given buffer size is based on sensible benchmark testing results produced by the mobile device vendor.

 	The buffer size is then added to the estart.txt file

 	The figure is included in the estart.txt file along with the drive number and the variable name. 

 	The example below shows the required format:

 	[DriveC]

 	RecWriteBufSize 16384

 	When no value is provided, value KErrNotSupported is returned.

 	*/

 	TInt iRecWriteBufSize;

 private:

 	/*

 	Reserved space for future use

 	*/

 	TInt iReserved[4];

 	};

 enum TDriveNumber

 /**

 @publishedAll

 @released

 The drive number enumeration.

 */

 	{

 	EDriveA,   EDriveB,   EDriveC,   EDriveD,   EDriveE,

 	EDriveF,   EDriveG,   EDriveH,   EDriveI,   EDriveJ,

 	EDriveK,   EDriveL,   EDriveM,   EDriveN,   EDriveO, 

 	EDriveP,   EDriveQ,   EDriveR,   EDriveS,   EDriveT,

 	EDriveU,   EDriveV,   EDriveW,   EDriveX,   EDriveY,

 	EDriveZ

 	};

 enum TEntryKey

 /**

 @publishedAll

 @released

 Flags indicating the order in which directory entries are to be sorted.

 @see RFs::GetDir

 @see CDirScan::SetScanDataL

 @see CDir::Sort

 */

 	{

 	/**

 	The default; no sorting takes place

 	*/

 	ESortNone=0,

 	/**

 	Sort according to alphabetic order of file and directory name.

     This setting is mutually exclusive with ESortByExt, ESortBySize,

     ESortByDate and ESortByUid.

 	*/

 	ESortByName,

 	/**

 	Sort according to alphabetic order of file extension.

 	Files without an extension take precedence over files with an extension.

 	For files with the same extension or without an extension, the default is

 	to sort by name.

     This setting is mutually exclusive with ESortByName, ESortBySize,

     ESortByDate and ESortByUid.

 	*/

 	ESortByExt,

 	/**

 	Sort according to file size.

     This setting is mutually exclusive with ESortByName, ESortByExt,

     ESortByDate and ESortByUid.

 	*/

 	ESortBySize,

 	/**

 	Sort according to files' last modified time and date.

 	By default, most recent last.

     This setting is mutually exclusive with ESortByName, ESortByExt,

     ESortBySize and ESortByUid.

 	*/

 	ESortByDate,

 	/**

 	Sort according to file UID.

     This setting is mutually exclusive with ESortByName, ESortByExt,

     ESortBySize and ESortByDate.

 	*/

 	ESortByUid,

 	/**

 	Qualifies the sort order; if set, directories are listed in the order in

 	which they occur. 

 	This is the default.

     This flag is mutually exclusive with EDirsFirst and EDirslast.

 	*/

 	EDirsAnyOrder=0,

 	/**

 	Qualifies the sort order; if set, directories come before files in sort order.

     This flag is mutually exclusive with EDirsAnyOrder and EDirsLast.

 	*/

 	EDirsFirst=0x100,

 	/**

 	Qualifies the sort order; if set, files come before directories in sort order.

     This flag is mutually exclusive with EDirsAnyOrder and EDirsFirst.

 	*/

 	EDirsLast=0x200,

 	/**

 	Qualifies the sort order; files are sorted in ascending order, i.e. from A to Z.

 	This is the default behaviour.

     This flag is mutually exclusive with EDescending and EDirDescending.

 	*/

 	EAscending=0,

 	/**

 	Qualifies the sort order; files are sorted in descending order, i.e. from Z to A.

     This flag is mutually exclusive with EAscending and EDirDescending.

 	*/

 	EDescending=0x400,

 	/**

 	Qualifies the sort order; directories are sorted in descending order, i.e. from Z to A.

     This flag shall be used in combination with either EDirsFirst or EDirsLast.

     This flag is mutually exclusive with EAscending and EDescending.

 	*/

 	EDirDescending=0x800

 	};

 enum TFileMode

 /**

 @publishedAll

 @released

 Access and share modes available when opening a file.

 The access mode indicates whether the file is opened just for reading or

 for writing.

 The share mode indicates whether other RFile objects can access the

 open file, and whether this access is read only.

 Use EFileShareReadersOrWriters if a client does not care whether the file has

 been previously opened for ReadOnly or Read/Write access.

 If EFileShareReadersOrWriters is not used, then a client needs to cooperate with 

 other clients in order to open the file with the correct share mode, either

 EFileShareReadersOnly or EFileShareAny, depending on the share mode used when

 the file was originally opened.

 To open a file for reading and writing with read and write shared access, 

 use:

 @code

 _LIT(KFilename, "filename.ext");

 RFile file;

 file.Open(theFs, KFilename, EFileShareAny|EFileWrite);

 @endcode

 If another instance of RFile tries to open this file in EFileShareExclusive

 or EFileShareReadersOnly mode, access is denied. However, it can be opened

 in EFileShareAny mode or EFileShareReadersOrWriters mode.

 If a file is opened with EFileShareReadersOrWriters, and the file is opened for

 sharing by another client, then the file share mode is promoted to the new share 

 mode. When the file handle is closed then the share mode is demoted back to 

 EFileShareReadersOrWriters.

 @code

 Table of FileShare promotion rules

 ----------------------------------

 Client A					Client B							Resultant Share Mode 

 --------					--------							--------------------

 ReadersOnly					ReadersOnly						ReadersOnly

 ReadersOnly					ReadersOrWriters|EFileRead			ReadersOnly

 ReadersOnly					ReadersOrWriters|EFileWrite		INCOMPATIBLE

 ReadersOnly					Any								INCOMPATIBLE

 ReadersOrWriters|EFileRead	ReadersOnly						ReadersOnly

 ReadersOrWriters|EFileRead	ReadersOrWriters|EFileRead		ReadersOrWriters

 ReadersOrWriters|EFileRead	ReadersOrWriters|EFileWrite		ReadersOrWriters

 ReadersOrWriters|EFileRead	Any								Any

 ReadersOrWriters|EFileWrite	ReadersOnly						INCOMPATIBLE

 ReadersOrWriters|EFileWrite	ReadersOrWriters|EFileRead			ReadersOrWriters

 ReadersOrWriters|EFileWrite	ReadersOrWriters|EFileWrite		ReadersOrWriters

 ReadersOrWriters|EFileWrite	Any								Any

 Any							ReadersOnly						INCOMPATIBLE

 Any							ReadersOrWriters|EFileRead			Any

 Any							ReadersOrWriters|EFileWrite		Any

 Any							Any								Any

 @endcode

 Use the following guidance notes for selecting FileShare mode with shared RFile objects:

 EFileShareAny

 - Use this mode to request both read and write access when another client needs

 to write to the file and respective client access to the file is coordinated.

 - To open a file for non-exclusive write, use EFileShareAny | EFileWrite. 

 - It is recommended that either EFileShareAny or EFileShareAny | EFileRead are

 not used. These combinations will block users attempting to use the 

 EFileShareReadersOnly mode even if all the EFileShareAny handles do not have

 the EFileWrite bit set as the EFileRead and EFileWrite bits have no affect on 

 sharing. Use either EFileShareReadersOnly or EFileShareReadersOrWriters.

 EFileShareReadersOrWriters 

 - Use this mode when it does not matter if another file writes to the file and

 file access can not be coordinated as other clients are unknown.

 - To open a file for shared read access whilst permitting writers, use 

 EFileShareReadersOrWriters | EFileRead.

 - For write access with unrestricted share mode, 

 EFileShareReadersOrWriters | EFileWrite may be used however 

 EFilesShareAny | EFileWrite is preferred.

 EFileShareReadersOnly

 - Use this mode to get read access to the file and deny write access for any 

 other handles on this file. 

 - To open a file for shared read access whilst disallowing writers use 

 EFileShareReadersOnly.

 Files may be opened in text or binary mode. Native Symbian OS application 

 files are nearly all binary, (so they will usually be opened in binary mode).

 However, they can be opened in text mode (to support testing, and to make them

 compatible with text formats on remote systems).

 Symbian OS native text format uses CR-LF (ASCII 0x0d, 0x0a) to denote the end of

 a line. When reading, however, any combination of CR, LF, LF-CR or CR-LF is

 recognised as the end of a line. Where a remote file system uses a different

 format, it is the responsibility of the installable file system to present

 an interface for text files which conforms with this format.

 The share mode may be OR’ed with either EFileStream or EFileStreamText.

 Additionally, it may be OR’ed with either EFileRead or EFileWrite.

 */

 	{

 	/**

 	Exclusive access for the program opening the file.

 	No other program can access the file until it is closed.

     If another program is already accessing the file in any share mode, then

     an attempt to open it with an EFileShareExclusive will fail.

 	*/

 	EFileShareExclusive,

 	/**

 	Read-only sharing.

 	This means that the file may only be accessed for reading.

     A file cannot be opened using a share mode of EFileShareReadersOnly with

     an EFileWrite flag.

 	*/

 	EFileShareReadersOnly,

 	/**

 	Shared access for reading and writing.

 	This means that other programs may share access to the file for reading

 	and writing with the program which opened the file.

 	When using this mode, the program is expecting another program to be able

 	to write to the file, so is not compatible with EFileShareReadersOnly.

 	*/

 	EFileShareAny,

 	/**

 	Shared access for reading and writing.

 	This means that other programs may share access to the file for reading

 	and writing with the program which opened the file.  

 	When using this mode, the program does not care if another program has

 	the file open for read or write access.

 	*/

 	EFileShareReadersOrWriters,

 	/**

 	For files to be opened in binary mode.

 	*/

 	EFileStream=0,

 	/**

 	For files to be opened in text mode.

 	*/

 	EFileStreamText=0x100,

 	/**

 	The file may be read from but not written to.

 	*/

 	EFileRead=0,

 	/**

 	The file may be read from and written to

 	Cannot be combined with a share mode of EFileShareReadersOnly.

 	*/

 	EFileWrite=0x200,

 	/**

 	Specifies that an asynchronous read request should not be completed 

 	until all requested data becomes available.

 	Cannot be combined with the EFileShareExclusive or EFileShareReadersOnly

 	share modes as this will prohibit a writer from updating the file.

 	*/

 	EFileReadAsyncAll=0x400,

 	/**

 	Enables write buffering

 	*/

 	EFileWriteBuffered	=0x00000800,

 	/**

 	Disables write buffering

 	*/

 	EFileWriteDirectIO	=0x00001000,

 	/**

 	Enables read buffering

 	*/

 	EFileReadBuffered	=0x00002000,

 	/**

 	Disables read buffering

 	*/

 	EFileReadDirectIO	=0x00004000,

 	/**

 	Enables read ahead. 

 	*/

 	EFileReadAheadOn	=0x00008000,

 	/**

 	Disables read ahead.

 	*/

 	EFileReadAheadOff	=0x00010000

 	};

 /**

 @publishedAll

 @released

 Bit mask provided for retrieving a file's share mode.

 @see TFileMode

 */

 const TUint KFileShareMask=0xff;

 enum TFormatMode 

 /**

 @publishedAll

 @released

 The format method.

 */

 	{

 	/**

 	Indicates a high density floppy disk to be formatted.

 	*/

 	EHighDensity,

     /**

     Indicates a standard floppy disk to be formatted.

 	*/

 	ELowDensity,

 	/**

 	Performs a full format, erasing existing content and resetting the FAT

 	and root directory.

 	This is the default, and can be ORed with bit EHighDensity or ELowDensity.

 	*/

 	EFullFormat=0,

     /**

     Does the minimum required to format the device, only resetting the FAT

     and root directory.

     This is the default, and can be ORed with bit EHighDensity or ELowDensity.

 	*/

 	EQuickFormat=0x100,

 	/**

 	Indicates a custom formatting mode.

 	*/

 	ESpecialFormat=0x200,

 	/**

 	Forced erase of locked media

 	*/

 	EForceErase=0x400

 	};

 enum TSeek

 /**

 @publishedAll

 @released

 Flags indicating the destination of a seek operation.

 File locations are specified as a 32-bit signed integer,

 allowing offsets of ?GB from the origin of the seek.

 @see RFile::Seek

 */

 	{

 	/**

 	This can only be used for file systems with execute-in-place facilities,

 	such as the ROM file system: the offset specifies the absolute address of

 	the data.

 	*/

 	ESeekAddress,

 	/**

 	Destination is the start of file.

 	*/

 	ESeekStart,

 	/**

 	Destination is the current position in file.

 	*/

 	ESeekCurrent,

 	/**

 	Destination is the end of file.

 	*/

 	ESeekEnd

 	};

 /**

 */

 class TBlockMapEntry : public TBlockMapEntryBase

 	{

 public:

 	IMPORT_C TBlockMapEntry();

 	IMPORT_C void SetNumberOfBlocks( TUint aNumberOfBlocks );

 	IMPORT_C void SetStartBlock( TUint aStartBlock );

 	};

 /**

 */

 typedef TBuf8<KMaxMapsPerCall*sizeof(TBlockMapEntry)> TBlockArrayDes;

 struct SBlockMapInfo : public SBlockMapInfoBase

 	{

 	TBlockArrayDes iMap;

 	};

 /**

 */

 enum TBlockMapUsage

 	{

 	/* */

 	EBlockMapUsagePaging,

 	/* */

 	ETestDebug

 	};

 class TEntry

 /**

 @publishedAll

 @released

 Encapsulates an entry in a directory, which can be another (nested) directory,

 a file or a volume label.

 Each directory entry has a name which is relative to its owning directory

 and a type, which is indicated by its unique identifier (UID).

 An entry can be interrogated for the following properties:

 1. the kind of entry: stored in the entry UIDs, stored in iType

 2. the entry attributes, stored in iAtt

 3. the size of entry

 4. the time the entry was last modified.

 @see RDir

 @see RFs::Entry

 @see RFs::SetEntry

 @see CfileBase::CurrentEntry

 */

 	{

 public:

 	IMPORT_C TEntry();

 	IMPORT_C TEntry(const TEntry& aEntry);

 	IMPORT_C TEntry& operator=(const TEntry& aEntry);

 	IMPORT_C TBool IsReadOnly() const;

 	IMPORT_C TBool IsHidden() const;

 	IMPORT_C TBool IsSystem() const;

 	IMPORT_C TBool IsDir() const;

 	IMPORT_C TBool IsArchive() const;

 	inline const TUid& operator[](TInt anIndex) const;

 	inline TBool IsUidPresent(TUid aUid) const;

 	inline TBool IsTypeValid() const;

 	inline TUid MostDerivedUid() const;

 public:

     /**

     The individual bits within this byte indicate which attributes

     have been set.

     @see KEntryAttNormal

 	@see KEntryAttReadOnly

 	@see KEntryAttHidden

     @see KEntryAttSystem

     */

 	TUint iAtt;

     /**

     The size of the file in bytes.

     For files larger that 2G it must be cast to TUint in order to avoid looking like negative signed.

     */

 	TInt iSize;

 	/**

 	The local time of last modification.

 	*/

 	TTime iModified;

 	/**

 	The file's UIDtype

 	*/

 	TUidType iType;

 	/**

 	The name of the file relative to the owning directory,

 	with a maximum of KMaxFileName characters.

 	@see KMaxFileName

 	*/

 	TBufC<KMaxFileName> iName;

 private:	

 	/**

 	Reserved for future expansion

 	*/

 	TUint32 iReserved[2];

 	};

 class RDir;

 class TEntryArray

 /**

 @publishedAll

 @released

 Array of directory entries.

 It contains the results of a call to RDir::Read(): it will contain all

 the TEntry items in the directory. Thus, a directory can be read in

 a single call, minimising client/server communication overheads.

 @see TEntry

 @see RDir::Read

 */

 	{

 public:

 	IMPORT_C TEntryArray();

 	IMPORT_C TInt Count() const;

 	IMPORT_C const TEntry& operator[](TInt anIndex) const;

 private:

 	TInt iCount;

 	TInt iIndex;

 	const TEntry* iPos;

 	TBuf8<KEntryArraySize> iBuf;

 	friend class RDir;

 	friend class RFs;

 	};

 class TDriveInfo

 /**

 @publishedAll

 @released

 Contains drive information.

 @see RFs::Drive

 */

 	{

 public:

     /**

     The type of media mounted on the drive.

     */

 	TMediaType iType;

     /**

     Indicates whether the drive supports a battery, and if so, its state.

     */

     TBatteryState iBattery;

     /**

     The drive attributes.

     @see KDriveAttLocal

     @see KDriveAttRom

     @see KDriveAttRedirected

     @see KDriveAttSubsted

     @see KDriveAttInternal

     @see KDriveAttRemovable

     */

 	TUint iDriveAtt;

     /**

     The attributes of the media mounted on the drive.

     @see KMediaAttVariableSize

     @see KMediaAttDualDensity

     @see KMediaAttFormattable

     @see KMediaAttWriteProtected

     @see KMediaAttLockable

     @see KMediaAttLocked

     */

 	TUint iMediaAtt;

 private:	

 	/**

 	Reserved for future expansion

 	*/

 	TUint32 iReserved;	

 	};

 class TVolumeInfo

 /**

 @publishedAll

 @released

 Contains information about a volume mounted on a drive. Use RFs::Drive() if only 

 the drive information is required. 

 If a drive supports removable media it may contain different volumes over time.

 Volume information is made up of information concerning the drive on which it is mounted, 

 which can also be accessed through RFs::Drive(), and the volume information, this is made 

 up of the size of the volume, the free space, its unique identifying number and a name.

 TVolumeInfo is initialised by RFs::Volume().

 @see RFs::Volume()

 @see RFs::Drive()

 */

 	{

 public:

 	IMPORT_C TVolumeInfo();

 	/**

 	Information about the drive on which the volume is mounted.

 	@see TDriveInfo

 	*/

 	TDriveInfo iDrive;

 	/**

 	The volume’s unique identifying number.

 	*/

 	TUint iUniqueID;

 	/**

 	The maximum size of the volume in bytes. The current amount of memory

 	in use plus the amount of free memory.

 	*/

 	TInt64 iSize;

 	/**

 	The amount of free space on the volume in bytes.

 	*/

 	TInt64 iFree;

 	/**

 	Name of the volume, with a maximum of KMaxFileName characters.

 	This field is optional.

     @see KMaxFileName

 	*/

 	TBufC<KMaxFileName> iName;

 	/** 

 	Flags which define the default file-caching behaviour for this volume

 	@see TFileCacheFlags

 	*/

 	TFileCacheFlags iFileCacheFlags;

     /**

     @prototype

     @internalTechnology

     Internal flag, used in the case of non-blocking getting volume information. 

     @see RFs::Volume(TVolumeInfo& aVol,TInt aDrive, TRequestStatus& aStat)

     If this flag is set, it means that the volume information will be obtained

     asynchronously. More specific, on return iFree will reflect the _current_ amount of free space on volume at the moment of 

     RFs::Volume() call, not the exact final value. This is because in this case getting volume information will be asynchronous, 

     and the client will not be suspended until the mount finish calculating free space. At present appicable to FAT32 file system only.

     */

     TUint8 iVolSizeAsync : 1;

 private:	

 	/**

 	Reserved for future expansion

 	*/

     TUint8  i8Reserved1;	

     TUint16 i16Reserved1;	

     TUint32 i32Reserved1;	

     TUint32 i32Reserved2;	

 	};

 class TDriveUnit

 /**

 @publishedAll

 @released

 Drive numbers and letters.

 A drive may be represented by either an integer between zero and twenty five

 inclusive, or by a buffer descriptor containing a character between "A" and "Z"

 inclusive, followed by a colon.

 This class encapsulates both representations.

 An instance of this class is constructed specifying either the drive number

 or the drive letter and may be converted between the two representations.

 */

 	{

 public:

 	inline TDriveUnit() {};

 	IMPORT_C TDriveUnit(TInt aDrive);

 	IMPORT_C TDriveUnit(const TDesC& aDrive);

 	IMPORT_C TDriveUnit& operator=(TInt aDrive);

 	IMPORT_C TDriveUnit& operator=(const TDesC& aDrive);

 	inline operator TInt() const;

 	IMPORT_C TDriveName Name() const;

 private:

 	TInt iDrive;

 	};

 class RFs;

 //

 class TParseBase

 /**

 @publishedAll

 @released

 Base class for file name parsing.

 You first need to set up the path to be parsed using either a TParse, TParsePtr

 or TParsePtrC object.

 The interrogation and extraction functions in this class allow you to test

 whether a component has been specified in the pathname, and if so,

 to extract it. If a component is not present in the pathname,

 the extraction function returns an empty string.

 This class also allows directories to be added to, and popped from the path.

 Notes:

 1. the filename modification functions cannot be used by the TParsePtrC class.

 2. navigation using .. and . is not supported.

 @see TParse

 @see TParsePtr

 @see TParsePtrC

 */

 	{

 private:

 	struct SField {TUint8 pos;TUint8 len;TUint8 present;TUint8 filler;};

 	enum TField {EDrive,EPath,EName,EExt,EMaxFields};

 	enum TWild {EWildName=0x01,EWildExt=0x02,EWildEither=0x04,EIsRoot=0x08,EWildIsKMatchOne=0x10,EWildIsKMatchAny=0x20};

 public:

 	IMPORT_C TParseBase();

 	IMPORT_C TInt PopDir();

 	IMPORT_C TInt AddDir(const TDesC& aName);

 	IMPORT_C const TDesC& FullName() const;

 	IMPORT_C TPtrC Drive() const;

 	IMPORT_C TPtrC Path() const;

 	IMPORT_C TPtrC DriveAndPath() const;

 	IMPORT_C TPtrC Name() const;

 	IMPORT_C TPtrC Ext() const;

 	IMPORT_C TPtrC NameAndExt() const;

 	IMPORT_C TBool DrivePresent() const;

 	IMPORT_C TBool PathPresent() const;

 	IMPORT_C TBool NamePresent() const;

 	IMPORT_C TBool ExtPresent() const;

 	IMPORT_C TBool NameOrExtPresent() const;

 	IMPORT_C TBool IsRoot() const;

 	IMPORT_C TBool IsWild() const;

 	IMPORT_C TBool IsKMatchOne() const;

 	IMPORT_C TBool IsKMatchAny() const;

 	IMPORT_C TBool IsNameWild() const;

 	IMPORT_C TBool IsExtWild() const;

 protected:

 	virtual TDes& NameBuf() = 0;                // Reference to derived class descriptor containing the filename.

 	virtual const TDesC& NameBufC() const = 0;  // const reference to derived class descriptor containing the filename.

 	TInt Set(const TDesC* aName,const TDesC* aRelated,const TDesC* aDefault,TBool allowWild);

 private:

 	TInt ParseDrive(TLex& aName,TBool& aDone);

 	TInt ParsePath(TLex& aName,TBool& aDone);

 	TInt ParseName(TLex& aName,TBool& aDone);

 	TInt ParseExt(TLex& aName,TBool& aDone);

 protected:

 	TInt16 iMod;        // Non-zero indicates File name modification functionality is enabled.

 private:

 	TInt16 iWild;

 	SField iField[EMaxFields];

 	};

 class TParsePtr : public TParseBase

 /**

 @publishedAll

 @released

 Parses filenames using less space on the stack than TParse.

 Stores a reference to a filename, unlike TParse, which uses

 a 512 byte TFileName object as an internal buffer to store

 a copy of the filename.

 The filename's components (drive, path, etc.) can be retrieved using

 the functions provided by the base class, TParseBase.

 This class should be used in preference to TParse when minimising stack

 usage is a priority.

 @see TParse

 @see TFileName

 */

 	{

 public:

 	IMPORT_C TParsePtr(TDes& aName);

 protected:

 	IMPORT_C TDes& NameBuf();

 	IMPORT_C const TDesC& NameBufC() const;

 private:

 	TPtr iNameBuf;

 	};

 class TParsePtrC : public TParseBase

 /**

 @publishedAll

 @released

 Parses, but cannot modify, filenames using less space on the stack than TParse.

 Stores a reference to a filename, unlike TParse, which uses

 a 512 byte TFileName object as an internal buffer to store

 a copy of the filename.

 The filename's components (drive, path, etc.) can be retrieved using

 the functions provided by the base class, TParseBase. 

 Note that because the filename cannot be modified through this class,

 the base class functions PopDir() and AddDir() cannot be called, because

 a panic will be raised.

 @see TParse

 @see TFileName

 */

 	{

 public:

 	IMPORT_C TParsePtrC(const TDesC& aName);

 protected:

 	IMPORT_C TDes& NameBuf();

 	IMPORT_C const TDesC& NameBufC() const;

 private:

 	TPtrC iNameBuf;

 	};

 class TParse : public TParseBase

 /**

 @publishedAll

 @released

 Parses filenames.

 The class uses the full filename structure supported by Symbian OS.

 TParse works by using the Set() function to set up the filename to be parsed.

 Then, various getter functions defined in the base class, TParseBase, such as:

 FullName(), Drive(), Path(), DriveAndPath(), Name(), Ext() and NameAndExt()

 may be used to retrieve path components.

 There are a number of restrictions to valid path components, which are

 described in guide documentation.

 */

 	{

 public:

 	IMPORT_C TParse();

 	IMPORT_C TInt Set(const TDesC& aName,const TDesC* aRelated,const TDesC* aDefault);

 	IMPORT_C TInt SetNoWild(const TDesC& aName,const TDesC* aRelated,const TDesC* aDefault);

 protected:

 	IMPORT_C TDes& NameBuf();

 	IMPORT_C const TDesC& NameBufC() const;

 private:

 	TFileName iNameBuf;

 	};

 class CDir : public CBase

 /**

 @publishedAll

 @released

 Array of directory entries that has been read into memory from the file system.

 It can be read and sorted by user programs, but cannot be created by them. 

 */

 	{

 public:

 	IMPORT_C virtual ~CDir();

 	IMPORT_C TInt Count() const;

 	IMPORT_C const TEntry& operator[](TInt anIndex) const;

 	IMPORT_C TInt Sort(TUint aEntrySortKey);

 protected:

 	IMPORT_C CDir();

 	IMPORT_C static CDir* NewL();

 	IMPORT_C void AddL(const TEntry& anEntry);

 	IMPORT_C void ExtractL(TBool aRemove,CDir*& aDir);

 	IMPORT_C void Compress();

 protected:

 	CArrayPakFlat<TEntry>* iArray;

 	friend class RFs;

 	friend class TOpenFileScan;

 	};

 class RFs : public RSessionBase

 /**

 @publishedAll

 @released

 A handle to a file server session.

 A program or thread may have arbitrarily many sessions open simultaneously.

 Use this class for all file system manipulation, including:

 1. adding, removing, moving and renaming files and directories

 2. inspecting and changing file attributes and directory entry details.

    These include the time and date when the file or directory was last

    written to, its size and various attribute flags such as read-only,

    hidden, archive or system.                                     

 3. finding a file’s real name; if the file system on which it is stored

    has to "mangle" the name into a shorter format

 4. getting directory listings

 5. maintaining a default path; unlike some other systems, there is a single

    system default path, rather than one for each drive: the default path

    consists of a drive and a path specification.

 6. performing context-sensitive parses using TParse objects, and

    the session path

 7. obtaining information on drives and volumes

 8. formatting and labelling volumes

 9. obtaining a list of valid drives

 10. emulating the DOS subst command, which allows any directory to appear

     as if it were a separate drive

 11. requesting notification of when significant change occurs.

     This can be used for programs which maintain file lists, but must

     update those lists when change occurs.

 12. finding the version number of the file server

 13. resource counting to ensure that all resources are closed when

     the session terminates.

 This class is not intended for user derivation.

 The following restrictions apply when a path is specified:

 1. its total length must not exceed 256 characters

 2. wildcards cannot be used in the drive or in any directory name,

    although they may be allowed in the filename and extension.

 3. double backslashes are not allowed in the path. 

 4. the following characters must not be included anywhere in the path: < > " / |

 5. a colon may only be included between the drive and path

 6. no directory name or filename plus extension may consist solely

    of space characters, or of a single or double dot.

 7. spaces between the drive, if specified, and the first directory in

    the path are illegal, although there may be spaces between other

    path components, for instance between directories.

 */

 	{

 public:

 	IMPORT_C TInt Connect(TInt aMessageSlots=KFileServerDefaultMessageSlots);

 	IMPORT_C TVersion Version() const;

 	IMPORT_C TInt AddFileSystem(const TDesC& aFileName) const;

 	IMPORT_C TInt MountFileSystem(const TDesC& aFileSystemName,TInt aDrive) const;

 	IMPORT_C TInt MountFileSystem(const TDesC& aFileSystemName,TInt aDrive, TBool aIsSync) const;

 	IMPORT_C TInt MountFileSystemAndScan(const TDesC& aFileSystemName,TInt aDrive,TBool& aIsMountSuccess) const;

 	IMPORT_C TInt MountFileSystem(const TDesC& aFileSystemName,const TDesC& aExtensionName,TInt aDrive);

 	IMPORT_C TInt MountFileSystem(const TDesC& aFileSystemName,const TDesC& aExtensionName,TInt aDrive, TBool aIsSync);

 	IMPORT_C TInt MountFileSystemAndScan(const TDesC& aFileSystemName,const TDesC& aExtensionName,TInt aDrive,TBool& aIsMountSuccess) const;

 	IMPORT_C TInt DismountFileSystem(const TDesC& aFileSystemName,TInt aDrive) const;

 	IMPORT_C TInt RemoveFileSystem(const TDesC& aFileSystemName) const;

 	IMPORT_C TInt FileSystemName(TDes& aName,TInt aDrive) const;

 	IMPORT_C TInt AddExtension(const TDesC& aFileName);

 	IMPORT_C TInt MountExtension(const TDesC& aExtensionName,TInt aDrive);

 	IMPORT_C TInt DismountExtension(const TDesC& aExtensionName,TInt aDrive);

 	IMPORT_C TInt RemoveExtension(const TDesC& aExtensionName);

 	IMPORT_C TInt ExtensionName(TDes& aExtensionName,TInt aDrive,TInt aPos);

 	IMPORT_C TInt RemountDrive(TInt aDrive,const TDesC8* aMountInfo=NULL,TUint aFlags=0);

 	IMPORT_C void NotifyChange(TNotifyType aType,TRequestStatus& aStat);

 	IMPORT_C void NotifyChange(TNotifyType aType,TRequestStatus& aStat,const TDesC& aPathName);

 	IMPORT_C void NotifyChangeCancel();

 	IMPORT_C void NotifyChangeCancel(TRequestStatus& aStat);

 	IMPORT_C void NotifyDiskSpace(TInt64 aThreshold,TInt aDrive,TRequestStatus& aStat);

 	IMPORT_C void NotifyDiskSpaceCancel(TRequestStatus& aStat);

 	IMPORT_C void NotifyDiskSpaceCancel();

 	IMPORT_C TInt DriveList(TDriveList& aList) const;

 	IMPORT_C TInt DriveList(TDriveList& aList, TUint aFlags) const;

 	IMPORT_C TInt Drive(TDriveInfo& anInfo,TInt aDrive=KDefaultDrive) const;

 	IMPORT_C TInt Volume(TVolumeInfo& aVol,TInt aDrive=KDefaultDrive) const;

     IMPORT_C void Volume(TVolumeInfo& aVol,TInt aDrive, TRequestStatus& aStat) const;

 	IMPORT_C TInt SetVolumeLabel(const TDesC& aName,TInt aDrive=KDefaultDrive);

 	IMPORT_C TInt Subst(TDes& aPath,TInt aDrive=KDefaultDrive) const;

 	IMPORT_C TInt SetSubst(const TDesC& aPath,TInt aDrive=KDefaultDrive);

 	IMPORT_C TInt RealName(const TDesC& aName,TDes& aResult) const;

     IMPORT_C TInt GetMediaSerialNumber(TMediaSerialNumber& aSerialNum, TInt aDrive);

 	IMPORT_C TInt SessionPath(TDes& aPath) const;

 	IMPORT_C TInt SetSessionPath(const TDesC& aPath);

 	IMPORT_C TInt Parse(const TDesC& aName,TParse& aParse) const;

 	IMPORT_C TInt Parse(const TDesC& aName,const TDesC& aRelated,TParse& aParse) const;

 	IMPORT_C TInt MkDir(const TDesC& aPath);

 	IMPORT_C TInt MkDirAll(const TDesC& aPath);

 	IMPORT_C TInt RmDir(const TDesC& aPath);

 	IMPORT_C TInt GetDir(const TDesC& aName,TUint anEntryAttMask,TUint anEntrySortKey,CDir*& anEntryList) const;

 	IMPORT_C TInt GetDir(const TDesC& aName,TUint anEntryAttMask,TUint anEntrySortKey,CDir*& anEntryList,CDir*& aDirList) const;

 	IMPORT_C TInt GetDir(const TDesC& aName,const TUidType& anEntryUid,TUint anEntrySortKey,CDir*& aFileList) const;

 	IMPORT_C TInt Delete(const TDesC& aName);

 	IMPORT_C TInt Rename(const TDesC& anOldName,const TDesC& aNewName);

 	IMPORT_C TInt Replace(const TDesC& anOldName,const TDesC& aNewName);

 	IMPORT_C TInt Att(const TDesC& aName,TUint& aAttValue) const;

 	IMPORT_C TInt SetAtt(const TDesC& aName,TUint aSetAttMask,TUint aClearAttMask);

 	IMPORT_C TInt Modified(const TDesC& aName,TTime& aTime) const;

 	IMPORT_C TInt SetModified(const TDesC& aName,const TTime& aTime);

 	IMPORT_C TInt Entry(const TDesC& aName,TEntry& anEntry) const;

 	IMPORT_C TInt SetEntry(const TDesC& aName,const TTime& aTime,TUint aSetAttMask,TUint aClearAttMask);

 	IMPORT_C TInt ReadFileSection(const TDesC& aName,TInt aPos,TDes8& aDes,TInt aLength) const;

 	IMPORT_C static TBool IsValidDrive(TInt aDrive);

 	IMPORT_C static TInt CharToDrive(TChar aChar,TInt& aDrive);

 	IMPORT_C static TInt DriveToChar(TInt aDrive,TChar& aChar);

 	IMPORT_C static TBool IsRomAddress(TAny* aAny);

 	IMPORT_C static TDriveNumber GetSystemDrive();

 	IMPORT_C static TChar GetSystemDriveChar();

 	IMPORT_C TInt SetSystemDrive(TDriveNumber aSystemDrive);

 	IMPORT_C void ResourceCountMarkStart() const;

 	IMPORT_C void ResourceCountMarkEnd() const;

 	IMPORT_C TInt ResourceCount() const;

 	IMPORT_C TInt IsFileOpen(const TDesC& aFile,TBool& anAnswer) const;

 	IMPORT_C TInt CheckDisk(const TDesC& aDrive) const;

 	IMPORT_C TInt ScanDrive(const TDesC& aDrive) const;

 	IMPORT_C TInt GetShortName(const TDesC& aLongName,TDes& aShortName) const;

 	IMPORT_C TInt GetLongName(const TDesC& aShortName,TDes& aLongName) const;

 	IMPORT_C TBool GetNotifyUser();

 	IMPORT_C void SetNotifyUser(TBool aValue);

 	IMPORT_C TUint8* IsFileInRom(const TDesC& aFileName) const;

 	IMPORT_C TBool IsValidName(const TDesC& anEntryName) const;

 	IMPORT_C TBool IsValidName(const TDesC& aFileName,TText& aBadChar) const;

 	IMPORT_C TInt GetDriveName(TInt aDrive,TDes& aDriveName) const;

 	IMPORT_C TInt SetDriveName(TInt aDrive,const TDesC& aDriveName);

 	IMPORT_C TInt LoaderHeapFunction(TInt aFunction, TAny *aArg1=NULL, TAny *aArg2=NULL);

 	IMPORT_C TInt SetErrorCondition(TInt anError,TInt aCount=0);

 	IMPORT_C TInt SetDebugRegister(TInt aVal);

 	IMPORT_C TInt SetAllocFailure(TInt aAllocNum);

 	IMPORT_C void DebugNotify(TInt aDrive,TUint aNotifyType,TRequestStatus& aStat);

 	IMPORT_C TInt ControlIo(TInt aDrive,TInt aCommand);

 	IMPORT_C TInt ControlIo(TInt aDrive,TInt aCommand,TDes8& aParam1);

 	IMPORT_C TInt ControlIo(TInt aDrive,TInt aCommand,TDes8& aParam1,TDes8& aParam2);

 	IMPORT_C TInt ControlIo(TInt aDrive,TInt aCommand,TAny* aParam1,TAny* aParam2);

 	IMPORT_C TInt LockDrive(TInt aDrv, const TMediaPassword &aOld, const TMediaPassword &aNew, TBool aStr);

 	IMPORT_C TInt UnlockDrive(TInt aDrv, const TMediaPassword &Pswd, TBool aStr);

 	IMPORT_C TInt ClearPassword(TInt aDrv, const TMediaPassword &aPswd);

 	IMPORT_C TInt ErasePassword(TInt aDrv);

 	IMPORT_C TInt SetSessionToPrivate(TInt aDrive);

 	IMPORT_C TInt PrivatePath(TDes& aPath);

 	IMPORT_C TInt CreatePrivatePath(TInt aDrive);	

 	IMPORT_C void StartupInitComplete(TRequestStatus& aStat);

 	IMPORT_C TInt SetLocalDriveMapping(const TDesC8& aMapping);

 	IMPORT_C TInt FinaliseDrives();

     /** specifies drive finalisation modes */

     enum TFinaliseDrvMode

         {

         EFinal_RW,      ///< after successful finalisation the drive remains writable and will become "not finalised" after the first write operation.

         EFinal_RO,      ///< after successful finalisation the drive becomes read-only

         EForceUnfinalise///< @internalComponent  mark the drive as "not finalised" can result in KErrAbort if the dive is in inconsistent state.

         };

     IMPORT_C TInt FinaliseDrive(TInt aDriveNo, TFinaliseDrvMode aMode) const;

 	IMPORT_C TInt SwapFileSystem(const TDesC& aOldFileSystemName,const TDesC& aNewFileSystemName,TInt aDrive) const;

 	IMPORT_C TInt ReserveDriveSpace(TInt aDriveNo, TInt aSpace);

 	IMPORT_C TInt GetReserveAccess(TInt aDriveNo);

 	IMPORT_C TInt ReleaseReserveAccess(TInt aDriveNo);

 	IMPORT_C TInt AddPlugin(const TDesC& aFileName) const;

 	IMPORT_C TInt RemovePlugin(const TDesC& aPluginName) const;

 	IMPORT_C TInt PluginName(TDes& aPluginName,TInt aDrive,TInt aPos);

 	IMPORT_C TInt MountPlugin(const TDesC& aPluginName) const;

 	IMPORT_C TInt MountPlugin(const TDesC& aPluginName,TInt aDrive) const;

 	IMPORT_C TInt MountPlugin(const TDesC& aPluginName,TInt aDrive, TInt aPos) const;

 	IMPORT_C TInt DismountPlugin(const TDesC& aPluginName) const;

 	IMPORT_C TInt DismountPlugin(const TDesC& aPluginName,TInt aDrive) const;

 	IMPORT_C TInt DismountPlugin(const TDesC& aPluginName,TInt aDrive,TInt aPos) const;

 	IMPORT_C void NotifyDismount(TInt aDrive, TRequestStatus& aStat, TNotifyDismountMode aMode=EFsDismountRegisterClient) const;

 	IMPORT_C void NotifyDismountCancel(TRequestStatus& aStat) const;

 	IMPORT_C void NotifyDismountCancel() const;

 	IMPORT_C TInt AllowDismount(TInt aDrive) const;

     IMPORT_C TInt SetStartupConfiguration(TInt aCommand,TAny* aParam1,TAny* aParam2) const;

 	IMPORT_C TInt AddCompositeMount(const TDesC& aFileSystemName,TInt aLocalDriveToMount,TInt aCompositeDrive, TBool aSync) const;

 	IMPORT_C TInt SetNotifyChange(TBool aNotifyChange);

 	IMPORT_C TInt QueryVolumeInfoExt(TInt aDrive, TQueryVolumeInfoExtCmd aCommand, TDes8& aInfo) const;

 	IMPORT_C TInt VolumeIOParam(TInt aDriveNo, TVolumeIOParamInfo& aParamInfo) const;

 	IMPORT_C TInt FileSystemSubType(TInt aDriveNo, TDes& aName) const;

 	IMPORT_C TInt InitialisePropertiesFile(const TPtrC8& aPtr) const;

 	TInt Unclamp(const RFileClamp& aHandle);

 private:

 	void GetDirL(const TDesC& aMatchName,TUint anEntryAttMask,TUint anEntrySortKey,CDir*& anEntryList,CDir*& aDirList,RDir& aDir) const;

 	void GetDirL(const TDesC& aMatchName,TUint anEntryAttMask,TUint anEntrySortKey,CDir*& anEntryList,RDir& aDir) const;

 	void GetDirL(const TDesC& aMatchName,const TUidType& aUidType,TUint anEntrySortKey,CDir*& anEntryList,RDir& aDir) const;

 	void DoGetDirL(TUint anEntrySortKey,CDir*& anEntryList,RDir& aDir) const;

 	TInt GetOpenFileList(TInt& aSessionNum,TInt& aLocalPos,TThreadId& aThreadId,TEntryArray& anArray) const;

 	friend class TOpenFileScan;

 	};

 /**

 @publishedAll

 @released

 Creates and opens a file, and performs all operations on a single open file.

 These include:

 - reading from and writing to the file

 - seeking to a position within the file

 - locking and unlocking within the file

 - setting file attributes

 Before using any of these services, a connection to a file server session must

 have been made, and the file must be open.

 Opening Files:

 -  use Open() to open an existing file for reading or writing; an error is

    returned if it does not already exist.

    To open an existing file for reading only, use Open() with an access mode of

    EFileRead, and a share mode of EFileShareReadersOnly.

 -  use Create() to create and open a new file for writing; an error is returned

    if it already exists.

 -  use Replace() to open a file for writing, replacing any existing file of

    the same name if one exists, or creating a new file if one does not exist.

    Note that if a file exists, its length is reset to zero.

 -  use Temp() to create and open a temporary file with a unique name,

    for writing and reading.

 When opening a file, you must specify the file server session to use for

 operations with that file. If you do not close the file explicitly, it is

 closed when the server session associated with it is closed.

 Reading and Writing:

 There are several variants of both Read() and Write().

 The basic Read(TDes8& aDes) and Write(const TDesC8& aDes) are supplemented

 by variants allowing the descriptor length to be overridden, or the seek

 position of the first byte to be specified, or asynchronous completion,

 or any combination.

 Reading transfers data from a file to a descriptor, and writing transfers

 data from a descriptor to a file. In all cases, the file data is treated

 as binary and byte descriptors are used (TDes8, TDesC8).

 @see TDes8

 @see TDesC8

 */

 class RFile : public RSubSessionBase

 	{

 public:

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

 	IMPORT_C void Close();

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

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

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

 	IMPORT_C TInt Read(TDes8& aDes) const;

 	IMPORT_C void Read(TDes8& aDes,TRequestStatus& aStatus) const;

 	IMPORT_C TInt Read(TDes8& aDes,TInt aLength) const;

 	IMPORT_C void Read(TDes8& aDes,TInt aLength,TRequestStatus& aStatus) const;

 	IMPORT_C TInt Read(TInt aPos,TDes8& aDes) const;

 	IMPORT_C void Read(TInt aPos,TDes8& aDes,TRequestStatus& aStatus) const;

 	IMPORT_C TInt Read(TInt aPos,TDes8& aDes,TInt aLength) const;

 	IMPORT_C void Read(TInt aPos,TDes8& aDes,TInt aLength,TRequestStatus& aStatus) const;

 	IMPORT_C void ReadCancel(TRequestStatus& aStatus) const;

 	IMPORT_C void ReadCancel() const;

 	IMPORT_C TInt Write(const TDesC8& aDes);

 	IMPORT_C void Write(const TDesC8& aDes,TRequestStatus& aStatus);

 	IMPORT_C TInt Write(const TDesC8& aDes,TInt aLength);

 	IMPORT_C void Write(const TDesC8& aDes,TInt aLength,TRequestStatus& aStatus);

 	IMPORT_C TInt Write(TInt aPos,const TDesC8& aDes);

 	IMPORT_C void Write(TInt aPos,const TDesC8& aDes,TRequestStatus& aStatus);

 	IMPORT_C TInt Write(TInt aPos,const TDesC8& aDes,TInt aLength);

 	IMPORT_C void Write(TInt aPos,const TDesC8& aDes,TInt aLength,TRequestStatus& aStatus);

 	IMPORT_C TInt Lock(TInt aPos,TInt aLength) const;

 	IMPORT_C TInt UnLock(TInt aPos,TInt aLength) const;

 	IMPORT_C TInt Seek(TSeek aMode,TInt& aPos) const;

 	IMPORT_C TInt Flush();

 	IMPORT_C void Flush(TRequestStatus& aStatus);

 	IMPORT_C TInt Size(TInt& aSize) const;

 	IMPORT_C TInt SetSize(TInt aSize);

 	IMPORT_C TInt Att(TUint& aAttValue) const;

 	IMPORT_C TInt SetAtt(TUint aSetAttMask,TUint aClearAttMask);

 	IMPORT_C TInt Modified(TTime& aTime) const;

 	IMPORT_C TInt SetModified(const TTime& aTime);

 	IMPORT_C TInt Set(const TTime& aTime,TUint aSetAttMask,TUint aClearAttMask);

 	IMPORT_C TInt ChangeMode(TFileMode aNewMode);

 	IMPORT_C TInt Rename(const TDesC& aNewName);

 	IMPORT_C TInt Drive(TInt &aDriveNumber, TDriveInfo &aDriveInfo) const;

 	IMPORT_C TInt Adopt(RFs& aFs, TInt aHandle);

 	IMPORT_C TInt AdoptFromClient(const RMessage2& aMsg, TInt aFsHandleIndex, TInt aFileHandleIndex);

 	IMPORT_C TInt AdoptFromServer(TInt aFsHandle, TInt aFileHandle);

 	IMPORT_C TInt AdoptFromCreator(TInt aFsIndex, TInt aFileHandleIndex);

 	IMPORT_C TInt Name(TDes& aName) const;

 	IMPORT_C TInt TransferToServer(TIpcArgs& aIpcArgs, TInt aFsHandleIndex, TInt aFileHandleIndex) const;

 	IMPORT_C TInt TransferToClient(const RMessage2& aMsg, TInt aFileHandleIndex) const;

 	IMPORT_C TInt TransferToProcess(RProcess& aProcess, TInt aFsHandleIndex, TInt aFileHandleIndex) const;

 	IMPORT_C TInt Duplicate(const RFile& aFile, TOwnerType aType=EOwnerProcess);

 	IMPORT_C TInt FullName(TDes& aName) const;

 	IMPORT_C TInt BlockMap(SBlockMapInfo& aInfo, TInt64& aStartPos, TInt64 aEndPos=-1, TInt aBlockMapusage=EBlockMapUsagePaging) const;

 //	IMPORT_C TInt Clamp(RFileClamp& aHandle);

 	TInt Clamp(RFileClamp& aHandle);

 private:

 	TInt DuplicateHandle(TInt& aSubSessionHandle) const;

 	};

 class RDir : public RSubSessionBase

 /**

 @publishedAll

 @released

 Reads the entries contained in a directory.

 You must first open the directory, specifying an attribute mask which is used

 by Read() calls to filter the entry types required. Then, use one of

 the Read() functions to read the filtered entries. When the operation

 is complete, the directory should be closed using Close()

 There are two types of Read(): one works with a single entry at a time,

 requiring programs to iterate through the entries explicitly.

 The other works with an entire TEntryArray, allowing multiple entries to be

 read in one call.

 As well as making application program logic somewhat simpler, this type

 uses fewer calls to the server, and is more efficient.

 Each type of Read() can be performed either synchronously or asynchronously.

 It may be more convenient to use RFs::GetDir() than the Read() calls supported

 by this class.

 RFs::GetDir() has the advantage that it allows a directory’s entries to be

 sorted in various ways.

 However, it does not provide asynchronous as well as synchronous variants

 and does not allow entries to be read individually.

 @see RFs

 */

 	{

 public:

 	IMPORT_C TInt Open(RFs& aFs,const TDesC& aMatchName,const TUidType& aUidType);

 	IMPORT_C TInt Open(RFs& aFs,const TDesC& aMatchName,TUint anAttMask);

 	IMPORT_C void Close();

 	IMPORT_C TInt Read(TEntryArray& anArray) const;

 	IMPORT_C void Read(TEntryArray& anArray,TRequestStatus& aStatus) const;

 	IMPORT_C TInt Read(TEntry& anEntry) const;

 	IMPORT_C void Read(TPckg<TEntry>& anEntry,TRequestStatus& aStatus) const;

 	};

 class RFormat : public RSubSessionBase

 /**

 @publishedAll

 @released

 Formats a device, one step at a time. 

 RFormat must first be opened on a device before formatting each

 track using Next().

 There is also an asynchronous version of Next() which, if encapsulated into

 a suitable active object, can be used to implement a

 user-interruptible formatting process.

 */

 	{

 public:

 	IMPORT_C TInt Open(RFs& aFs,const TDesC& aName,TUint aFormatMode,TInt& aCount);

 	IMPORT_C TInt Open(RFs& aFs,const TDesC& aName,TUint aFormatMode,TInt& aCount,const TDesC8& anInfo);

 	IMPORT_C void Close();

 	IMPORT_C TInt Next(TInt& aStep);

 	IMPORT_C void Next(TPckgBuf<TInt>& aStep,TRequestStatus& aStatus);

 	};

 class RRawDisk : public RSubSessionBase

 /**

 @publishedAll

 @released

 Enables direct disk access.

 No other resources can access the disk while direct access to it is in effect.

 This class is not intended for user derivation.

 */

 	{

 public:

 	IMPORT_C TInt Open(RFs& aFs,TInt aDrive);

 	IMPORT_C void Close();

 	IMPORT_C TInt Read(TInt64 aPos,TDes8& aDes);

 	IMPORT_C TInt Write(TInt64 aPos,TDesC8& aDes);

 private:

 	TInt iDrive;

 	};

 class CDirStack;

 NONSHARABLE_CLASS(CDirScan) : public CBase

 /**

 @publishedAll

 @released

 Scans a directory structure.

 The scan moves from directory to directory through the hierarchy, returning

 a list of the entries contained in each. The order in which the directories

 are scanned is determined by a sort key which is specified when setting up

 the scan. The base directory to be scanned and the entry types of interest

 must also be specified before performing the scan.

 This class is not intended for user derivation

 */

     {

 public:

     /**

     Defines the scan direction.

     */

 	enum TScanDirection

 		{

 		/**

 		Scan upwards from the lowest level directory in the hierarchy to

 		the top level directory.

 		*/

 		EScanUpTree,

 		/**

 		Scan downwards from the top level directory in the hierarchy to

 		the bottom level directory.

 		*/

 		EScanDownTree

 		};

 public:

 	IMPORT_C static CDirScan* NewL(RFs& aFs);

 	IMPORT_C static CDirScan* NewLC(RFs& aFs);

 	IMPORT_C ~CDirScan();

 	IMPORT_C void SetScanDataL(const TDesC& aMatchName,TUint anEntryAttMask,TUint anEntrySortMask,TScanDirection aScanDir=EScanDownTree);

 	IMPORT_C void NextL(CDir*& aDirEntries);

 	IMPORT_C TPtrC AbbreviatedPath();

 	IMPORT_C TPtrC FullPath();

 protected:

 	CDirScan(RFs& aFs);

 private:

 	inline RFs& Fs();

 	void UpdateAbbreviatedPath();

 	void ScanUpTreeL(CDir*& aDirEntries);

 	void ScanDownTreeL(CDir*& aDirEntries);

 	void GetDirEntriesL(CDir*& aDirEntries);

 private:

 	RFs* const iFs;

 	TParse iFullPath;

 	TPtrC iAbbreviatedPath;

 	TInt iAbbreviatedPathPos;

 	TUint iEntryAttMask;

 	TUint iEntrySortMask;

 	TBool iScanning;

 	TScanDirection iScanDir;

 	CDirStack* iStack;

 	};

 enum TFileManError

 /**

 @publishedAll

 @released

 A list of CFileMan error codes.

 @see CFileMan

 */

 	{

 	/**

 	No additional error information is available, either because

 	the latest CFileMan operation did not return an error, or if it did,

 	the error was not one for which additional information is available.

 	*/

 	ENoExtraInformation,

 	/**

 	A leave occurred while setting up the initial scan.

 	This indicates that the operation did not begin.

 	@see CDirScan.

     */

 	EInitializationFailed,

 	/**

 	A leave occurred while scanning the next directory in the course of a file

 	management function.

 	This indicates that the operation did begin.

 	@see CDirScan.

 	*/

 	EScanNextDirectoryFailed,

 	/**

 	Error occurred when attempting to open the source file for a file copy

 	or move.

 	*/

 	ESrcOpenFailed,

 	/**

 	Error occurred while attempting to create, or, if overwriting is in effect,

 	replace the target file for a file copy or move.

 	*/

 	ETrgOpenFailed,

 	/**

 	The operation completed without processing any files because no matching

 	files were found.

 	*/

 	ENoFilesProcessed

 	};

 class MFileManObserver

 /**

 @publishedAll

 @released

 Provides notification of the progress of synchronous or asynchronous

 file management operations.

 It should be inherited by classes which implement this protocol.

 The enquiry functions provided by CFileBase and CFileMan may be used by

 the observer to display information about the progress of the operation

 such as error messages, the names of the target and destination files,

 and the number of bytes transferred during a copy operation.

 Notification may take place before or after an entry has been processed,

 or during a file copy or move.

 Each notification function returns a value which can be used to enable

 the user to control the progress of the operation, for example to cancel

 a long-running multiple file copy.

 To use this class, pass a pointer to an instance of the class to

 the CFileMan constructor, or use SetObserver(), defined in CFileBase.

 */

 	{

 public:

     /**

     Control for the current CFileMan operation.

     */

 	enum TControl

 		{

 		/**

 		Proceed with the current or the next entry.

 		*/

 		EContinue,

 		/**

 		Retry processing the previous entry.

 		*/

 		ERetry,

 		/**

 		Abort operation, causes function to return KErrCancel.

 		*/

 		EAbort,

 		/**

 		Cancel processing the current entry.

 		*/

 		ECancel

 		};

 public:

 	IMPORT_C virtual TControl NotifyFileManStarted();

 	IMPORT_C virtual TControl NotifyFileManOperation();

 	IMPORT_C virtual TControl NotifyFileManEnded();

 	};

 class CFileBase : public CBase

 /**

 @publishedAll

 @released

 Abstract base class for file management.

 It provides functions to set an observer for the derived class

 CFileMan, and to get information about the entry being processed.

 @see CFileMan

 */

 	{

 public:

 	IMPORT_C void SetObserver(MFileManObserver* anObserver);

 public:

 	IMPORT_C const TEntry& CurrentEntry();

 	IMPORT_C TPtrC AbbreviatedPath();

 	IMPORT_C TPtrC FullPath();

 	IMPORT_C TInt GetLastError();

 	IMPORT_C TFileManError GetMoreInfoAboutError();

 protected:

 	IMPORT_C CFileBase(RFs& anFs);

 	IMPORT_C void ConstructL();

 	IMPORT_C ~CFileBase();

 	IMPORT_C void RunL();

 	IMPORT_C void RunInSeparateThreadL(TThreadFunction aThreadFunction);

 // virtual

     /**

     Called from RunL to perform tidy up after an operation.

     @see CFileMan

     @see CFileBase::RunL

     */

 	virtual void CompleteOperationL() {};

 //pure virtual

 	/**

 	Called from RunL to perform the requested operation.

 	@see CFileMan

 	@see CFileBase::RunL

 	*/

 	virtual void DoOperationL() = 0;

 protected:

 	RFs iFs;

 	RFs iFsOld;

 	RThread iFManThread;

 	RSemaphore iSynchronizer;

 	CDirScan* iScanner;

 	CDir* iDirList;

 	TInt iCurrentEntry;

 	TUint iMatchEntry;

 	TUint iSwitches;

 	TParse iSrcFile;

 	MFileManObserver* iObserver;

 	TInt iLastError;

 	TFileManError iErrorInfo;

 	TRequestStatus* iStatus;

 	HBufC* iSessionPath;

 	TInt iNumberOfFilesProcessed;

 friend void DoFManBaseOperationL(TAny* aPtr);

 friend TInt FManBaseThreadFunction(TAny* aPtr);

 	};

 NONSHARABLE_CLASS(CFileMan) : public CFileBase

 /**

 @publishedAll

 @released

 Offers file management services which accept the use of wildcards;

 synchronous and asynchronous.

 It also provides enquiry functions, which, like those provided by

 the base class CFileBase, may be used by an observer class object

 to provide the user with information about the progress of the operation.

 All of the file management functions provided by this class accept the use of

 wildcards, and may operate either synchronously or asynchronously.

 When CFileMan is operating asynchronously, the operation takes place in

 a separate thread from the calling code.

 A file notification observer (an instance of a class deriving

 from MFileManObserver) may optionally be used by CFileMan when operating

 synchronously or asynchronously. If provided, the appropriate notification

 function is called before or after each entry has been processed,

 or during a file copy or move.

 This notification can be used to provide information about the state of

 the operation, such as the number of bytes transferred during a

 large-scale file copy. It can also be used to allow the user to cancel,

 retry or continue processing an entry, or to abort the whole operation.

 If such notification is required, specify an object deriving from

 MFileManObserver class in the constructor, or call SetObserver(),

 defined in the base class, CFileBase.

 All of the file manipulation functions except Rename() may operate recursively,

 and all can operate non-recursively. When operating recursively,

 these functions will act on all matching files located throughout

 the source directory’s hierarchy. When operating non-recursively,

 these functions act upon files contained in the single top level source

 directory only. Recursion is set or unset using the switch parameter to

 these functions.

 This class is not intended for user derivation.

 @see MFileManObserver

 */

 	{

 public:

     /**

     An enumeration that identifies CFileMan tasks. This enumeration is used

     by CurrentAction() to identify which task currently being carried out.

 	@see CFileMan::CurrentAction

     */

 	enum TAction

 		{

 		/**

 		Inactive

 		*/

 		ENone,

 		/**

 		Setting attributes

 		*/

 		EAttribs,

 		/**

 		Copying files

 		*/

 		ECopy,

 		/**

 		Deleting files

 		*/

 		EDelete,

 		/**

 		Moving files

 		*/

 		EMove,

 		/**

 		Renaming files

 		*/

 		ERename,

 		/**

 		Deleting a directory and all contents

 		*/

 		ERmDir,

 		/**

 		Renaming component to VFAT short name (guaranteed to be unique)

 		*/

 		ERenameInvalidEntry,

 		/**

 		Copying file from open file handle

 		*/

 		ECopyFromHandle,

 		};

 	/**

 	Overwriting and recursion switch.

 	Used in CFileMan functions to set whether operations are applied to

 	the specified directory and all directories below it, or

 	the specified directory only. 

 	*/	

 	enum TSwitch

 		{

 		/**

 		Any files in the destination directory that have the same name as

 		the source files in a rename, move or copy operation, will

 		be overwritten.

 		*/

 		EOverWrite=1,

 		/**

 		Recursive operation.

 		*/

 		ERecurse=2

 		};

 public:

 	IMPORT_C static CFileMan* NewL(RFs& aFs);

 	IMPORT_C static CFileMan* NewL(RFs& aFs,MFileManObserver* anObserver);

 	~CFileMan();

 	IMPORT_C TAction CurrentAction();

 	IMPORT_C void GetCurrentTarget(TFileName& aFile);

 	IMPORT_C void GetCurrentSource(TFileName& aFile);

 	IMPORT_C TInt BytesTransferredByCopyStep();

 public:

 	IMPORT_C TInt Attribs(const TDesC& aName,TUint aSetMask,TUint aClearMask,const TTime& aTime,TUint aSwitch=0);

 	IMPORT_C TInt Attribs(const TDesC& aName,TUint aSetMask,TUint aClearMask,const TTime& aTime,TUint aSwitch,TRequestStatus& aStatus);

 	IMPORT_C TInt Copy(const TDesC& anOld,const TDesC& aNew,TUint aSwitch=EOverWrite);

 	IMPORT_C TInt Copy(const TDesC& anOld,const TDesC& aNew,TUint aSwitch,TRequestStatus& aStatus);

 	IMPORT_C TInt Delete(const TDesC& aName,TUint aSwitch=0);

 	IMPORT_C TInt Delete(const TDesC& aName,TUint aSwitch,TRequestStatus& aStatus);

 	IMPORT_C TInt Move(const TDesC& anOld,const TDesC& aNew,TUint aSwitch=EOverWrite);

 	IMPORT_C TInt Move(const TDesC& anOld,const TDesC& aNew,TUint aSwitch,TRequestStatus& aStatus);

 	IMPORT_C TInt Rename(const TDesC& anOld,const TDesC& aNew,TUint aSwitch=EOverWrite);

 	IMPORT_C TInt Rename(const TDesC& anOld,const TDesC& aNew,TUint aSwitch,TRequestStatus& aStatus);

 	IMPORT_C TInt RmDir(const TDesC& aDirName);

 	IMPORT_C TInt RmDir(const TDesC& aDirName,TRequestStatus& aStatus);

 	IMPORT_C TInt Copy(const RFile& anOld,const TDesC& aNew,TUint aSwitches=EOverWrite);

 	IMPORT_C TInt Copy(const RFile& anOld,const TDesC& aNew,TUint aSwitches,TRequestStatus& aStatus);

 protected:

 	CFileMan(RFs& aFs);

 	TInt RenameInvalidEntry(const TDesC& anOld,const TDesC& aNew,TUint aSwitch=EOverWrite);

 private:

 	/**

 	This is an internal enumeration for CFileMan implementation. 

 	THis enumeration is mapped into TAction when user wants to identify the current

 	task of CFileMan by CurrentAction().

 	@see CFileMan::TAction

 	@see CFileMan::CurrentAction

     */	

 	enum TInternalAction