/*

* 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:  Device information command struct implementations.

*

*/

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

// Includes

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

#include "smldtd.h"

#include "smldevinfdtd.h"

#include "smldevinftags.h"

#include "WBXMLDevInfParser.h"

#include "WBXMLParserError.h"

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

// External functions

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

extern CXMLElement* AddPCDataL( SmlPcdataListPtr_t* aList );

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

// Macros

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

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

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

// Helper functions

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

CXMLElement* AddCTParamL(  SmlDevInfCTDataListPtr_t* aList )

	{

	SmlDevInfCTDataListPtr_t itemL = new (ELeave) SmlDevInfCTDataList_t();

	CleanupStack::PushL(itemL);

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

	GenericListAddL(aList, itemL);

	CleanupStack::Pop(); // itemL

	return itemL->data;

	}

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

CXMLElement* AddCTPropL( SmlDevInfCTDataPropListPtr_t* aList )

	{

	SmlDevInfCTDataPropListPtr_t itemL = new (ELeave) SmlDevInfCTDataPropList_t();

	CleanupStack::PushL(itemL);

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

	GenericListAddL(aList, itemL);

	CleanupStack::Pop(); // itemL

	return itemL->data;

	}

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

CXMLElement* AddPropertyL( SmlDevInfPropertyListPtr_t* aList )

	{

	SmlDevInfPropertyListPtr_t itemL = new (ELeave) SmlDevInfPropertyList_t();

	CleanupStack::PushL(itemL);

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

	GenericListAddL(aList, itemL);

	CleanupStack::Pop(); // itemL

	return itemL->data;

	}

// 1.2 CHANGES: new element PropParam

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

CXMLElement* AddPropParamL( SmlDevInfPropParamListPtr_t* aList )

	{

	SmlDevInfPropParamListPtr_t itemL = new (ELeave) SmlDevInfPropParamList_t();

	CleanupStack::PushL(itemL);

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

	GenericListAddL(aList, itemL);

	CleanupStack::Pop(); // itemL

	return itemL->data;

	}

// Changes end

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

CXMLElement* AddXmitL( SmlDevInfXmitListPtr_t* aList )

	{

	SmlDevInfXmitListPtr_t itemL = new (ELeave) SmlDevInfXmitList_t();

	CleanupStack::PushL(itemL);

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

	GenericListAddL(aList, itemL);

	CleanupStack::Pop(); // itemL

	return itemL->data;

	}

// 1.2 CHANGES: new element FilterCap

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

CXMLElement* AddFilterCapL( SmlDevInfFilterCapListPtr_t* aList)

	{

	SmlDevInfFilterCapListPtr_t itemL = new (ELeave) SmlDevInfFilterCapList_t();

	CleanupStack::PushL(itemL);

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

	GenericListAddL(aList, itemL);

	CleanupStack::Pop(); //itemL

	return itemL->data;

	}

// Changes end

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

CXMLElement* AddCtCapL( SmlDevInfCtCapListPtr_t* aList, CXMLElement* aParent = 0 )

	{

	SmlDevInfCtCapListPtr_t itemL = new (ELeave) SmlDevInfCtCapList_t();

	CleanupStack::PushL(itemL);

	itemL->data = new (ELeave) SmlDevInfCtCap_t(aParent);

	GenericListAddL(aList, itemL);

	CleanupStack::Pop(); // itemL

	return itemL->data;

	}

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

CXMLElement* AddDataStoreL( SmlDevInfDatastoreListPtr_t* aList )

	{

	SmlDevInfDatastoreListPtr_t itemL = new (ELeave) SmlDevInfDatastoreList_t();

	CleanupStack::PushL(itemL);

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

	GenericListAddL(aList, itemL);

	CleanupStack::Pop(); // itemL

	return itemL->data;

	}

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

CXMLElement* AddExtL( SmlDevInfExtListPtr_t* aList )

	{

	SmlDevInfExtListPtr_t itemL = new (ELeave) SmlDevInfExtList_t();

	CleanupStack::PushL(itemL);

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

	GenericListAddL(aList, itemL);

	CleanupStack::Pop(); // itemL

	return itemL->data;

	}

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

// sml_devinf_xmit_s

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

EXPORT_C sml_devinf_xmit_s::sml_devinf_xmit_s()

	{

	}

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

EXPORT_C sml_devinf_xmit_s::~sml_devinf_xmit_s()

	{

	delete cttype;

	delete verct;

	}

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

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

	{

	switch( aTag )

	{ 

		case EDevCTType:

			CHECK_NO_DUPLICATE(cttype);

			cttype = new (ELeave) SmlPcdata_t();

			return cttype;

		case EDevVerCT:

			CHECK_NO_DUPLICATE(verct);

			verct = new (ELeave) SmlPcdata_t();

			return verct;

		default:

			User::Leave(KWBXMLParserErrorInvalidTag);

		}

	return 0;

	}

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

// sml_devinf_xmitlist_s

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

EXPORT_C sml_devinf_xmitlist_s::sml_devinf_xmitlist_s()

	{

	}

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

EXPORT_C sml_devinf_xmitlist_s::~sml_devinf_xmitlist_s()

	{

	delete data;

	}

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

// sml_devinf_ext_s

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

EXPORT_C sml_devinf_ext_s::sml_devinf_ext_s()

	{

	}

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

EXPORT_C sml_devinf_ext_s::~sml_devinf_ext_s()

	{

    delete xnam;     

    GenericListDelete( xval );

	}

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

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

	{

	switch( aTag )

		{

		case EDevXNam:

			CHECK_NO_DUPLICATE(xnam);

			xnam = new (ELeave) SmlPcdata_t();

			return xnam;

		case EDevXVal:

			return AddPCDataL(&xval);

		default:

			User::Leave(KWBXMLParserErrorInvalidTag);

		}

	return 0;

	}

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

// sml_devinf_extlist_s

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

EXPORT_C sml_devinf_extlist_s::sml_devinf_extlist_s()

	{

	}

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

EXPORT_C sml_devinf_extlist_s::~sml_devinf_extlist_s()

	{

	delete data;	

	}

// 1.2 CHANGES: New element FilterCap

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

// sml_devinf_filtercap_s

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

EXPORT_C sml_devinf_filtercap_s::sml_devinf_filtercap_s()

	{

	}

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

EXPORT_C sml_devinf_filtercap_s::~sml_devinf_filtercap_s()

	{

    delete cttype;

    delete verct;

	GenericListDelete( filterkeyword ); /* optional */

	GenericListDelete( propname ); /* optional */

	}

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

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

{

	switch( aTag )

		{

		case EDevCTType:

			CHECK_NO_DUPLICATE(cttype);

			cttype = new (ELeave) SmlPcdata_t();

			return cttype;

		case EDevVerCT:

			CHECK_NO_DUPLICATE(verct);

			verct = new (ELeave) SmlPcdata_t();

			return verct;

		case EDevFilterKeyword:

			return AddPCDataL(&filterkeyword);

		case EDevPropName:

			return AddPCDataL(&propname);

		default:

			User::Leave(KWBXMLParserErrorInvalidTag);

		}

	return 0;

}

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

// sml_devinf_filtercaplist_s

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

EXPORT_C sml_devinf_filtercaplist_s::sml_devinf_filtercaplist_s()

	{

	}

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

EXPORT_C sml_devinf_filtercaplist_s::~sml_devinf_filtercaplist_s()

	{

	delete data;	

	}

// Changes end

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

// sml_devinf_synccap_s

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

EXPORT_C sml_devinf_synccap_s::sml_devinf_synccap_s()

	{

	}

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

EXPORT_C sml_devinf_synccap_s::~sml_devinf_synccap_s()

	{    

    GenericListDelete( synctype );

	}

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

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

	{

	switch( aTag )

		{

		case EDevSyncType:

			return AddPCDataL(&synctype);

		default:

			User::Leave(KWBXMLParserErrorInvalidTag);

		}

	return 0;

	}

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

// sml_devinf_dsmem_s

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

EXPORT_C sml_devinf_dsmem_s::sml_devinf_dsmem_s()

	{

	}

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

EXPORT_C sml_devinf_dsmem_s::~sml_devinf_dsmem_s()

	{

    delete maxmem; /* optional */

    delete maxid;  /* optional */

	delete shared; /* optional */

	}

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

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

	{

	switch( aTag )

		{

		case EDevSharedMem:

			CHECK_NO_DUPLICATE(shared);

			shared = new (ELeave) SmlPcdata_t();

			return shared;

		case EDevMaxMem:

			CHECK_NO_DUPLICATE(maxmem);

			maxmem = new (ELeave) SmlPcdata_t();

			return maxmem;

		case EDevMaxID:

			CHECK_NO_DUPLICATE(maxid);

			maxid = new (ELeave) SmlPcdata_t();

			return maxid;

		default:

			User::Leave(KWBXMLParserErrorInvalidTag);

		}

	return 0;

	}

// 1.2 CHANGES: new elements PropParam and Property

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

// sml_devinf_propparam_s

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

EXPORT_C sml_devinf_propparam_s::sml_devinf_propparam_s()

	{

	}

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

EXPORT_C sml_devinf_propparam_s::~sml_devinf_propparam_s()

	{

	delete datatype;

	delete displayname;

	delete paramname;	

	GenericListDelete( valenum );

	}

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

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

	{

	switch (aTag)

		{

		case EDevParamName:

			CHECK_NO_DUPLICATE(paramname);

			paramname = new (ELeave) SmlPcdata_t();

			return paramname;

		case EDevDataType:

			CHECK_NO_DUPLICATE(datatype);

			datatype = new (ELeave) SmlPcdata_t();

			return datatype;

		case EDevValEnum:

			return AddPCDataL(&valenum);

		case EDevDisplayName:

			CHECK_NO_DUPLICATE(displayname);

			displayname = new (ELeave) SmlPcdata_t();

			return displayname;

		default:

			User::Leave(KWBXMLParserErrorInvalidTag);

		}

	return 0;

	}

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

// sml_devinf_propparamlist_s

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

EXPORT_C sml_devinf_propparamlist_s::sml_devinf_propparamlist_s()

	{

	};

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

EXPORT_C sml_devinf_propparamlist_s::~sml_devinf_propparamlist_s()

	{	

	delete data;	

	}

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

// sml_devinf_property_s

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

EXPORT_C sml_devinf_property_s::sml_devinf_property_s()

	{

	}

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

EXPORT_C sml_devinf_property_s::~sml_devinf_property_s()

	{

    delete datatype;

	delete displayname;

	delete maxoccur;

	delete maxsize;

	delete propname;	

	GenericListDelete( propparam );	

	GenericListDelete( valenum );	

	delete notruncate;	

	}

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

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

	{

	switch( aTag )

		{

		case EDevPropName:

			CHECK_NO_DUPLICATE(propname);

			propname = new (ELeave) SmlPcdata_t();

			return propname;

		case EDevDataType:

			CHECK_NO_DUPLICATE(datatype);

			datatype = new (ELeave) SmlPcdata_t();

			return datatype;

		case EDevMaxOccur:

			CHECK_NO_DUPLICATE(maxoccur);

			maxoccur = new (ELeave) SmlPcdata_t();

			return maxoccur;

		case EDevMaxSize:

			CHECK_NO_DUPLICATE(maxsize);

			maxsize = new (ELeave) SmlPcdata_t();

			return maxsize;

		case EDevNoTruncate:

			CHECK_NO_DUPLICATE(notruncate);

			notruncate = new(ELeave) SmlPcdata_t();

			return notruncate;

		case EDevValEnum:

			return AddPCDataL(&valenum);

		case EDevDisplayName:

			CHECK_NO_DUPLICATE(displayname);

			displayname = new (ELeave) SmlPcdata_t();

			return displayname;

		case EDevPropParam:

			return AddPropParamL(&propparam);

		default:

			User::Leave(KWBXMLParserErrorInvalidTag);

		}

	return 0;

	}

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

// sml_devinf_propertylist_s

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

EXPORT_C sml_devinf_propertylist_s::sml_devinf_propertylist_s()

	{

	}

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

EXPORT_C sml_devinf_propertylist_s::~sml_devinf_propertylist_s()

	{

	delete data;	

	}

//Changes end

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

// sml_devinf_ctdata_s

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

EXPORT_C sml_devinf_ctdata_s::sml_devinf_ctdata_s()

	{

	}

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

EXPORT_C sml_devinf_ctdata_s::~sml_devinf_ctdata_s()

	{

    delete name; /* param OR prop name */

    delete dname; /* optional, display name */    

    GenericListDelete( valenum );

    delete datatype;

    delete size;

	}

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

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

	{

	switch( aTag )

		{

		case EDevParamName: