// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "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:

//

#include "FileBuf64.h"

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**

This constant is used for initializing the RFileBuf64::iFileSize data member and means that

the iFileSize is not yet initialized with the real file size value. 

(RFileBuf64::iFileSize caches the file size value)

@internalComponent

*/

static const TInt KFileSizeNotSet = -1;

/**

This constant is used as a default initializer for the RFileBuf64::iNextReadFilePos data member,

indicating that the "guessed" file read offset is invalid and should not be used.

@internalComponent

*/

static const TInt KNextReadFilePosNotSet = -1;

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#ifdef _DEBUG

#define __FILEBUF64_INVARIANT() Invariant()

#else //_DEBUG

#define __FILEBUF64_INVARIANT() void(0)

#endif//_DEBUG

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

///////////////////////////        RFileBuf64    /////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**

Initializes RFileBuf64 data members with their default values.

@param aSize Max file buffer size (capacity) in bytes.

*/

RFileBuf64::RFileBuf64(TInt aSize) :

	iCapacity(aSize),

	iReadAheadSize(RFileBuf64::KDefaultReadAheadSize)

	{

	}

/**

Initializes the RFileBuf64 object and creates and opens a new file that will be accessed through RFileBuf64 public interface.

If the file already exists, an error is returned.

If the resulting path does not exist, then the operation cannot proceed and the function returns an error code.

@param aFs       The file server session.

@param aFileName The name of the file. Any path components (i.e. drive letter

                 or directory), which are not specified, are taken from

                 the session path.

@param aFileMode The mode in which the file is opened. See TFileMode for details.

@return KErrNone if successful, otherwise one of the other system-wide error codes.

@see TFileMode

@see RFile64::Create()

*/

TInt RFileBuf64::Create(RFs& aFs, const TDesC& aFileName, TUint aFileMode)

	{

	}

/**

Initializes the RFileBuf64 object and opens an existing file that will be accessed through RFileBuf64 public interface.

If the file does not already exist, an error is returned.

@param aFs       The file server session.

@param aFileName The name of the file. Any path components (i.e. drive letter

                 or directory), which are not specified, are taken from

                 the session path.

@param aFileMode The mode in which the file is opened. See TFileMode for details.

@return KErrNone if successful, otherwise one of the other system-wide error codes.

@see TFileMode

@see RFile64::Open()

*/

TInt RFileBuf64::Open(RFs& aFs, const TDesC& aFileName, TUint aFileMode)

	{

    TInt err = DoPreInit();

    if(err == KErrNone)

        {

        err = iFile.Open(aFs, aFileName, aFileMode);

        }

	}

/**

Initializes the RFileBuf64 object and creates and opens a temporary file with unique name that will be accessed through 

RFileBuf64 public interface.

@param aFs       The file server session.

@param aPath     The directory in which the file is created.

@param aFileName On return, contains the full path and file name of the file.

                 The filename is guaranteed to be unique within the directory

                 specified by aPath.

@param aFileMode The mode in which the file is opened. The access mode is

                 automatically set to EFileWrite. See TFileMode for details.

@return KErrNone if successful, otherwise one of the other system-wide error codes.

@see TFileMode

@see RFile64::Temp()

*/

TInt RFileBuf64::Temp(RFs& aFs, const TDesC& aPath, TFileName& aFileName, TUint aFileMode)

	{

    TInt err = DoPreInit();

    if(err == KErrNone)

        {

        err = iFile.Temp(aFs, aPath, aFileName, aFileMode);

        }

	}

/**

Writes to the file the pending data (if the buffer contains pending data), closes the file and releases

the RFileBuf64 resources. 

RFileBuf64::Flush() should be called before RFileBuf64::Close() to ensure that if there are pending data, they will

be written to the file and if the operation fails, the caller will be notified with an appropriate return error.

@see RFileBuf64::Flush()

*/

void RFileBuf64::Close()

	{

	if(iFile.SubSessionHandle() != 0 && iBase != 0)

		{

		(void)DoFileWrite2();

		}

	iFile.Close();

	User::Free(iBase);

	iBase = 0;

	}

/**

Calculates and sets optimal read-ahead buffer size.

aBlockSize and aReadRecBufSize values are retrieved by the caller from the file system.

Initialization rules:

Rule 1: If aReadRecBufSize is positive, bigger than the default read-ahead and 

        a power of two then the read-ahead value will be

        initialized with aReadRecBufSize (if aReadRecBufSize is less than the buffer capacity otherwise

        the buffer capacity will be used as a read-ahead value). 

Rule 2: If rule#1 is not applicable then the same checks, as in rule#1, are performed this time for aBlockSize.

        If aBlockSize passes the checks then it will be used as a read-ahead value. 

@param aBlockSize The size of a file block in bytes

@param aReadRecBufSize The recommended buffer size for optimised reading performance

@return The new read-ahead value

@see TVolumeIOParamInfo

*/

TInt RFileBuf64::SetReadAheadSize(TInt aBlockSize, TInt aReadRecBufSize)

	{

	__FILEBUF64_INVARIANT();

		{

		iReadAheadSize = aReadRecBufSize > iCapacity ? iCapacity : aReadRecBufSize;

		}

		{

		iReadAheadSize = aBlockSize > iCapacity ? iCapacity : aBlockSize;

		}

	__FILEBUF64_INVARIANT();

	return iReadAheadSize;

	}

/**

Reads from the file at the specified position (aFilePos).

If the data to be read is in the buffer, then the data will be taken from the buffer.

@param aFilePos Position of first byte to be read.  This is an offset from

            the start of the file. 

            If aPos is beyond the end of the file, the function returns

            a zero length descriptor.

@param aDes Descriptor into which binary data is read. Any existing contents 

            are overwritten. On return, its length is set to the number of

            bytes read.

@return KErrNone if successful, otherwise one of the other system-wide error  codes.

See RFileBuf64::Invariant() for other possible panics that may occur when this method is called.

@see RFileBuf64::Invariant()

*/

TInt RFileBuf64::Read(TInt64 aFilePos, TDes8& aDes)

	{

	__FILEBUF64_INVARIANT();

	aDes.SetLength(0);

	//1. The output buffer max len is 0

	if(aDes.MaxLength() == 0)

		{

		__FILEBUF64_INVARIANT();

		return KErrNone;	

		}

	//2. Initialize the "iFileSize" if it is not initialized yet

	TInt err = DoFileSize();

	if(err != KErrNone)

		{

		__FILEBUF64_INVARIANT();

		return err;	

		}

	//3. Too big "read" request - read directly from the file

	TInt len = aDes.MaxLength();

	if(len > iCapacity)

		{

			{//Write the pending data if the iDirty flag is set, otherwise preserve the buffer content.

			err = DoFileWrite1(aFilePos);

			}

		if(err == KErrNone)

			{

			err = iFile.Read(aFilePos, aDes);

			}

		__FILEBUF64_INVARIANT();

		return err;

		}

	//4. The requested data size is smaller than the buffer capacity

	TUint8* outptr = const_cast <TUint8*> (aDes.Ptr());

	while(len > 0 && err == KErrNone && aFilePos < iFileSize)

		{

		//1. If part or all of the data is in the buffer - copy the data to the target location

		if(aFilePos >= iFilePos && aFilePos < (iFilePos + iLength))

			{

			TInt blocklen = Min(len, (iFilePos + iLength - aFilePos));

			outptr = Mem::Copy(outptr, iBase + (aFilePos - iFilePos), blocklen);

			len -= blocklen;

			aFilePos += blocklen;

			}

		//2. Perform a read-ahead operation

		else

			{

			//Write the pending data if the iDirty flag is set, otherwise preserve the buffer content.

			err = DoFileWrite1(aFilePos);

			if(err != KErrNone)

				{

				break;	

				}

			if(iNextReadFilePos != aFilePos)

				{//Guessed read ahead was wrong. Direct "file read" operation

				iNextReadFilePosHits = 0;

				TPtr8 ptr2(outptr, len);

				err = iFile.Read(aFilePos, ptr2);

				if(err == KErrNone)

					{

					iNextReadFilePos = aFilePos + len;

					len -= ptr2.Length();

					}

				break;

				}

			//The guessed from the previous "file read" operation file pos is correct. Start reading-ahead.

			const TInt KMaxReadFilePosHits = 8;//The max read-ahead buffer size can be up to 2^8 times the iReadAheadSize

			if(iNextReadFilePosHits < KMaxReadFilePosHits)

				{

				++iNextReadFilePosHits;

				}

			TInt maxReadAhead = iReadAheadSize * (1 << iNextReadFilePosHits);

			TInt align = (aFilePos + len + maxReadAhead) & (iReadAheadSize - 1);

			TInt readahead = maxReadAhead - align;

			if(readahead < 0)

				{

				// if read-ahead doesn't cross block boundary do it all

				readahead = maxReadAhead;	

				}

			TPtr8 ptr(iBase, Min(iCapacity, (len + readahead)));

			err = iFile.Read(aFilePos, ptr);

			if(err == KErrNone)

				{

				iFilePos = aFilePos;

				iLength = ptr.Length();	

				iNextReadFilePos = iFilePos + iLength;

				if(iLength == 0)

					{

					break;	

					}

				}

			else

				{

				DoDiscard();	

				}

			}

		}

	aDes.SetLength(aDes.MaxLength() - len);

	__FILEBUF64_INVARIANT();

	return err;

	}

/**

Writes to the file at the specified offset (aFilePos) within the file.

If certain conditions are met, the data will be stored in the buffer - no call to the file server.

@param aFilePos The offset from the start of the file at which the first byte is written. 

                If a position beyond the end of the file is specified, then

                the write operation begins at the end of the file.

                If the position has been locked, then the write fails.

@param aData The descriptor from which binary data is written. The function writes 

             the entire contents of aData to the file.

@return KErrNone if successful, otherwise one of the other system-wide error  codes.

See RFileBuf64::Invariant() for other possible panics that may occur when this method is called.

@see RFileBuf64::Invariant()

*/

TInt RFileBuf64::Write(TInt64 aFilePos, const TDesC8& aData)

	{

	__FILEBUF64_INVARIANT();

	if(aData.Length() == 0)

		{

		__FILEBUF64_INVARIANT();

		return KErrNone;	

		}

	TInt err = DoFileSize();

	if(err != KErrNone)

		{

		__FILEBUF64_INVARIANT();

		return err;	

		}

	DoDiscardBufferedReadData();

	const TUint8* data = aData.Ptr();

	for(TInt len = aData.Length(); len > 0 && err == KErrNone;)

		{

		//1. The new write pos is before the buffered file pos

		if(aFilePos < iFilePos)

			{

			//If the new data sticks to/overlapps the old data and there is room in the buffer to move the old data 

			//toward the end, then the new data can be copied at the beginning of the buffer.

			if((aFilePos + len) >= iFilePos && (iFilePos - aFilePos) <= (iCapacity - iLength))

				{

				(void)Mem::Copy(iBase + (iFilePos - aFilePos), iBase, iLength);	//Make room - move the existing data toward the end

				(void)Mem::Copy(iBase, data, len);								//of the buffer. Stick the new data to the old data

				iLength += (iFilePos - aFilePos);

				iFilePos = aFilePos;										//The new file pos is associated with the buffer

				iFileSize = Max(iFileSize, (iFilePos + iLength));

				len = 0;													//No more new data

				iDirty = ETrue;	

				}

			else

			//The "aFilePos" is too far before the "iFilePos". Write the buffer and associate the new pos with the buffer

				{

				err = DoFileWrite2(aFilePos);

				}

			}

		//2. The new write pos is after the associated file pos + the data length.

		else if(aFilePos > (iFilePos + iLength))

			{

			if(aFilePos > iFileSize)											//Beyond the end of the file

				{

				if((iFilePos + iLength) == iFileSize && (aFilePos - iFilePos) < iCapacity)	

					{															//but within the buffer => extend the file with zeros.

					Mem::FillZ(iBase + iLength, aFilePos - iFilePos - iLength);

					iLength = aFilePos - iFilePos;

					iFileSize = Max(iFileSize, (iFilePos + iLength));

					iDirty = ETrue;	

					}

				else									

				//Beyond the end of the file and not in the buffer - set file size.

					{

					err = DoSetFileSize(aFilePos);

					}

				}

			else										

			//Within the file, not in the buffer - write the buffer and associate the new file pos with the buffer

				{

				err = DoFileWrite2(aFilePos);

				}

			}

		//3. The new write pos is in the buffer, but the data length is too big

		//   (For SQLite is OK, otherwise the whole block must be written to the file)

		//4. The new write pos is in the buffer, the data entirely fits in the buffer

		else

			{

			if(iCapacity == iLength)			//The buffer is full. Write the buffer and associate the new file pos

				{

				err = DoFileWrite2(aFilePos);

				}

			if(err == KErrNone)

				{

				TInt amount = Min(len, (iCapacity - (aFilePos - iFilePos)));

				const TUint8* end = Mem::Copy(iBase + (aFilePos - iFilePos), data, amount);

				iLength = Max(iLength, (end - iBase));

				iFileSize = Max(iFileSize, (iFilePos + iLength));

				len -= amount;

				data += amount;

				aFilePos += amount;

				iDirty = ETrue;	

				}

			}

		}

	__FILEBUF64_INVARIANT();

	return err;

	}

/**

Gets the current file size.

@param aFileSize On return, the size of the file in bytes.

@return KErrNone if successful, otherwise one of the other system-wide error codes.

See RFileBuf64::Invariant() for possible panics that may occur when this method is called.

@see RFileBuf64::Invariant()

*/

TInt RFileBuf64::Size(TInt64& aFileSize)

	{

	__FILEBUF64_INVARIANT();

	TInt err = DoFileSize();

	if(err == KErrNone)

		{

		aFileSize = iFileSize;

		}

	__FILEBUF64_INVARIANT();

	return err;

	}

/**

Sets the file size.

If the size of the file is reduced, data may be lost from the end of the file.

Note:

1. The current file position remains unchanged unless SetSize() reduces the size 

   of the file in such a way that the current file position is now beyond

   the end of the file. In this case, the current file position is set to

   the end of file. 

2. If the file was not opened for writing, an error is returned.

@param aFileSize The new size of the file, in bytes. This value must not be negative, otherwise the function raises a panic.

@return KErrNone if successful, otherwise one of the other system-wide error codes.

See RFileBuf64::Invariant() for other possible panics that may occur when this method is called.

@see RFileBuf64::Invariant()

*/

TInt RFileBuf64::SetSize(TInt64 aFileSize)

	{

	__FILEBUF64_INVARIANT();

	return DoSetFileSize(aFileSize);

	}

/**

Locks a region within the file as defined by a range of bytes.

@see RFile64::Lock()