// 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\sfsrv\cl_entry.cpp

// 

//

#include "cl_std.h"

/**

Default constructor.

*/

EXPORT_C TVolumeInfo::TVolumeInfo()

	{

    Mem::FillZ(this, sizeof(TVolumeInfo)); //-- zero-fill itself

    new(&iName)TBufC<KMaxFileName>;        //-- initialise broken descriptor 

    }

EXPORT_C TBool TEntry::IsReadOnly() const

/**

Tests whether the file or directory is read-only.

@return ETrue if entry is read-only, EFalse if not.

@see KEntryAttReadOnly

*/

	{

	return(iAtt&KEntryAttReadOnly);

	}

EXPORT_C TBool TEntry::IsHidden() const

/**

Tests whether the file or directory is hidden.

@return ETrue if entry is hidden, EFalse if not.

@see KEntryAttHidden

*/

	{

	return(iAtt&KEntryAttHidden);

	}

EXPORT_C TBool TEntry::IsSystem() const

/**

Tests whether the file or directory has the system attribute set.

@return ETrue if entry is a system entry, EFalse if not.

@see KEntryAttSystem

*/

	{

	return(iAtt&KEntryAttSystem);

	}

EXPORT_C TBool TEntry::IsDir() const

/**

Tests whether the entry is a directory.

@return ETrue if entry indicates a directory, EFalse if not.

@see KEntryAttDir

*/

	{

	return(iAtt&KEntryAttDir);

	}

EXPORT_C TBool TEntry::IsArchive() const

/**

Tests whether the file is an archive file.

@return ETrue if file is archive, EFalse if not.

@see KEntryAttArchive

*/

	{

	return(iAtt&KEntryAttArchive);

	}

EXPORT_C TEntryArray::TEntryArray()

	: iCount(0)

/**

Default constructor.

Initialises its count of contained TEntry objects to zero.

*/

	{}

EXPORT_C TInt TEntryArray::Count() const

/**

Gets the number of entries in the array.

@return The number of entries in the array.

*/

	{

	if (iCount==KCountNeeded)

		{

		const TEntry* pE=(const TEntry*)iBuf.Ptr();

		const TEntry* pEnd=PtrAdd(pE,iBuf.Length());

		TInt c=0;

		while (pE<pEnd)

			{

			c++;

			pE=PtrAdd(pE,EntrySize(*pE, ETrue));

			}

		TEntryArray& me=(TEntryArray& )(*this);

		me.iCount=c;

		me.iIndex=0;

		me.iPos=(const TEntry*)iBuf.Ptr();

		}

	return(iCount);

	}

EXPORT_C const TEntry& TEntryArray::operator[](TInt anIndex) const

/**

Gets the directory entry at the specified index.

@param anIndex Index of the entry within the array.

               This value is relative to zero.

@return On return contains the entry at the specified index.

@panic FSCLIENT 22 if anIndex is greater than or equal to the number

       of elements in the array.

*/

	{

	__ASSERT_ALWAYS(anIndex<Count(),Panic(EEntryArrayBadIndex));

	const TEntry* pE=iPos;

	TInt ix=iIndex;

	if (anIndex<ix)

		{

		ix=0;

		pE=(const TEntry*)iBuf.Ptr();

		}

	while (ix<anIndex)

		{

		pE=PtrAdd(pE,EntrySize(*pE, ETrue));

		ix++;

		}

	TEntryArray& me=(TEntryArray& )(*this);

	me.iIndex=ix;

	me.iPos=pE;

	return(*pE);

	}

EXPORT_C TEntry::TEntry()

/**

Default constructor.

*/

 : iSizeHigh(0),

   iReserved(0)

	{}

EXPORT_C TEntry::TEntry(const TEntry& aEntry)

/**

Copy constructor.

@param aEntry The TEntry object to be copied.

*/

	{

	Copy(aEntry);

	Unpack();		// Check that unpacking is safe here - we need to verify that wherever

					// the entry is copied back into a TEntryArray that the iSizeHigh and

					// iReserved members are re-packaged and the attribute set accordingly.

					// (for example, CDir::Sort might do this, but I haven't checked - I know

					//  this uses the assignment operator, which is why that doesn't unpack...)

	}

EXPORT_C TEntry& TEntry::operator=(const TEntry& aEntry)

/**

Assignment operator.

@param aEntry The TEntry object to be copied to this TEntry object.

@return A reference to this TEntry object.

*/

	{

	if(this!=&aEntry)

		{

		Copy(aEntry);

		Unpack();

		}

	return(*this);

	}

/**

@internalTechnology

@prototype

*/

inline void TEntry::Unpack()

	{

	if(iAtt & KEntryAttPacked)

		{

		/**

		 * This entry is still in a packed form, so unpack it now by copying high length 

		 * and reserved bytes from the packed source to the to the unpacked target entry

		 */

		TUint32* pSizeHighSrc = PtrAdd((TUint32*)this, EntrySize(*this, EFalse));

		iSizeHigh = *pSizeHighSrc++;	// Copy iSizeHigh

		iReserved = *pSizeHighSrc;		// Copy iReserved

		iAtt &= ~KEntryAttPacked;

		}

	}

/**

@internalTechnology

@prototype

*/

inline void TEntry::Copy(const TEntry& aEntry)

	{

	Mem::Copy(this,&aEntry,EntrySize(aEntry, ETrue));

	if(!(iAtt & KEntryAttPacked))

		{

		iSizeHigh = aEntry.iSizeHigh;

		iReserved = aEntry.iReserved;

		}

	}

#ifndef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

/**

@internalTechnology

@prototype

*/

#else

/**

Returns the file size in 64 bits.

This can be used to find the size of a file whose size is more than 2 GB - 1.

@return The file size in 64 bits

@publishedAll

@prototype

@see TEntry::iSize

*/

#endif

EXPORT_C TInt64 TEntry::FileSize() const

	{

#ifndef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

	Panic(ENotImplemented);

	return (KErrNotSupported);	// To suppress warning!

#else

	if(iAtt & KEntryAttPacked)

		{

		/**

		 * This entry is still in a packed form, so unpack it now by copying high length 

		 * and reserved bytes from the packed source to the to the unpacked target entry

		 */

		TUint32* pSizeHighSrc = PtrAdd((TUint32*)this, Align4(EntrySize(*this, EFalse)));

		return MAKE_TINT64(*pSizeHighSrc, iSize);

		}

	return MAKE_TINT64(iSizeHigh, iSize);

#endif

	}