/*

* Copyright (c) 2004 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:  SyncML command struct implementations.

*

*/

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

// Includes

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

#include "smldtd.h"

#include "smlsyncmltags.h"

#include "smlmetinfdtd.h"

#include "smldevinfdtd.h"

#include "WBXMLSyncMLParser.h"

#include "WBXMLParserError.h"

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

// Macros

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

#define CHECK_NO_DUPLICATE(a) if( a ) { User::Leave(KErrParserErrorInvalidDocument); }

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

// Helper functions

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

CXMLElement* AddPCDataL( SmlPcdataListPtr_t* aList )

	{

	SmlPcdataListPtr_t itemL = new (ELeave) SmlPcdataList_t();

	CleanupStack::PushL(itemL);

	itemL->data = new (ELeave) SmlPcdata_t();

	GenericListAddL(aList, itemL);

	CleanupStack::Pop(); // itemL

	return itemL->data;

	}

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

CXMLElement* AddItemL( SmlItemListPtr_t* aList )

	{

	SmlItemListPtr_t itemL = new (ELeave) SmlItemList_t();

	CleanupStack::PushL(itemL);

	itemL->item = new (ELeave) SmlItem_t();

	GenericListAddL(aList, itemL);

	CleanupStack::Pop(); // itemL

	return itemL->item;

	}

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

CXMLElement* AddMapItemL( SmlMapItemListPtr_t* aList )

	{

	SmlMapItemListPtr_t itemL = new (ELeave) SmlMapItemList_t();

	CleanupStack::PushL(itemL);

	itemL->mapItem = new (ELeave) SmlMapItem_t();

	GenericListAddL(aList, itemL);

	CleanupStack::Pop(); // itemL

	return itemL->mapItem;

	}

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

CXMLElement* AddSourceListL( SmlSourceListPtr_t* aList )

	{

	SmlSourceListPtr_t itemL = new (ELeave) SmlSourceList_t();

	CleanupStack::PushL(itemL);

	itemL->source = new (ELeave) SmlSource_t();

	GenericListAddL(aList, itemL);

	CleanupStack::Pop(); // itemL

	return itemL->source;

	}

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

CXMLElement* AddTargetRefL( SmlTargetRefListPtr_t* aList )

	{

	SmlTargetRefListPtr_t itemL = new (ELeave) SmlTargetRefList_t();

	CleanupStack::PushL(itemL);

	itemL->targetRef = new (ELeave) SmlPcdata_t();

	GenericListAddL(aList, itemL);

	CleanupStack::Pop(); // itemL

	return itemL->targetRef;

	}

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

CXMLElement* AddSourceRefL( SmlSourceRefListPtr_t* aList )

	{

	SmlSourceRefListPtr_t itemL = new (ELeave) SmlSourceRefList_t();

	CleanupStack::PushL(itemL);

	itemL->sourceRef = new (ELeave) SmlPcdata_t();

	GenericListAddL(aList, itemL);

	CleanupStack::Pop(); // itemL

	return itemL->sourceRef;

	}

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

LOCAL_D TBool CreateBasicCommandL( CXMLElement*& aElement, TUint8 aTag )

	{

	aElement = 0;

	switch( aTag )

		{

		case EMap:

			aElement = new (ELeave) SmlMap_t();

			return ETrue;

		case EAlert:

			aElement = new (ELeave) SmlAlert_t();

			return ETrue;

		case EAtomic:

			aElement = new (ELeave) SmlAtomic_t(SML_PE_ATOMIC_START);

			return ETrue;

		case EAdd:

		case ECopy:

		case EDelete:

		case EReplace:

		case EMove:

			aElement = new (ELeave) SmlCopy_t();

			return ETrue;

		case EGet:

		case EPut:

			aElement = new (ELeave) SmlGet_t();

			return ETrue;

		case EExec:

			aElement = new (ELeave) SmlExec_t();

			return ETrue;

		case EResults:

			aElement = new (ELeave) SmlResults_t();

			return ETrue;

		case ESearch:

			aElement = new (ELeave) SmlSearch_t();

			return ETrue;

		case ESequence:

			aElement = new (ELeave) SmlSequence_t(SML_PE_SEQUENCE_START);

			return ETrue;

		case EStatus:

			aElement = new (ELeave) SmlStatus_t();

			return ETrue;

		case ESync:

			aElement = new (ELeave) SmlSync_t();

			return ETrue;

		default:

			break;

		}

	return EFalse;

	}

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

// sml_pcdata_s

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

EXPORT_C sml_pcdata_s::sml_pcdata_s( const SmlPcdataType_t aType, const SmlPcdataExtension_t aExt )

	: contentType(aType), extension(aExt)

	{

	}

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

EXPORT_C sml_pcdata_s::sml_pcdata_s() : contentType(SML_PCDATA_OPAQUE), extension(SML_EXT_UNDEFINED)

	{

	}

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

EXPORT_C sml_pcdata_s::~sml_pcdata_s()

	{

	FreeContent();

	}

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

EXPORT_C void sml_pcdata_s::FreeContent()

	{

	if( extension == SML_EXT_METINF )

		{

		delete SmlMetInfMetInfPtr_t(content);

		}

    else if( extension == SML_EXT_DEVINFPROP )

		{

        delete SmlDevInfPropertyListPtr_t(content);            

		}

	else

		{

		}

	content = 0;

	}

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

EXPORT_C void sml_pcdata_s::SetDataL( const TDesC8& aData )

	{

	FreeContent();

	length = aData.Length();

	content = User::AllocL(length);

	Mem::Copy(content, aData.Ptr(), length);

	}

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

EXPORT_C TPtrC8 sml_pcdata_s::Data() const

	{

	return TPtrC8((TUint8*)content, length);

	}

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

EXPORT_C void sml_pcdata_s::TruncateL( TInt aConsumed )

	{

	HBufC8* buffer = TPtrC8((TUint8*)content + aConsumed, length - aConsumed).AllocLC();

	SetDataL(*buffer);

	CleanupStack::PopAndDestroy(); // buffer

	}

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

// sml_pcdata_list_s

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

EXPORT_C sml_pcdata_list_s::sml_pcdata_list_s()

	{

	}

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

EXPORT_C sml_pcdata_list_s::~sml_pcdata_list_s()

	{

	delete data;

	}

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

// sml_chal_s

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

EXPORT_C sml_chal_s::sml_chal_s()

	{

	delete meta;

	}

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

EXPORT_C sml_chal_s::~sml_chal_s()

	{

	delete meta;

	}

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

CXMLElement* sml_chal_s::BeginElementL( TUint8 aTag, const TXMLElementParams& /*aParams*/ )

	{

	switch( aTag )

		{

		case EMeta:

			CHECK_NO_DUPLICATE(meta);

			meta = new (ELeave) SmlPcdata_t( /*SML_PCDATA_EXTENSION, SML_EXT_METINF*/);

			meta->contentType = SML_PCDATA_EXTENSION;

			meta->extension = SML_EXT_METINF;

			return meta;

		default:

			User::Leave(KWBXMLParserErrorInvalidTag);

		}

	return 0;

	}

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

// sml_cred_s

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

EXPORT_C sml_cred_s::sml_cred_s()

	{

	}

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

EXPORT_C sml_cred_s::~sml_cred_s()

	{

	delete data;

	delete meta;

	}

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

CXMLElement* sml_cred_s::BeginElementL( TUint8 aTag, const TXMLElementParams& /*aParams*/ )

	{

	switch( aTag )

		{

		case EData:

			CHECK_NO_DUPLICATE(data);

			data = new (ELeave) SmlPcdata_t();

			return data;

		case EMeta:

			CHECK_NO_DUPLICATE(meta)

			meta = new (ELeave) SmlPcdata_t(/*SML_PCDATA_EXTENSION, SML_EXT_METINF*/);

			meta->contentType = SML_PCDATA_EXTENSION;

			meta->extension = SML_EXT_METINF;

			return meta;

		default:

			User::Leave(KWBXMLParserErrorInvalidTag);

		}

	return 0;

	}

// 1.2 CHANGES: new common use elements

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

// sml_field_or_record_s

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

EXPORT_C sml_field_or_record_s::sml_field_or_record_s()

	{

	}

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

EXPORT_C sml_field_or_record_s::~sml_field_or_record_s()

	{

	delete item;

	}

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

CXMLElement* sml_field_or_record_s::BeginElementL( TUint8 aTag, const TXMLElementParams& /*aParams*/ )

	{

	switch( aTag )

		{

		case EItem:

			CHECK_NO_DUPLICATE(item);

			item = new (ELeave) SmlItem_t();

			return item;

		default:

			User::Leave(KWBXMLParserErrorInvalidTag);

		}

	return 0;

	}

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

// sml_filter_s

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

EXPORT_C sml_filter_s::sml_filter_s()

	{

	}

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

EXPORT_C sml_filter_s::~sml_filter_s()

	{

	delete meta;

	delete field;

	delete record;

	delete filterType;

	}

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

CXMLElement* sml_filter_s::BeginElementL( TUint8 aTag, const TXMLElementParams& /*aParams*/ )

	{

	switch( aTag )

		{

		case EMeta:

			CHECK_NO_DUPLICATE(meta);

			meta = new (ELeave) SmlPcdata_t();

			meta->contentType = SML_PCDATA_EXTENSION;

			meta->extension = SML_EXT_METINF;

			return meta;

		case EField:

			CHECK_NO_DUPLICATE(field);

			field = new (ELeave) SmlField_t();

			return field;

		case ERecord:

			CHECK_NO_DUPLICATE(record);

			record = new (ELeave) SmlRecord_t();

			return record;

		case EFilterType:

			CHECK_NO_DUPLICATE(filterType);

			filterType = new (ELeave) SmlPcdata_t();

			return filterType;

		default:

			User::Leave(KWBXMLParserErrorInvalidTag);

		}

	return 0;

	}

// Changes end

// 1.2 CHANGES: Source & Target divided to their own structs

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

// sml_source_s

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

EXPORT_C sml_source_s::sml_source_s()

	{

	}

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

EXPORT_C sml_source_s::~sml_source_s()

	{

	delete locURI;

	delete locName;

	}

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

CXMLElement* sml_source_s::BeginElementL( TUint8 aTag, const TXMLElementParams& /*aParams*/ )

	{

	switch( aTag )

		{

		case ELocURI:

			CHECK_NO_DUPLICATE(locURI);

			locURI = new (ELeave) SmlPcdata_t();

			return locURI;

		case ELocName:

			CHECK_NO_DUPLICATE(locName);

			locName = new (ELeave) SmlPcdata_t();

			return locName;

		default:

			User::Leave(KWBXMLParserErrorInvalidTag);

		}

	return 0;

	}

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

// sml_target_s

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

EXPORT_C sml_target_s::sml_target_s()

	{

	}

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

EXPORT_C sml_target_s::~sml_target_s()

	{

	delete locURI;

	delete locName;

	delete filter;

	}

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

CXMLElement* sml_target_s::BeginElementL( TUint8 aTag, const TXMLElementParams& /*aParams*/ )

	{

	switch( aTag )

		{

		case ELocURI:

			CHECK_NO_DUPLICATE(locURI);

			locURI = new (ELeave) SmlPcdata_t();

			return locURI;

		case ELocName:

			CHECK_NO_DUPLICATE(locName);

			locName = new (ELeave) SmlPcdata_t();

			return locName;

		case EFilter:

			CHECK_NO_DUPLICATE(filter);

			filter = new (ELeave) SmlFilter_t();

			return filter;

		default:

			User::Leave(KWBXMLParserErrorInvalidTag);

		}

	return 0;

	}

// Changes end

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

// sml_source_list_s

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

EXPORT_C sml_source_list_s::sml_source_list_s()

	{

	}

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

EXPORT_C sml_source_list_s::~sml_source_list_s()

	{

	delete source;

	}

//1.2 CHANGES: Source & Target parent

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

// sml_source_or_target_parent_s

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

EXPORT_C sml_source_or_target_parent_s::sml_source_or_target_parent_s()

	{

	}

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

EXPORT_C sml_source_or_target_parent_s::~sml_source_or_target_parent_s()

	{

	delete locURI;

	}

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

CXMLElement* sml_source_or_target_parent_s::BeginElementL( TUint8 aTag, const TXMLElementParams& /*aParams*/ )

	{

	switch( aTag )

		{

		case ELocURI:

			CHECK_NO_DUPLICATE(locURI);

			locURI = new (ELeave) SmlPcdata_t();

			return locURI;

		default:

			User::Leave(KWBXMLParserErrorInvalidTag);

		}

	return 0;

	}

// Changes end

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

// sml_sync_hdr_s

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

EXPORT_C sml_sync_hdr_s::sml_sync_hdr_s()

	{

	}

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

EXPORT_C sml_sync_hdr_s::~sml_sync_hdr_s()

	{

	delete version;       

	delete proto;         

	delete sessionID;     

	delete msgID;         

	delete target;

	delete source;

	delete respURI;

	delete cred;