// Copyright (c) 2008-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:

// e32\debug\crashMonitor\src\scmbytestreamutil.cpp

// some utility classes for writing data to flash buffer

// 

//

/**

 @file

 @internalTechnology

*/

#include "scmbytestreamutil.h"

#include "scmtrace.h"

namespace Debug 

	{

	/**

	 * TByteStreamBase Constructor 

	 * @param aBuffer - pointer to buffer that this utility will use

	 */	

	TByteStreamBase::TByteStreamBase(TUint8* aBuffer) 

		: iBuffer(aBuffer)

		, iPos(0) 

		{

		}

	/**

	 * SetPosition

	 * @param aBuffer - Sets iPos

	 * @return void

	 */	

	void TByteStreamBase::SetPosition(TInt aPos)

		{

		iPos = aPos;

		}

	/**

	 * CurrentPosition

	 * @param aBuffer - Returns the current value of iPos

	 * @return Tint

	 */	

	TInt TByteStreamBase::CurrentPosition() const

		{

		return iPos;

		}

	/**

	 * TByteStreamReader Constructor 

	 * @param aBuffer - pointer to buffer that this utility will use

	 */	

	TByteStreamReader::TByteStreamReader(TUint8* aBuffer) 

		: TByteStreamBase(aBuffer)

		{	

		}

	/**

	 * Constructor for TByteStreamWriter

	 * @param aBuffer buffer for writing

	 * @param aPhysEnabled whether or not physical writing to another media is enabled

	 */

	TByteStreamWriter::TByteStreamWriter(TUint8* aBuffer, TBool aPhysEnabled) 

		: TByteStreamBase(aBuffer)

		, iPhysEnabled(aPhysEnabled)

		, iBytesWritten(0)

		{			

		}

	/**

	 * Writes a byte to the buffer

	 * @param aValue Byte to write

	 */

	void TByteStreamWriter::WriteByte(TUint8 aValue)

		{

		if(iBuffer)

			{

			iBuffer[iPos++] = aValue;

			++iBytesWritten;

			}

		}

	/**

	 * Resets the byte counter back to zero

	 */

	void TByteStreamWriter::ResetBytesWritten()

		{

		iBytesWritten = 0;

		}

	/**

	 * TCachedByteStreamWriter Constructor 

	 * @param aBuffer - pointer to buffer that this utility will use

	 * @param aCacheSize - suggested length of cache to use if greater than EMaxCache

	 * 					cache length of EMaxCache will be used

	 */

	TCachedByteStreamWriter::TCachedByteStreamWriter(TUint8* aCacheBuffer, TInt aCacheSize, TBool aPhysEnabled) 

		: TByteStreamWriter(NULL, aPhysEnabled)

		, iCacheSize(aCacheSize)

		, iCacheBuffer(aCacheBuffer)

		, iPhysicalWriter(NULL)

		{

		}

	/**

	 * FlushCache 

	 * Writes the contents of the cache to buffer amd/or to physical writer implementation

	 * if one is currently set

	 * @return void

	 */	

	TInt TCachedByteStreamWriter::FlushCache()

		{			

		TInt padCount = iCacheSize - iPos;

		if(padCount > 0)

			{		

			for(TInt i=0;i<padCount;i++)

				{

				iCacheBuffer[iPos++] = 0;

				}		

			}

		if(iPhysEnabled)

			{

			if(iPhysicalWriter) // do we have a writer to send the cache data to

				{

				iPhysicalWriter->DoPhysicalWrite(iCacheBuffer, iBytesWritten, iPos);

				}

			}

		iPos = 0;

		return KErrNone;

		}

	/**

	 * Writes a byte to the cached buffer

	 * @param aValue Byte to write

	 */

	void TCachedByteStreamWriter::WriteByte(TUint8 aValue)

		{

		if(iPos == iCacheSize)

			{

			FlushCache();

			}		

		iCacheBuffer[iPos++] = aValue;	

		++iBytesWritten;

		}

	/**

	 * CurrentPosition

	 * @param aBuffer -  need to return the position in buffer plus the write pos into cache

	 * @return Tint

	 */	

	TInt TCachedByteStreamWriter::CurrentPosition() const

		{

		return iBytesWritten;	

		}

	/**

	 * SetWriterImpl

	 * @param aPhysicalWriter - sets the physical writer implementation to be used when the cache is flushed

	 * 							pass NULL to remove a previous writer implementation

	 * @return void

	 */	

	void TCachedByteStreamWriter::SetWriterImpl(MPhysicalWriterImpl* aPhysicalWriter)

		{

		iPhysicalWriter = aPhysicalWriter;

		}	

	}

//eof