// 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 "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// f32\inc\f32fsys.inl

// 

// WARNING: This file contains some APIs which are internal and are subject

//          to change without noticed. Such APIs should therefore not be used

//          outside the Kernel and Hardware Services package.

//

#define __IS_DRIVETHREAD() {__ASSERT_DEBUG(IsDriveThread(),DriveFault(ETrue));}

#define __IS_MAINTHREAD() {__ASSERT_DEBUG(IsMainThread(),DriveFault(EFalse));}

//---------------------------------------------------------------------------------------------------------------------------------

// Class TDrive

/**

Gets last error reason.

@return	TInt	Returns last error reason.

*/

inline TInt TDrive::GetReason() const

	{

	__IS_DRIVETHREAD(); 

	return(iReason);

	}

/**

Sets a flag to state that the drive contents has changed.

@param	aValue	True if contents has changed; False if unchanged.

*/

inline void TDrive::SetChanged(TBool aValue)

	{

	iChanged=aValue;

	}

/**

Determines whether the drive content has changed.

@return	True if contents changed , False if unchanged.

*/

inline TBool TDrive::IsChanged() const

	{

	return(iChanged);

	}

/**

Returns the drive number.

@return The drive number. 

@see TDriveNumber

*/

inline TInt TDrive::DriveNumber() const

	{return(iDriveNumber);}

/**

Determines whether the drive is mounted.

@return True if drive is mounted, False if drive is not mounted.

*/

inline TBool TDrive::IsMounted() const

	{

	__IS_DRIVETHREAD();

	return(iCurrentMount!=NULL);

	}

/**

Determines whether attribute is set to local.

@return True if attribute is set to KDriveAttLocal, False for all other attributes.

*/

inline TBool TDrive::IsLocal()  const

	{return(iAtt & KDriveAttLocal);}

/**

Determines whether the drive is ROM drive.

@return True if drive attribute is set as ROM drive  , False if not set as ROM drive.

*/

inline TBool TDrive::IsRom()  const

	{return( iAtt & KDriveAttRom);}

/**

Determines whether the drive is removable.

@return True if drive attribute is set to removable , False for all other attributes.

*/

inline TBool TDrive::IsRemovable() const

	{return( iAtt & KDriveAttRemovable);}

/**

Determines whether the drive is substed.

@return True if drive attribute is set to substed (KDriveAttSubsted), False for all other attributes.

*/

inline TBool TDrive::IsSubsted() const

	{return( iAtt & KDriveAttSubsted);}//	KDriveAttSubsted = 0x08

/**

Gets a reference to the object representing the current mount.

@return The file's mount.

*/

inline CMountCB& TDrive::CurrentMount() const

	{

	__IS_DRIVETHREAD();

	return(*iCurrentMount);

	}

inline  TBool TDrive::IsCurrentMount(CMountCB& aMount) const

	{return(iCurrentMount == &aMount);}

/**

Gets the substed drive.

@return		A pointer to the drive which is substed.

*/

inline TDrive& TDrive::SubstedDrive()const

	{

	__IS_MAINTHREAD();

	return(*iSubstedDrive);

	}

/**

Sets the drive as substed to the path set by an earlier call to SetSubst().

@param	aDrive	A pointer to the drive on which the volume is mounted.

*/

inline void TDrive::SetSubstedDrive(TDrive* aDrive)

	{

	__IS_MAINTHREAD();

	iSubstedDrive=aDrive;

	}

/**

Gets the substed path set by an earlier call to SetSubst().

@return	A reference to a heap descriptor containing the substed path.

*/

inline HBufC& TDrive::Subst() const

	{

	__IS_MAINTHREAD();

	return(*iSubst);

	}

/**

Assigns a path to a drive.

@param	aSubst	Path will be assigned to a drive.

*/

inline void TDrive::SetSubst(HBufC* aSubst)

	{

	__IS_MAINTHREAD();

	iSubst=aSubst;

	}

/**

Gets a reference to the object representing the mount on which the file resides.

@return The Drives's mount.

*/

inline CFsObjectCon& TDrive::Mount() const

	{return(*iMount);}

/**

Gets a reference to the object representing the file system

@return The reference to file system.

*/

inline CFileSystem& TDrive::FSys()

	{return(*iFSys);}

/**

Gets the object representing the file system

@return The file system.

*/

inline CFileSystem*& TDrive::GetFSys()

	{return(iFSys);}

/**

Gets the object representing the TDriveExtInfo.

@return The Drive extension information object.

@see	TDriveExtInfo

*/

inline TDriveExtInfo& TDrive::ExtInfo()

	{

	__IS_DRIVETHREAD();

	return(iExtInfo);

	}

/**

Sets the notification flag ON. The client will receive notifications on Read or Write 

failures from the file system.

*/

inline void TDrive::SetNotifyOn()

	{

	__IS_DRIVETHREAD();

	iDriveFlags &= ~ENotifyOff;

	}

/**

Sets the notification flag OFF. The client will not receive notifications on Read or Write 

failures from the file system.

*/

inline void TDrive::SetNotifyOff()

	{

	__IS_DRIVETHREAD();

	iDriveFlags |= ENotifyOff;

	}

/**

Locks the drive.This function acquires iLock mutex.

*/

inline void TDrive::Lock()

	{iLock.Wait();}

/**

UnLocks the drive.This function signals the iLock mutex.

*/

inline void TDrive::UnLock()

	{iLock.Signal();}

/**

Gets the reserved space of a drive

@return	Amount of space reserved in bytes.

*/

inline TInt TDrive::ReservedSpace() const

	{return iReservedSpace;}

/**

Reserves a space of a drive.

@param	aReservedSpace	Amount of space to reserve in bytes.

*/

inline void TDrive::SetReservedSpace(const TInt aReservedSpace)

	{iReservedSpace=aReservedSpace; }

/**

Sets the rugged flag in the drive object.

@param Flag to set or clear the rugged flag.

@see	IsRugged()

*/

inline void TDrive::SetRugged(TBool aIsRugged)

	{

	if (!aIsRugged)

		iDriveFlags |= ENotRugged;

	else

		iDriveFlags &= ~ENotRugged;

	}

/**

Returns whether the current drive is running as rugged Fat

or not.If IsRugged flag is set then in the event of power 

failure fat/metadata will be in a valid state if the scandrive 

utility is run immediately after.

@return Is rugged fat flag.

*/

inline TBool TDrive::IsRugged() const

	{return !(iDriveFlags & ENotRugged); }

/**

    @return ETrue if the drive is synchronous, i.e. runs in the main file server thread.

*/

inline TBool TDrive::IsSynchronous() const

{

    return iDriveFlags & EDriveIsSynch;

}

/**

    Set or reset internal EDriveIsSynch flag for the TDrive.

*/

inline void TDrive::SetSynchronous(TBool aIsSynch)

{

    if(aIsSynch)

        iDriveFlags |= EDriveIsSynch;

    else

        iDriveFlags &= ~EDriveIsSynch;

}

inline TBool TDrive::DismountDeferred() const

	{ return(iDriveFlags & EDismountDeferred); }

// Class CMountCB

/**

Gets a reference to the object representing the drive on which

the volume is mounted.

@return The drive on which the volume is mounted.

*/

inline TDrive& CMountCB::Drive() const

	{return(*iDrive);}

/**

Sets a pointer to the object representing the drive on which

the volume is mounted.

@param aDrive A pointer to the drive on which the volume is mounted.

*/

inline void CMountCB::SetDrive(TDrive* aDrive)

	{iDrive=aDrive;}

/**

Gets a reference to a heap descriptor containing the name of

the mounted volume.

@return A reference to a heap descriptor containing the volume name.

*/

inline HBufC& CMountCB::VolumeName() const

	{return(*iVolumeName);}

/**

Sets a pointer to a heap descriptor containing the name of the mounted volume.

@param aName A pointer to a heap descriptor containing the name of

             the mounted volume to be set.

*/

inline void CMountCB::SetVolumeName(HBufC* aName)

	{iVolumeName=aName;}

/**

Tests whether the client is notified of any read or write failures.

The notification status is a property of the current session with

the file server, the value of which is stored in CSessionFs::iNotifyUser.

If set to true, the client will receive notifications from the file system.

Typically, this function might be used to save the current notification

state prior to temporarily disabling notifiers. This allows the original

notification state to be restored. 

Note that GetNotifyUser() is only available once the drive has been set for

the mount control block (using SetDrive()), since the notification status

is held by the session and accessed via the drive.

@return True if the client receives notifications from the file system,

        false otherwise.

*/

inline TBool CMountCB::GetNotifyUser() const

	{return(Drive().GetNotifyUser());}

/**

*/

inline void CMountCB::SetNotifyOn()

	{Drive().SetNotifyOn();}

/**

*/

inline void CMountCB::SetNotifyOff()

	{Drive().SetNotifyOff();}

/**

Locks the mount by incrementing the internal lock counter.

The mount becomes locked on formatting or on the opening of a resource

(a file or a directory) or raw disk subsession.

A format, resource or raw disk subsession can only be opened if the mount

is not locked.

*/

inline void CMountCB::IncLock()

	{iLockMount++;}

/**

Unlocks the mount by decrementing the internal lock counter.

The mount becomes locked on formatting or on the opening of a resource

(a file or a directory) or raw disk subsession.

A format, resource or raw disk subsession can only be opened if the mount

is not locked.

*/

inline void CMountCB::DecLock()

	{iLockMount--;}

/**

Gets the current lock status.

It delivers the current lock status by returning the internal lock counter.

@return The current lock status.

*/

inline TInt CMountCB::LockStatus() const

	{return(iLockMount);}

/**

Tests whether the mount is currently locked. 

A mount is locked when the internal lock counter is greater than zero.

On creation, the lock counter is set to zero.

The mount becomes locked on formatting or on the opening of a resource

(a file or a directory) or raw disk subsession.

A format, resource or raw disk subsession can only be opened if the mount

is not locked.

@return True if the mount is locked, false, otherwise.

*/

inline TBool CMountCB::Locked() const

	{return iLockMount>0; }

/**

Tests whether the mount control block represents the current mount on

the associated drive.

A drive has only one mount which is accessible: the current mount.

Any mount other than the current mount relates to a partition (i.e. volume)

that was present on a removable media which has since been removed.

The reason the mount has persisted is because resources (i.e. files/directories)

are still open on it.

This function is only available when the drive has been set for the mount

control block (using SetDrive()), since the current mount is held by the drive.