// Copyright (c) 2003-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 <e32std.h>
#include <ecom/implementationproxy.h>

#include <xml/contenthandler.h>
#include <xml/stringdictionarycollection.h>

#include "xmlparserplugin.h"

using namespace Xml;

const TInt KExpatBufferSize = 2048;

MParser* CXmlParserPlugin::EcomNewL(TAny* aInitParams)
	{
	// The cast to the MParser interface is a particular to the Xml Framework.  Ecom plug-ins usually
	// return the pointer to the C class.
	return static_cast<MParser*>(CXmlParserPlugin::NewL(aInitParams));
	}

/*
CXmlParserPlugin::NewL is for testing and can only be accessed by linking directly to XmlParser.o

aDebugFailCount is used to configure parser heap failure during construction testing - the
usual heap failure macros do not work for our purposes here as it is a private heap.  See
CExpat for details.
*/
CXmlParserPlugin* CXmlParserPlugin::NewL(TAny* aInitParams, TInt aDebugFailCount)
	{
	TParserInitParams* p = reinterpret_cast<TParserInitParams*>(aInitParams);

	CXmlParserPlugin* self = new(ELeave) CXmlParserPlugin(p->iContentHandler);
	
	CleanupStack::PushL(self);
	self->ConstructL(p->iStringDictionaryCollection, p->iCharSetConverter, p->iElementStack, aDebugFailCount);
	CleanupStack::Pop(self);

	return self;
	}

CXmlParserPlugin::CXmlParserPlugin(MContentHandler* aContentHandler) :
	iContentHandler(*aContentHandler)
	{
	}

void CXmlParserPlugin::ConstructL(RStringDictionaryCollection* aStringDictionaryCollection, CCharSetConverter* aCharSetConverter,
							RElementStack* aElementStack, TInt aDebugFailCount)
	{
	iExpat = CExpat::NewL(iContentHandler, aStringDictionaryCollection->StringPool(), *aCharSetConverter, *aElementStack, aDebugFailCount);
	}

/*
Used by framework to delete this object
*/
void CXmlParserPlugin::Release()
	{
	delete this;
	}

/*
Private destructor - only accessible from Release method
*/
CXmlParserPlugin::~CXmlParserPlugin()
	{
	delete iExpat;
	}


TInt CXmlParserPlugin::EnableFeature(TInt aParseMode)
	{
	return iExpat->EnableFeature(aParseMode);
	}

TInt CXmlParserPlugin::DisableFeature(TInt aParseMode)
	{
	return iExpat->DisableFeature(aParseMode);
	}

TBool CXmlParserPlugin::IsFeatureEnabled(TInt aParseMode) const
	{
	return iExpat->IsFeatureEnabled(aParseMode);
	}


void CXmlParserPlugin::ParseChunkL(const TDesC8& aChunk)
	{
	// If a Reset failed, iExpatResetError will have been set.  Here we report it by leaving with the error,
	// which will in turn be passed to MContentHandler::OnError.
	User::LeaveIfError(iExpatResetError);
	ParseChunkInPartsL(aChunk);
	}

void CXmlParserPlugin::ParseLastChunkL(const TDesC8& aFinalChunk)
	{
	// If a Reset failed, iExpatResetError will have been set.  Here we report it by leaving with the error,
	// which will in turn be passed to MContentHandler::OnError.
	User::LeaveIfError(iExpatResetError);

	// Could be that there is some enourmous piece of data here.
	ParseChunkInPartsL(aFinalChunk);
	
	// We need a buffer even though we have nothing to parse,
	// as any previous buffers are destroyed.
	// We are just going through the sequence of completing the parsing gracefully.
	TDes8& buf = iExpat->GetBufferL(1);
	buf = _L8("");
	iExpat->ParseLastL();

	// TRAP doesn't set its result variable unless a leave occurs - so reset it first.
	iExpatResetError = KErrNone;

	// The Reset interface of the Xml Framework provides no mechanism for failure reporting.  If iExpat.ResetL
	// fails we set iExpatResetError.  The error will be reported to MContentHandler::OnError when an attempt
	// is made by the client to begin parsing (see RunL).
	TRAP(iExpatResetError, iExpat->ResetL());
	}

void CXmlParserPlugin::ParseChunkInPartsL(const TDesC8& aChunk)
	{
	// The Expat parser has a buffer of 64k that it stores its state variables in 
	// and allocates its heap memory from.
	// We do this because we may need to upgrade the version of Expat later and this
	// makes it easier.
	// Beacuse of this we copy the buffer that could have a performance issue, 
	// we will address this if it later arises.
	// We parse the descriptor in parts as we do not want to blow the buffer.
	// Even though the descriptor may already be passed in chunks they may be too big.
	
	if (aChunk.Length() == 0)
		{
		return;
		}

	TPtrC8 part;
	TInt offset = 0;
	TInt size = aChunk.Size();
	TInt partSize = size;

	do
		{
		TDes8& buf = iExpat->GetBufferL(KExpatBufferSize);

		if (partSize > KExpatBufferSize) 
			{	
			partSize = KExpatBufferSize;
			}
			
		part.Set (aChunk.Mid(offset, partSize));

		buf = part;
		iExpat->ParseL();

		// The remaining part stats.
		offset += part.Length();
		partSize = size - offset;

		} while (partSize);
	}

void CXmlParserPlugin::SetContentSink(class MContentHandler &aContentSink)
	{
	iExpat->SetContentSink(aContentSink);
	}

RHeap* CXmlParserPlugin::GetInternalHeap() const
	{
	return iExpat->GetInternalHeap();
	}

//
// Ecom implementation infrastructure
//

// KUidXmlParserPlugin is the unique UID for our implementation of the MParser interface.  This interface is
// 'published' as KParserInterfaceUid defined in Xml/FrameworkConstants.h.  KUidXmlParserPlugin must be
// the same as the value of implementation_uid in the file 101faa0a.rss
const TInt KUidXmlParserPlugin = 0x101FAA0C;

const TImplementationProxy ImplementationTable[] = {
	IMPLEMENTATION_PROXY_ENTRY(KUidXmlParserPlugin, CXmlParserPlugin::EcomNewL)
};

EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)
	{
	aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy);

	return ImplementationTable;
	}