// Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).
// 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 "UF_STD.H"
#include "S32FILEBUFSIZE.H"

//#define MAP_ROM_FILES
#ifdef _DEBUG
//#define IO_TRACING
//#define SIMULATE_PARTIAL_WRITE
#endif

#ifdef IO_TRACING
#include <e32svr.h>
_LIT(KTraceWrite,"RFile::Write [%d,%d)\n");
#define _TRACE_WRITE(p,l) RDebug::Print(KTraceWrite,(p),(p)+(l))
_LIT(KTraceRead,"RFile::Read [%d,%d)\n");
#define _TRACE_READ(p,l) RDebug::Print(KTraceRead,(p),(p)+(l))
_LIT(KTraceSize,"RFile::Size\n");
#define _TRACE_SIZE() RDebug::Print(KTraceSize)
_LIT(KTraceFlush,"RFile::Flush\n");
#define _TRACE_FLUSH() RDebug::Print(KTraceFlush)
_LIT(KTraceSetSize,"RFile::SetSize %d\n");
#define _TRACE_SETSIZE(s) RDebug::Print(KTraceSetSize,(s))
#else
#define _TRACE_WRITE(p,l)
#define _TRACE_READ(p,l)
#define _TRACE_SIZE()
#define _TRACE_FLUSH()
#define _TRACE_SETSIZE(s)
#endif

EXPORT_C RFileBuf::RFileBuf()
	: iBase(NULL),iSize(KDefaultFileBufSize),iWLim(NULL)
/** Constructs the object with a default intermediate buffer size.

The size of the intermediate buffer is the value of the constant KDefaultFileBufSize. */
	{}

EXPORT_C RFileBuf::RFileBuf(TInt aSize)
	: iBase(NULL),iSize(aSize),iWLim(NULL)
/** Constructs the object with the specified intermediate buffer size.

If the intermediate buffer size is zero, then the class provides an MStreamBuf 
interface to unbuffered file I/O.

@param aSize The size of the intermediate buffer. */
	{}

RFileBuf::RFileBuf(TCapture<RFileBuf> aCapture)
//
// Take over from the buffer wrapped inside aCapture.
//
	{
	RFileBuf& buf=aCapture.Object();
	iBase=buf.iBase;
	iSize=buf.iSize;
	SetBuf(ERead,buf.Ptr(ERead),buf.End(ERead));
	SetBuf(EWrite,buf.Ptr(EWrite),buf.End(EWrite));
	SetLimit(EWrite,buf.Limit(EWrite));
	buf.iBase=NULL;
	buf.SetBuf(ERead|EWrite,NULL,NULL);
	iFile=buf.File();
	buf.Detach();
	SetPos(ERead,buf.Pos(ERead));
	SetPos(EWrite,buf.Pos(EWrite));
	iExt=buf.iExt;
	}

EXPORT_C void RFileBuf::Reset()
/** Frees the intermediate buffer.

If there is any read data in the intermediate buffer, then the function reverts 
the read position within the stream.

The intermediate buffer must not contain any outstanding write data, otherwise 
the function raises a STORE-File 6 panic. */
	{
	__ASSERT_ALWAYS(Span(EWrite)==0,Panic(EFileWriteOutstanding));
	MovePos(ERead,Lag(ERead));
	Free();
	}

EXPORT_C TInt RFileBuf::Open(RFs& aFs,const TDesC& aName,TUint aFileMode)
/** Opens the specified file and attaches it to this stream buffer.

If the file cannot be opened, then it is not attached to this stream buffer.

@param aFs Handle to a file server session through which the file is opened.
@param aName The name of the file to be opened.
@param aFileMode The mode in which the file is to be accessed. The mode is 
defined by the TFileMode type.
@return KErrNone, if successful, otherwise one of the other system wide error 
codes.
@see Attach()
@see TFileMode
@see RFile */
	{
	RFile file;
	TInt r=file.Open(aFs,aName,aFileMode);
	if (r==KErrNone)
		Attach(file);
	return r;
	}

EXPORT_C TInt RFileBuf::Create(RFs& aFs,const TDesC& aName,TUint aFileMode)
/** Creates a file with the specified name and attaches it to this stream buffer.

The file must not already exist.

If the file cannot be created and opened, then it is not attached to this 
stream buffer.

@param aFs Handle to a file server session through which the file is created.
@param aName The name of the file to be created.
@param aFileMode The mode in which the file is to be accessed. The mode is 
defined by the TFileMode type.
@return KErrNone, if successful, otherwise one of the other system wide error 
codes.
@see Attach()
@see TFileMode
@see RFile */
	{
	RFile file;
	TInt r=file.Create(aFs,aName,aFileMode);
	if (r==KErrNone)
		Attach(file);
	return r;
	}

EXPORT_C TInt RFileBuf::Replace(RFs& aFs,const TDesC& aName,TUint aFileMode)
/** Replaces the file with the specified name and attaches it to this stream buffer.

If there is an existing file with the same name, then this function overwrites 
it. If the file does not already exist, it is created.

If the file cannot be replaced, then it is not attached to this stream buffer.

@param aFs Handle to a file server session through which the file is replaced.
@param aName The name of the file to be replaced.
@param aFileMode The mode in which the file is to be accessed. The mode is 
defined by the TFileMode type.
@return KErrNone, if successful, otherwise one of the other system wide error 
codes.
@see Attach()
@see TFileMode
@see RFile */
	{
	RFile file;
	TInt r=file.Replace(aFs,aName,aFileMode);
	if (r==KErrNone)
		Attach(file);
	return r;
	}

EXPORT_C TInt RFileBuf::Temp(RFs& aFs,const TDesC& aPath,TFileName& aName,TUint aFileMode)
/** Creates and opens a temporary file with a unique name and attaches it to this 
stream buffer.

@param aFs Handle to a file server session through which the file is created.
@param aPath The directory in which the file is created.
@param aName On return, contains the full path and file name of the file. The 
filename is guaranteed to be unique within the specified directory.
@param aFileMode The mode in which the file is to be accessed. The mode is 
defined by the TFileMode type.
@see Attach()
@see TFileMode
@see RFile */
	{
	RFile file;
	TInt r=file.Temp(aFs,aPath,aName,aFileMode);
	if (r==KErrNone)
		Attach(file);
	return r;
	}

EXPORT_C void RFileBuf::Attach(RFile& aFile,TInt aPos)
/** Attaches the specified file to this stream buffer.

The function also re-sets the intermediate buffer's read and write marks to 
the beginning of the intermediate buffer and sets the read and write stream 
positions to the specified offset within the file.

@param aFile The file to be attached.
@param aPos The offset within the file to which the read and write stream positions 
are set. By default this is zero.
@see Detach()
@see Reattach() */
	{
	__ASSERT_ALWAYS(Span(EWrite)==0,Panic(EFileWriteOutstanding));
	TUint8* base=iBase;
	SetBuf(ERead|EWrite,base,base);
	iFile=aFile;
	aFile=RFile();
	SetPos(ERead|EWrite,aPos);
	iExt=-1;
	}

EXPORT_C void RFileBuf::Close()
/** Writes any outstanding data from the intermediate buffer before freeing the 
intermediate buffer and closing the attached file. */
	{
	TInt lag=Span(EWrite);
	if (lag>0)
		{
		_TRACE_WRITE(Pos(EWrite),lag);
		File().Write(Pos(EWrite),TPtrC8(iBase,lag));
		}
	Free();
	File().Close();
	}

EXPORT_C void RFileBuf::SetSizeL(TInt aSize)
/** Changes the size of the file attached to this buffer to the specified value.

Writes any outstanding data from the intermediate buffer to the stream hosted 
by the file. Any data in the intermediate buffer that would lie beyond the 
end of the truncated file, is not written.

@param aSize The new size of the file. */
	{
	TUint8* base=iBase;
	TInt pos=Pos(EWrite);
	TInt excess=aSize-pos;
	if (excess>0)
		FileWriteL(base,Min(excess,Span(EWrite)),0);
	MovePos(ERead,Lag(ERead));
	SetBuf(ERead,base,base);
//
	_TRACE_SETSIZE(aSize);
	TInt r=File().SetSize(aSize);
	if (r!=KErrNone)
		{
		SetPos(EWrite,pos);
		iExt=-1;
		__LEAVE(r);
		}
//
	SetPos(EWrite,Min(pos+Lag(EWrite), aSize)); 
	SetBuf(EWrite,base,base);
	iExt=aSize;
	}

EXPORT_C TInt RFileBuf::UnderflowL(TInt aMaxLength)
//
// Fill the buffer's read area.
//
	{
	__ASSERT_DEBUG(Avail(ERead)==0,User::Invariant());
	TUint8* base=iBase;
	if (base==NULL)
		{
#if defined(MAP_ROM_FILES)
		if (Ptr(ERead))
			return 0;		// memory mapped ROM file
		TInt pos=0;
		TInt err = File().Seek(ESeekAddress,pos);
		if (err==KErrNone)
			{				// memory map a ROM file into the read zone
			base=(TUint8*)pos;
			TInt len=EndL();
			SetPos(ERead,len);
			SetBuf(ERead,base,base+len);
			return len;
			}
#endif
		base=AllocL();
		}

	TInt lag=Pos(ERead)-Pos(EWrite);
	TInt span=Span(EWrite);
	if (lag>=0&&lag<span)
		{
		SetBuf(ERead,base+lag,base+span);
		MovePos(ERead,span-lag);
		return span-lag;
		}

	FileWriteL(base,Span(EWrite));
	SetBuf(EWrite,base,base);
	
	// Align file position with file 'blocks' when possible
	TInt align = (Pos(ERead) + aMaxLength + KMaxFileBufReadAhead) & (KFileBufBlockSize-1);
	TInt readahead = KMaxFileBufReadAhead - align;
	if(readahead < 0)
		{
		// if read-ahead doesn't cross block boundary do it all
		readahead = KMaxFileBufReadAhead;	
		}
	TInt len=FileReadL(base, Min(iSize, aMaxLength+readahead));
	
	SetBuf(ERead,base,base+len);
	return len;
	}

EXPORT_C void RFileBuf::OverflowL()
//
// Set up the buffer's write area.
//
	{
	__ASSERT_DEBUG(Avail(EWrite)==0,User::Invariant());
	TUint8* base=iBase;
	if (base==NULL)
		base=AllocL();
	MovePos(ERead,Lag(ERead));
	SetBuf(ERead,base,base);
//
	__ASSERT_DEBUG(Lag(EWrite)==Span(EWrite),User::Invariant());
	FileWriteL(base,Lag(EWrite),0);
	SetBuf(EWrite,base,base+iSize);
	}

EXPORT_C void RFileBuf::DoRelease()
//
// Release all resources, losing any outstanding data.
//
	{
	Free();
	File().Close();
	}

EXPORT_C void RFileBuf::DoSynchL()
//
// Synchronise this buffer with its file, giving up on outstanding writes in case of failure.
//
	{
	TUint8* base=iBase;
#if defined(MAP_ROM_FILES)
	if (base!=NULL)	// do not do this for memory mapped ROM files
#endif
		{
		MovePos(ERead,Lag(ERead));
		TInt span=Span(EWrite);
		TInt rewind=span-Lag(EWrite);
		SetBuf(ERead|EWrite,base,base);
		iExt=-1;
		FileWriteL(base,span,rewind);
		}
	TInt handle = File().SubSessionHandle();
	if (handle!=0)
		{
		_TRACE_FLUSH();
		TInt r=File().Flush();
		if (r!=KErrNone&&r!=KErrAccessDenied)
			{
			__LEAVE(r);
			}
		}
	}

EXPORT_C TInt RFileBuf::DoReadL(TAny* aPtr,TInt aMaxLength)
//
// Read direct from file if asked to transfer more than a bufferful.
//
	{
	__ASSERT_DEBUG(aMaxLength>=0,Panic(EFileReadLengthNegative));
	__ASSERT_DEBUG(aMaxLength>0,Panic(EFileReadNoTransfer));
	TInt avail=Avail(ERead);
	__ASSERT_DEBUG(avail>=0&&Avail(EWrite)>=0,User::Invariant());
	if (avail>0)
		{
		TInt len=Min(aMaxLength,avail);
		TUint8* ptr=Ptr(ERead);
		aPtr=Mem::Copy(aPtr,ptr,len);
		SetPtr(ERead,ptr+len);
		aMaxLength-=len;
		if (aMaxLength==0)
			return len; // that's it
		}
	__ASSERT_DEBUG(Avail(ERead)==0,User::Invariant());
	if (aMaxLength<iSize)
		return avail+TStreamBuf::DoReadL(aPtr,aMaxLength);
//
	TUint8* base=iBase;
	FileWriteL(base,Span(EWrite));
	SetBuf(ERead|EWrite,base,base);
	return avail+FileReadL(aPtr,aMaxLength);
	}

EXPORT_C TInt RFileBuf::DoReadL(TDes8& aDes,TInt aMaxLength,TRequestStatus& aStatus)
//
// Read up to aMaxLength bytes asynchronously.
//
	{
//#pragma message( __FILE__ " : 'RFileBuf::DoReadL(TDes8&,TInt,TRequestStatus&)' not implemented" )
	__ASSERT_DEBUG(aMaxLength<=aDes.MaxLength(),Panic(EFileReadBeyondEnd));
	aDes.SetLength(DoReadL((TUint8*)aDes.Ptr(),aMaxLength));
	TRequestStatus* stat=&aStatus;
	User::RequestComplete(stat,KErrNone);
	return aMaxLength;
	}

EXPORT_C void RFileBuf::DoWriteL(const TAny* aPtr,TInt aLength)
//
// Write direct to file if asked to transfer more than a bufferful.
//
	{
	__ASSERT_DEBUG(aLength>=0,Panic(EFileWriteLengthNegative));
	__ASSERT_DEBUG(aLength>0,Panic(EFileWriteNoTransfer));
	TInt avail=Avail(EWrite);
	__ASSERT_DEBUG(Avail(ERead)>=0&&avail>=0,User::Invariant());
	if (avail>0)
		{
		TInt len=Min(aLength,avail);
		SetPtr(EWrite,Mem::Copy(Ptr(EWrite),aPtr,len));
		aLength-=len;
		if (aLength==0)
			return; // done
//
		aPtr=(TUint8*)aPtr+len;
		}
	__ASSERT_DEBUG(Avail(EWrite)==0,User::Invariant());
	if (aLength<iSize)
		TStreamBuf::DoWriteL(aPtr,aLength);
	else
		{
		__ASSERT_DEBUG(Lag(EWrite)==Span(EWrite),User::Invariant());
		TUint8* base=iBase;
		FileWriteL(base,Lag(EWrite),0);
		MovePos(ERead,Lag(ERead));
		SetBuf(ERead|EWrite,base,base);
		FileWriteL(aPtr,aLength,0);
		}
	}

EXPORT_C TInt RFileBuf::DoWriteL(const TDesC8& aDes,TInt aMaxLength,TRequestStatus& aStatus)
//
// Write up to aMaxLength bytes asynchronously.
//
	{
//#pragma message( __FILE__ " : 'RFileBuf::DoWriteL(const TDesC8&,TInt,TRequestStatus&)' not implemented" )
	__ASSERT_DEBUG(aMaxLength<=aDes.Length(),Panic(EFileWriteBeyondEnd));
	DoWriteL(aDes.Ptr(),aMaxLength);
	TRequestStatus* stat=&aStatus;
	User::RequestComplete(stat,KErrNone);
	return aMaxLength;
	}

EXPORT_C TStreamPos RFileBuf::DoSeekL(TMark aMark,TStreamLocation aLocation,TInt anOffset)
//
// Position the mark(s) indicated by aMark at anOffset from aLocation.
//
	{
	TUint8* base=iBase;
	TInt end=EndL();
//
	switch (aLocation)
		{
	case EStreamBeginning:
		break;
	case EStreamMark:
		anOffset+=Mark(aMark);
		break;
	case EStreamEnd:
		anOffset+=end;
		break;
	default:
		Panic(EFileLocationInvalid);
		break;
		}
	TInt r=KErrNone;
	if (anOffset<0)
		{
		anOffset=0;
		r=KErrEof;
		}
	else if (anOffset>end)
		{
		anOffset=end;
		r=KErrEof;
		}
//
	__ASSERT_ALWAYS(!(aMark&~(ERead|EWrite)),Panic(EFileMarkInvalid));
	if (aMark&ERead)
		{
		TInt lag=anOffset-Pos(ERead);
#if defined(MAP_ROM_FILES)
		if (base==NULL&&End(ERead)!=NULL)	// memory mapped
			SetPtr(ERead,End(ERead)+lag);
		else
#endif
		if (lag>=base-End(ERead)&&lag<=0)
			SetPtr(ERead,End(ERead)+lag);
		else
			{
			SetPos(ERead,anOffset);
			SetBuf(ERead,base,base);
			}
		}
	if (aMark&EWrite)
		{
		TInt lag=anOffset-Pos(EWrite);
		TInt span=Span(EWrite);
		if (lag>=0&&lag<=span)
			{
			SetLimit(EWrite,base+span);
			SetPtr(EWrite,base+lag);
			}
		else
			{
			FileWriteL(base,span,0);
			SetPos(EWrite,anOffset);
			SetBuf(EWrite,base,base);
			}
		}
	__LEAVE_IF_ERROR(r);
	return TStreamPos(anOffset);
	}

TUint8* RFileBuf::AllocL()
//
// Allocate space and return a pointer to this buffer's buffer space
//
	{
	__ASSERT_DEBUG(iBase==NULL && iSize>0,User::Invariant());
//
	TUint8* base=(TUint8*)User::AllocL(iSize);
	iBase=base;
	SetBuf(ERead|EWrite,base,base);
	return base;
	}

void RFileBuf::Free()
//
// Free this buffer's buffer space.
//
	{
	User::Free(iBase);
	iBase=NULL;
	SetBuf(ERead|EWrite,NULL,NULL);
	}

void RFileBuf::SetPos(TMark aMark,TInt aPos)
//
// Set the file position for the mark(s) indicated by aMark
//
	{
	__ASSERT_ALWAYS(!(aMark&~(ERead|EWrite)),Panic(EFileMarkInvalid));
	if (aMark&ERead)
		SetPos(ERead,aPos);
	if (aMark&EWrite)
		SetPos(EWrite,aPos);
	}

TInt RFileBuf::FileReadL(TAny* aPtr,TInt aMaxLength)
//
// Read from the file at the current read position.
//
	{
	__ASSERT_DEBUG(aMaxLength>=0,Panic(EFileReadLengthNegative));
	if (aMaxLength==0)
		return 0;
//
	TPtr8 des((TUint8*)aPtr,aMaxLength);
	TInt pos=Pos(ERead);
	__LEAVE_IF_ERROR(File().Read(pos,des));
	TInt len=des.Length();
	_TRACE_READ(pos,len);
	pos+=len;
	if (len<aMaxLength)
		iExt=pos; // end-of-file encountered
	SetPos(ERead,pos);
	return len;
	}

void RFileBuf::FileWriteL(const TAny* aPtr,TInt aLength)
//
// Write to the file at the current write position
// Use write buffer status to determine the rewind
//
	{
	FileWriteL(aPtr,aLength,Span(EWrite)-Lag(EWrite));
	}

void RFileBuf::FileWriteL(const TAny* aPtr,TInt aLength,TInt aRewind)
//
// Write to the file at the current write position.
// Rewind write position after write
//
	{
	__ASSERT_DEBUG(aLength>=0,Panic(EFileWriteLengthNegative));
	if (aLength==0)
		return;
//
	TInt ext=iExt;
	iExt=-1;
	TInt pos=Pos(EWrite);
	_TRACE_WRITE(pos,aLength);
#ifdef SIMULATE_PARTIAL_WRITE
	TPtrC8 ptr((TUint8*)aPtr,aLength);
	TInt partial = aLength >> 1;
	if (partial)
		{
		__LEAVE_IF_ERROR(File().Write(pos, ptr.Left(partial)));
		}
	__LEAVE_IF_ERROR(File().Write(pos + partial, ptr.Mid(partial)));
#else

#if defined SYSLIBS_TEST && defined _DEBUG
	const TInt KDefaultMediaBlockSize = 512;
	TInt startSectorAddr = pos & ~(KDefaultMediaBlockSize - 1);
	TInt endSectorAddr = (pos + aLength - 1) & ~(KDefaultMediaBlockSize - 1);
	if(startSectorAddr != endSectorAddr && aLength < KDefaultMediaBlockSize)
		{
		TInt len1 = startSectorAddr + KDefaultMediaBlockSize - 	pos;
		TInt len2 = aLength - len1;
		__LEAVE_IF_ERROR(File().Write(pos, TPtrC8((TUint8*)aPtr, len1)));
		__LEAVE_IF_ERROR(File().Write(pos + len1, TPtrC8((TUint8*)aPtr + len1, len2)));
		}
	else
		{
		__LEAVE_IF_ERROR(File().Write(pos,TPtrC8((TUint8*)aPtr,aLength)));
		}
#else //SYSLIBS_TEST		
	__LEAVE_IF_ERROR(File().Write(pos,TPtrC8((TUint8*)aPtr,aLength)));
#endif//SYSLIBS_TEST

#endif
	pos+=aLength;
	if (ext>=0)
		iExt=Max(pos,ext);
	SetPos(EWrite,pos-aRewind);
	}

TInt RFileBuf::EndL()
//
// Determine the end of the file.
//
	{
	TInt ext=iExt;
	if (ext<0)
		{
		_TRACE_SIZE();
		__LEAVE_IF_ERROR(File().Size(ext));
		iExt=ext;
		}
	return Max(ext,Reach(EWrite));
	}

TInt RFileBuf::Mark(TMark aMark) const
//
// Return the position of the mark indicated by aMark.
//
	{
	if (aMark==ERead)
		return Mark(ERead);
//
	__ASSERT_ALWAYS(aMark==EWrite,Panic(EFileMarkInvalid));
	return Mark(EWrite);
	}