// 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();}

/**

@return	Amount of space reserved in bytes.

*/

inline TInt TDrive::ReservedSpace() const

	{

    return iReservedSpace;

    }

/**

    Reserves space on a drive. The amount of 'reserved space' is subtracted  

    from the amount of available free space on the volume reported by file system, when the user 

    queries it.

    @param	aReservedSpace	Amount of space to reserve in bytes.

*/

inline void TDrive::SetReservedSpace(const TInt aReservedSpace)

	{

    iReservedSpace=aReservedSpace; 

    }

/**

    Sets the 'rugged mode' flag in the drive object. The file system associated with this TDrive object 

    can use this flag for changing its behaviour.

    For example, FAT file system if this flag is set, operates in 'Rugged FAT' mode, when the performance is 

    sacrificed for the sake of reliability. 

    @param aIsRugged  the 'rugged mode' flag.

*/

inline void TDrive::SetRugged(TBool aIsRugged)

	{

	if (!aIsRugged)

		iDriveFlags |= ENotRugged;

	else

		iDriveFlags &= ~ENotRugged;

	}

/**

    @return 'Is rugged' flag.

    See TDrive::SetRugged()

*/

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();}

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

/**

    Increment mount's lock counter. This happens on following events:

        - RemoveResource() call, when file (share) or directory is closed

        - AddDiskAccess() call,  when disk access object (like Format or RawDisk access) is opened on the mount.

    See also: CMountCB::LockStatus()   

*/

inline void CMountCB::IncLock()

	{

    iLockMount++;

    }

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

/**

    Decrement mount's lock counter. This happens on following events:

    AddResource()       call when file (share) or directory is opened on the mount 

    RemoveDiskAccess()  call when disk access object (like Format or RawDisk access) is closed.

    See also: CMountCB::LockStatus()   

*/

inline void CMountCB::DecLock()

	{

    iLockMount--;

    }

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

/**

    @return value of the Mount's lock counter value.

    The meaning of 'iLockMount' is overloaded a bit, it's value is:

        0   when there are no files, directories, formats and any other objects opened on the mount

        >0  when there are disk access objects opened (raw disk access or format)

        <0  when there are files or directories opened on the mount, and the value reflects their total number 

*/

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.

    This happens when a format, resource or raw disk subsession is opened on the mount.

    See also: CMountCB::LockStatus()   

    @return True if the mount is locked by having disk access objects opened

*/

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.