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

// XML Deserializer implementation

//

#include <xml/dom/xmlengdeserializer.h>

#include <xml/dom/xmlengerrors.h>

#include "xmlengdeserializerxop.h"

#include "xmlengdeserializergzip.h"

#include <xml/utils/xmlengxestd.h>

#include <xml/utils/xmlengxestrings.h>

#include <xml/dom/xmlengdatacontainer.h>

#include <xml/dom/xmlengparsingoptions.h>

#include <xml/dom/xmlengserializeerrors.h>

#include <xml/parser.h>

#include <xml/parserfeature.h>

#include <xml/matchdata.h>

#include <f32file.h>

_LIT8(KXmlMimeType, "text/xml");

_LIT8(KParserType,"libxml2");

using namespace Xml;

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

// Creates an instance of CXmlEngDeserializer

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

//

EXPORT_C CXmlEngDeserializer* CXmlEngDeserializer::NewL( MContentHandler& aContentHandler,	TXmlEngDeserializerType aType ) 															

    {

	switch(aType)

		{

		case EDeserializerXOP:

			{

			return CXmlEngDeserializerXOP::NewL( aContentHandler, EFalse );			

			}

		case EDeserializerXOPInfoset:

			{

			return CXmlEngDeserializerXOP::NewL( aContentHandler, ETrue );			

			}			

		case EDeserializerGZip:

			{

			return CXmlEngDeserializerGZIP::NewL( aContentHandler );

			}

		case EDeserializerDefault:		

		default:

		    {

	        CXmlEngDeserializer* self = new (ELeave) CXmlEngDeserializer; 

	        CleanupStack::PushL(self);

	        self->ConstructL( aContentHandler );

	        CleanupStack::Pop(self);

	        return self;

		    }

        }

    }

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

// Set input type as file

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

//

EXPORT_C void CXmlEngDeserializer::SetInputFileL(const TDesC& aFileName)

	{

	if(iInputFileName)

	    {

	    delete iInputFileName;

	    iInputFileName=NULL;

	    }

	iInputFileName = aFileName.AllocL();

	iSerializationOutput = EDeserializeFromFile;

	}

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

// Set input type as buffer

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

//

EXPORT_C void CXmlEngDeserializer::SetInputBuffer(const TDesC8& aBuffer)

	{

	iBuffer.Set(aBuffer);

	iSerializationOutput = EDeserializeFromBuffer;

	}

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

// Set content handler

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

//

EXPORT_C void CXmlEngDeserializer::SetContentHandlerL(MContentHandler& aContentHandler)

	{

	TInt i;

   	delete iParser;

   	iParser = NULL;

   	ConstructL( aContentHandler );

   	for(i=1; i<=ELastFeature; i*=2)

   		{

   		if(i & iFeatures)

   			{

   			iParser->EnableFeature(i);

   			}   			

   		}

	}	

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

// Set parsing options

// May be used to alter deserializer output

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

//	

EXPORT_C void CXmlEngDeserializer::SetParsingOptions(TXmlEngParsingOptions& aOptions)

	{

	iParsingOptions = aOptions;

	}

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

// Set parsing options

// May be used to alter deserializer output

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

//	

EXPORT_C const TXmlEngParsingOptions& CXmlEngDeserializer::ParsingOptions()

	{

	return iParsingOptions;

	}

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

// Set external data array

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

//

EXPORT_C void CXmlEngDeserializer::UseExternalDataL(RArray<TXmlEngDataContainer>& aList)

	{

	iDataList = &aList;

	}

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

// Fetches external data registered in this deserializer

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

//

EXPORT_C RArray<TXmlEngDataContainer>* CXmlEngDeserializer::ExternalData()

	{

	return iDataList;

	}

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

// Enables CParser feature

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

//

EXPORT_C TInt CXmlEngDeserializer::EnableFeature(TInt aParserFeature)

	{

	TInt res = iParser->EnableFeature(aParserFeature);

	if(!res)

		{

		iFeatures |= aParserFeature;	

		}

	return res; 

	}

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

// Disables CParser feature

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

//

EXPORT_C TInt CXmlEngDeserializer::DisableFeature(TInt aParserFeature)

	{

	TInt res = iParser->DisableFeature(aParserFeature);

	if(!res)

		{

		iFeatures &= ~aParserFeature;	

		}

	return res;	

	}

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

// Checks if a feature is enabled

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

//	

EXPORT_C TBool CXmlEngDeserializer::IsFeatureEnabled(TInt aParserFeature) const

	{

	return iParser->IsFeatureEnabled(aParserFeature);

	}

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

// Serializes TXmlEngNode to file

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

//

EXPORT_C void CXmlEngDeserializer::DeserializeL()

    {

	switch(iSerializationOutput)

		{

		case EDeserializeFromFile:

			{

			if(!iInputFileName)

				{

				User::Leave(KXmlEngErrNoParameters);

				}

		    RFs fs; 

		    CleanupClosePushL(fs);

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

		    DeserializeL( fs, iInputFileName->Des() );			

			CleanupStack::PopAndDestroy(&fs);

			break;

			}

		case EDeserializeFromBuffer:

			{

			if(iBuffer.Length() == 0)

				{

				User::Leave(KXmlEngErrNoParameters);

				}

			DeserializeL(iBuffer);			

			break;

			}

		case EDeserializeFromStream:

			{

			// Currently this feature is not supported. Implement when need arises or remove.

			User::Leave(KErrNotSupported);

			}			

		default:

			{

			User::Leave(KErrNotSupported);

			break;

			}						

		}   

    }

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

// Deserialize document

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

//

EXPORT_C void CXmlEngDeserializer::DeserializeL( const TDesC& aFileName,

											const TXmlEngParsingOptions& /*aOptions*/) 

    {

	RFs fs; 

	CleanupClosePushL(fs);

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

	ParseL(*iParser,fs,aFileName);			

	CleanupStack::PopAndDestroy(&fs);	

	}

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

// Deserialize document

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

//

EXPORT_C void CXmlEngDeserializer::DeserializeL( RFs& aRFs, 

											const TDesC& aFileName,

											const TXmlEngParsingOptions& /*aOptions*/) 

    {

	ParseL(*iParser,aRFs,aFileName);	

	}

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

// Deserialize document

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

//

EXPORT_C void CXmlEngDeserializer::DeserializeL( const TDesC8& aBuffer,

											const TXmlEngParsingOptions& /*aOptions*/) 

    {

  	ParseL(*iParser,aBuffer);

    }        

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

// Default Constructor

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

//

CXmlEngDeserializer::CXmlEngDeserializer()

    { 

	iParsingOptions = TXmlEngParsingOptions();           

    }

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

// Destructor

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

//

CXmlEngDeserializer::~CXmlEngDeserializer()

    {

   	delete iParser; 

   	delete iInputFileName;  

    }

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

// 2nd phase constructor

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

//

void CXmlEngDeserializer::ConstructL( MContentHandler& aContentHandler )

    {

    if(iParser)

    	{

    	delete iParser;

    	iParser = NULL;

    	}

    CMatchData* matchData = CMatchData::NewLC();

    matchData->SetMimeTypeL(KXmlMimeType);

    matchData->SetVariantL(KParserType); 

    iParser = CParser::NewL(*matchData, aContentHandler);

    CleanupStack::PopAndDestroy(&(*matchData));

    }

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

// Retrieves pointer to data container referenced by CID 

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

//

TXmlEngDataContainer* CXmlEngDeserializer::GetDataContainer(const TDesC8& aCid)

	{

	for(TInt i = 0; i < iDataList->Count(); i++)

		{

		if( (*iDataList)[i].Cid() == aCid )

			{

			return &(*iDataList)[i];

			}

		}	

	return NULL;

	}