/*

* Copyright (c) 2004-2007 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:  Handler for XML file modify. Defines the class to store and modify XML data.

*

*/

#ifdef _DEBUG

#include <driveinfo.h>

#include <pathinfo.h>

#endif

#include "cxmlhandler.h"

#include "clog.h"

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

//

// CXmlHandler::NewL

//

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

CXmlHandler* CXmlHandler::NewL()

	{

		CXmlHandler *self = NewLC();

		CleanupStack::Pop();	// self

		return self;

	}

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

//

// CXmlHandler::NewLC

//

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

CXmlHandler* CXmlHandler::NewLC()

	{

		CXmlHandler *self = new (ELeave) CXmlHandler();

		CleanupStack::PushL(self);

		self->ConstructL();

		return self;

	}

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

//

// CXmlHandler::~CXmlHandler

//

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

CXmlHandler::~CXmlHandler()

{

	if(iDataBuf)

		delete iDataBuf;

	iDataBuf = NULL;

	Reset();

	iFs.Close();

}

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

//

// CXmlHandler::ConstructL

//

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

void CXmlHandler::ConstructL()

{

	LOG("[CXmlHandler::ConstructL]\t");

	User::LeaveIfError( iFs.Connect() );

	Reset();

}

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

//

// CXmlHandler::InitFromFileL

//

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

void CXmlHandler::InitFromFileL(const TDesC& aFile, const TInt aId)

{

	LOG("[CXmlHandler::InitFromFileL]\t");

	Reset();

	ReadFileL(aFile);

	iBufferId = aId;

	LOG("[CXmlHandler::InitFromFileL]\t Done.");

}

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

//

// CXmlHandler::InitFromBufferL

//

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

void CXmlHandler::InitFromBufferL(const TDesC8& aBuffer, const TInt aId)

{

	LOG("[CXmlHandler::InitFromBufferL]\t");

	Reset();

	if(0 >= aBuffer.Length())

	{

		User::Leave(KErrArgument);

	}

	iDataBuf = static_cast<HBufC8*>(User::LeaveIfNull(aBuffer.AllocL()));

	iBufferId = aId;

	LOG("[CXmlHandler::InitFromBufferL]\t Done.");

}

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

//

// CXmlHandler::Reset

//

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

void CXmlHandler::Reset()

{

	LOG("[CXmlHandler::Reset]\t");

	if(iDataBuf)

		delete iDataBuf;

	iDataBuf = NULL;

	iBufferId = KErrNotFound;

}

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

//

// CXmlHandler::Reset

//

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

TInt CXmlHandler::BufferId()

{

	return iBufferId;

}

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

//

// CXmlHandler::Reset

//

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

TPtrC8 CXmlHandler::Buffer()

{

	if(iDataBuf)

		return iDataBuf->Des();

	return KNullDesC8();

}

// PRIVATE

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

//

// CXmlHandler::CXmlHandler

//

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

CXmlHandler::CXmlHandler()

{

}

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

//

// CXmlHandler::FinalizeBufferL

//

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

TPtrC8 CXmlHandler::FinalizeBufferL(const TDesC8& aTag)

{

	LOG("[CXmlHandler]\t FinalizeBufferL");

	User::LeaveIfNull(iDataBuf);

	// Cut the template to the end tag

	TInt pos = iDataBuf->Find(aTag);

	if(KErrNotFound == pos)

		User::Leave(KErrCorrupt);

	TInt dataLen = pos + aTag.Length();

	TPtrC8 tail = iDataBuf->Left(dataLen);

	return tail;

}

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

//

// CXmlHandler::DeleteBufferData

//

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

void CXmlHandler::DeleteBufferData(TInt aOffset, TInt aLength)

{

	iDataBuf->Des().Delete(aOffset, aLength);

}

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

//

// CXmlHandler::ReadL

//

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

void CXmlHandler::ReadFileL(const TDesC& aFileName)

{

	LOG("[CXmlHandler]\t ReadFileL");

	// Open the template file and read it into buffer

	RFile templateFile;

	CleanupClosePushL(templateFile);

	User::LeaveIfError( templateFile.Open( iFs, aFileName, EFileRead) );

	TInt fileSize = 0;

	TInt err = templateFile.Size(fileSize);

	if(KErrNone != err)

		fileSize = KBtMaxFileSize;

	iDataBuf = HBufC8::NewL(fileSize);

	TPtr8 bufferPtr( iDataBuf->Des() );

	bufferPtr.Zero();

	templateFile.Read(bufferPtr);

	CleanupStack::PopAndDestroy(&templateFile);

}

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

//

// CXmlHandler::GetDataL

//

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

TPtrC8 CXmlHandler::GetDataL(const TDesC8 &aStart, const TDesC8 &aEnd, TInt& aOffset)

{

	User::LeaveIfNull(iDataBuf);

	return ParseValue(iDataBuf->Des(), aStart, aEnd, aOffset);

}

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

//

// CXmlHandler::GetDataListL

//

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

void CXmlHandler::GetDataListL(const TDesC8 &aStart, const TDesC8 &aEnd, CDesC8ArrayFlat& aList)

{

	User::LeaveIfNull(iDataBuf);

	ParseValueListL(iDataBuf->Des(), aStart, aEnd, aList);

}

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

//

// CXmlHandler::ParseValue

//

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

TPtrC8 CXmlHandler::ParseValue(const TDesC8 &aData, const TDesC8 &aStart, const TDesC8 &aEnd, TInt& aOffset)

{

//	LOG82("[CXmlHandler::ParseValue]\t s: %S, e: %S", &aStart, &aEnd);

	aOffset = aData.Find(aStart);

	if(0 > aOffset)

	{

		return KNullDesC8();

	}

	TInt end = aData.Find(aEnd);

	TInt len = end-aOffset-aStart.Length();

	if(0 >= len)

	{

		aOffset = end;

		return KNullDesC8();

	}

	return aData.Mid(aOffset+aStart.Length(), len);

}

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

//

// CXmlHandler::ParseValueList

//

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

void CXmlHandler::ParseValueListL(const TDesC8 &aData, const TDesC8 &aStart, const TDesC8 &aEnd, CDesC8ArrayFlat& aList)

{

	LOG("[CXmlHandler::ParseValueListL]\t ");

	TPtrC8 tmpPtr = aData;

	TInt offset = tmpPtr.Find(aStart);

	while(offset != KErrNotFound)

	{

		TInt end = tmpPtr.Find(aEnd);

		if(0 > end)

		{

			return;

		}

		TPtrC8 valuePtr = tmpPtr.Mid(offset+aStart.Length(), end-offset-aStart.Length());

		HBufC8* listEntry = valuePtr.AllocLC();

		aList.AppendL(listEntry->Des());

		CleanupStack::PopAndDestroy();	// listEntry

		tmpPtr.Set( tmpPtr.Right(tmpPtr.Length()-(end+aEnd.Length()) ) );

		offset = tmpPtr.Find(aStart);

	}

}

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

//

// CXmlHandler::ComposeDataL

//

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

void CXmlHandler::ComposeDataL(const TInt aValue, const TDesC8 &aTag)

{

	TBuf8<KDefaultRealWidth> valueStr;

	valueStr.Zero();

	valueStr.AppendNum(aValue);

	ComposeDataL(valueStr, aTag);

}

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

//

// CXmlHandler::ComposeDataL

//

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

void CXmlHandler::ComposeDataL(const TDesC8 &aData, const TDesC8 &aTag)

{

	User::LeaveIfNull(iDataBuf);

	TInt pos = iDataBuf->Find(aTag);

	if(KErrNotFound == pos)

		User::Leave(KErrCorrupt);

	while(KErrNotFound != pos)

	{

		TInt requiredSize = iDataBuf->Des().Length() + aData.Length();

		if(iDataBuf->Des().MaxLength() < requiredSize)

		{

			iDataBuf = iDataBuf->ReAllocL(requiredSize);

		}

		iDataBuf->Des().Replace(pos, aTag.Length(), aData);

		pos = iDataBuf->Find(aTag);

	}

}

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

//

// CXmlHandler::InsertDataL

//

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

void CXmlHandler::InsertDataL(const TDesC8 &aData, const TInt aOffset)

{

	TInt requiredSize = iDataBuf->Des().Length() + aData.Length();

	if(iDataBuf->Des().MaxLength() < requiredSize)

	{

		iDataBuf = iDataBuf->ReAllocL(requiredSize);

	}

	iDataBuf->Des().Insert(aOffset, aData);

}

// End of file