/*
* 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
{
delete content;
}
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;
delete meta;
}
// ------------------------------------------------------------------------------------------------
CXMLElement* sml_sync_hdr_s::BeginElementL( TUint8 aTag, const TXMLElementParams& /*aParams*/ )
{
switch( aTag )
{
case EVerDTD:
CHECK_NO_DUPLICATE(version);
version = new (ELeave) SmlPcdata_t();
return version;
case EVerProto:
CHECK_NO_DUPLICATE(proto);
proto = new (ELeave) SmlPcdata_t();
return proto;
case ESessionID:
CHECK_NO_DUPLICATE(sessionID);
sessionID = new (ELeave) SmlPcdata_t();
return sessionID;
case EMsgID:
CHECK_NO_DUPLICATE(msgID);
msgID = new (ELeave) SmlPcdata_t();
return msgID;
case ETarget:
CHECK_NO_DUPLICATE(target);
target = new (ELeave) SmlTarget_t();
return target;
case ESource:
CHECK_NO_DUPLICATE(source);
source = new (ELeave) SmlSource_t();
return source;
case ERespURI:
CHECK_NO_DUPLICATE(respURI);
respURI = new (ELeave) SmlPcdata_t();
return respURI;
case ECred:
CHECK_NO_DUPLICATE(cred);
cred = new (ELeave) SmlCred_t();
return cred;
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;
case ENoResp:
CHECK_NO_DUPLICATE(flags & SmlNoResp_f);
flags |= SmlNoResp_f;
break;
default:
User::Leave(KWBXMLParserErrorInvalidTag);
}
return 0;
}
// ------------------------------------------------------------------------------------------------
CXMLElement::TAction sml_sync_hdr_s::EndElementL( TAny* aCallbacks, TUint8 aTag )
{
switch( aTag )
{
case ESyncHdr:
((MWBXMLSyncMLCallbacks*)aCallbacks)->smlStartMessageFuncL(this);
return EPopAndDestroy;
case ENoResp:
return ENone;
default:
User::Leave(KWBXMLParserErrorInvalidTag);
}
return EPop;
}
// ------------------------------------------------------------------------------------------------
TBool sml_sync_hdr_s::NeedsCleanup() const
{
return ETrue;
}
// ------------------------------------------------------------------------------------------------
// sml_item_s
// ------------------------------------------------------------------------------------------------
EXPORT_C sml_item_s::sml_item_s()
{
}
// ------------------------------------------------------------------------------------------------
EXPORT_C sml_item_s::~sml_item_s()
{
delete target;
delete source;
delete sourceParent;
delete targetParent;
delete meta;
delete data;
}
// ------------------------------------------------------------------------------------------------
CXMLElement* sml_item_s::BeginElementL( TUint8 aTag, const TXMLElementParams& /*aParams*/ )
{
switch( aTag )
{
case ETarget:
CHECK_NO_DUPLICATE(target);
target = new (ELeave) SmlTarget_t();
return target;
case ESource:
CHECK_NO_DUPLICATE(source);
source = new (ELeave) SmlSource_t();
return source;
// 1.2 CHANGES: SourceParent and TargetParent added
case ESourceParent:
CHECK_NO_DUPLICATE(sourceParent);
sourceParent = new (ELeave) SmlSourceParent_t();
return sourceParent;
case ETargetParent:
CHECK_NO_DUPLICATE(targetParent);
targetParent = new (ELeave) SmlTargetParent_t();
return targetParent;
// End Changes
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;
case EData:
CHECK_NO_DUPLICATE(data);
data = new (ELeave) SmlPcdata_t();
return data;
case EMoreData:
CHECK_NO_DUPLICATE(flags & SmlMoreData_f);
flags |= SmlMoreData_f;
break;
default:
User::Leave(KWBXMLParserErrorInvalidTag);
}
return 0;
}
// ------------------------------------------------------------------------------------------------
CXMLElement::TAction sml_item_s::EndElementL( TAny* /*aCallbacks*/, TUint8 aTag )
{
if( aTag == EMoreData )
{
return ENone;
}
return EPop;
}
// ------------------------------------------------------------------------------------------------
// sml_item_list_s
// ------------------------------------------------------------------------------------------------
EXPORT_C sml_item_list_s::sml_item_list_s()
{
}
// ------------------------------------------------------------------------------------------------
EXPORT_C sml_item_list_s::~sml_item_list_s()
{
delete item;
}
// ------------------------------------------------------------------------------------------------
// sml_generic_s
// ------------------------------------------------------------------------------------------------
EXPORT_C sml_generic_s::sml_generic_s()
{
}
// ------------------------------------------------------------------------------------------------
EXPORT_C sml_generic_s::~sml_generic_s()
{
delete cmdID;
delete cred;
delete meta;
GenericListDelete( itemList );
}
// ------------------------------------------------------------------------------------------------
CXMLElement* sml_generic_s::BeginElementL( TUint8 aTag, const TXMLElementParams& /*aParams*/ )
{
switch( aTag )
{
case ECmdID:
CHECK_NO_DUPLICATE(cmdID);
cmdID = new (ELeave) SmlPcdata_t();
return cmdID;
case ECred:
CHECK_NO_DUPLICATE(cred);
cred = new (ELeave) SmlCred_t();
return cred;
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;
case ENoResp:
CHECK_NO_DUPLICATE(flags & SmlNoResp_f);
flags |= SmlNoResp_f;
break;
case EArchive:
CHECK_NO_DUPLICATE(flags & SmlArchive_f);
flags |= SmlArchive_f;
break;
case ESftDel:
CHECK_NO_DUPLICATE(flags & SmlSftDel_f);
flags |= SmlSftDel_f;
break;
case EItem:
return AddItemL(&itemList);
default:
User::Leave(KWBXMLParserErrorInvalidTag);
}
return 0;
}
// ------------------------------------------------------------------------------------------------
CXMLElement::TAction sml_generic_s::EndElementL( TAny* aCallbacks, TUint8 aTag )
{
switch( aTag )
{
case EAdd:
((MWBXMLSyncMLCallbacks*)aCallbacks)->smlAddCmdFuncL(this);
return EPopAndDestroy;
case ECopy:
((MWBXMLSyncMLCallbacks*)aCallbacks)->smlCopyCmdFuncL(this);
return EPopAndDestroy;
case EDelete:
((MWBXMLSyncMLCallbacks*)aCallbacks)->smlDeleteCmdFuncL(this);
return EPopAndDestroy;
case EReplace:
((MWBXMLSyncMLCallbacks*)aCallbacks)->smlReplaceCmdFuncL(this);
return EPopAndDestroy;
case EMove:
((MWBXMLSyncMLCallbacks*)aCallbacks)->smlMoveCmdFuncL(this);
return EPopAndDestroy;
case ENoResp:
case EArchive:
case ESftDel:
return ENone;
default:
User::Leave(KWBXMLParserErrorInvalidTag);
}
return EPop;
}
// ------------------------------------------------------------------------------------------------
TBool sml_generic_s::NeedsCleanup() const
{
return ETrue;
}
// ------------------------------------------------------------------------------------------------
// sml_alert_s
// ------------------------------------------------------------------------------------------------
EXPORT_C sml_alert_s::sml_alert_s()
{
}
// ------------------------------------------------------------------------------------------------
EXPORT_C sml_alert_s::~sml_alert_s()
{
delete cmdID;
delete cred;
delete data;
// FOTA
delete correlator;
// FOTA end
GenericListDelete( itemList );
}
// ------------------------------------------------------------------------------------------------
CXMLElement* sml_alert_s::BeginElementL( TUint8 aTag, const TXMLElementParams& /*aParams*/ )
{
switch( aTag )
{
case ECmdID:
CHECK_NO_DUPLICATE(cmdID);
cmdID = new (ELeave) SmlPcdata_t();
return cmdID;
case ENoResp:
CHECK_NO_DUPLICATE(flags & SmlNoResp_f);
flags |= SmlNoResp_f;
break;
case ECred:
CHECK_NO_DUPLICATE(cred);
cred = new (ELeave) SmlCred_t();
return cred;
case EData:
CHECK_NO_DUPLICATE(data);
data = new (ELeave) SmlPcdata_t();
return data;
// FOTA
case ECorrelator:
CHECK_NO_DUPLICATE(correlator);
correlator = new (ELeave) SmlPcdata_t();
return correlator;
// FOTA end
case EItem:
return AddItemL(&itemList);
default:
User::Leave(KWBXMLParserErrorInvalidTag);
}
return 0;
}
// ------------------------------------------------------------------------------------------------
CXMLElement::TAction sml_alert_s::EndElementL( TAny* aCallbacks, TUint8 aTag )
{
switch( aTag )
{
case EAlert:
((MWBXMLSyncMLCallbacks*)aCallbacks)->smlAlertCmdFuncL(this);
return EPopAndDestroy;
case ENoResp:
return ENone;
default:
User::Leave(KWBXMLParserErrorInvalidTag);
}
return EPop;
}
// ------------------------------------------------------------------------------------------------
TBool sml_alert_s::NeedsCleanup() const
{
return ETrue;
}
// ------------------------------------------------------------------------------------------------
// sml_atomic_s
// ------------------------------------------------------------------------------------------------
EXPORT_C sml_atomic_s::sml_atomic_s( SmlProtoElement_t aType )
{
elementType = aType;
}
// ------------------------------------------------------------------------------------------------
EXPORT_C sml_atomic_s::~sml_atomic_s()
{
delete cmdID;
delete meta;
}
// ------------------------------------------------------------------------------------------------
CXMLElement* sml_atomic_s::BeginElementL( TUint8 aTag, const TXMLElementParams& aParams )
{
switch( aTag )
{
case ECmdID:
CHECK_NO_DUPLICATE(cmdID);
cmdID = new (ELeave) SmlPcdata_t();
return cmdID;
case ENoResp:
CHECK_NO_DUPLICATE(flags & SmlNoResp_f);
flags |= SmlNoResp_f;
break;
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:
CXMLElement* e;
if( CreateBasicCommandL(e, aTag) )
{
if( this->elementType == SML_PE_ATOMIC_START )
{
this->elementType = SML_PE_ATOMIC_END;
((MWBXMLSyncMLCallbacks*)aParams.Callbacks())->smlStartAtomicFuncL(this);
}
else if( this->elementType == SML_PE_SEQUENCE_START )
{
this->elementType = SML_PE_SEQUENCE_END;
((MWBXMLSyncMLCallbacks*)aParams.Callbacks())->smlStartSequenceFuncL(this);
}
}
else
{
User::Leave(KWBXMLParserErrorInvalidTag);
}
return e;
}
return 0;
}
// ------------------------------------------------------------------------------------------------
CXMLElement::TAction sml_atomic_s::EndElementL( TAny* aCallbacks, TUint8 aTag )
{
switch( aTag )
{
case EAtomic:
((MWBXMLSyncMLCallbacks*)aCallbacks)->smlEndAtomicFuncL();
return EPopAndDestroy;
case ESequence:
((MWBXMLSyncMLCallbacks*)aCallbacks)->smlEndSequenceFuncL();
return EPopAndDestroy;
case ENoResp:
return ENone;
default:
User::Leave(KWBXMLParserErrorInvalidTag);
}
return EPop;
}
// ------------------------------------------------------------------------------------------------
TBool sml_atomic_s::NeedsCleanup() const
{
return ETrue;
}
// ------------------------------------------------------------------------------------------------
// sml_sync_s
// ------------------------------------------------------------------------------------------------
EXPORT_C sml_sync_s::sml_sync_s()
{
elementType = SML_PE_SYNC_START;
}
// ------------------------------------------------------------------------------------------------
EXPORT_C sml_sync_s::~sml_sync_s()
{
delete cmdID;
delete cred;
delete target;
delete source;
delete meta;
delete noc;
}
// ------------------------------------------------------------------------------------------------
CXMLElement* sml_sync_s::BeginElementL( TUint8 aTag, const TXMLElementParams& aParams )
{
switch( aTag )
{
case ECmdID:
CHECK_NO_DUPLICATE(cmdID);
cmdID = new (ELeave) SmlPcdata_t();
return cmdID;
case ENoResp:
CHECK_NO_DUPLICATE(flags & SmlNoResp_f);
flags |= SmlNoResp_f;
break;
case ECred:
CHECK_NO_DUPLICATE(cred);
cred = new (ELeave) SmlCred_t();
return cred;
case ETarget:
CHECK_NO_DUPLICATE(target);
target = new (ELeave) SmlTarget_t();
return target;
case ESource:
CHECK_NO_DUPLICATE(source);
source = new (ELeave) SmlSource_t();
return source;
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;
case ENumberOfChanges:
CHECK_NO_DUPLICATE(noc);
noc = new (ELeave) SmlPcdata_t();
return noc;
default:
CXMLElement* e;
if( CreateBasicCommandL(e, aTag) )
{
if( this->elementType == SML_PE_SYNC_START )
{
this->elementType = SML_PE_SYNC_END;
((MWBXMLSyncMLCallbacks*)aParams.Callbacks())->smlStartSyncFuncL(this);
}
}
else
{
User::Leave(KWBXMLParserErrorInvalidTag);
}
return e;
}
return 0;
}
// ------------------------------------------------------------------------------------------------
CXMLElement::TAction sml_sync_s::EndElementL( TAny* aCallbacks, TUint8 aTag )
{
switch( aTag )
{
case ESync:
// If Sync element did not contain any commands -> call startsync and then end sync
if( this->elementType == SML_PE_SYNC_START )
{
this->elementType = SML_PE_SYNC_END;
((MWBXMLSyncMLCallbacks*)aCallbacks)->smlStartSyncFuncL(this);
}
((MWBXMLSyncMLCallbacks*)aCallbacks)->smlEndSyncFuncL();
return EPopAndDestroy;
case ENoResp:
return ENone;
default:
User::Leave(KWBXMLParserErrorInvalidTag);
}
return EPop;
}
// ------------------------------------------------------------------------------------------------
TBool sml_sync_s::NeedsCleanup() const
{
return ETrue;
}
// ------------------------------------------------------------------------------------------------
// sml_exec_s
// ------------------------------------------------------------------------------------------------
EXPORT_C sml_exec_s::sml_exec_s()
{
}
// ------------------------------------------------------------------------------------------------
EXPORT_C sml_exec_s::~sml_exec_s()
{
delete cmdID;
delete cred;
delete meta;
// FOTA
delete correlator;
// FOTA end
delete item;
}
// ------------------------------------------------------------------------------------------------
CXMLElement* sml_exec_s::BeginElementL( TUint8 aTag, const TXMLElementParams& /*aParams*/ )
{
switch( aTag )
{
case ECmdID:
CHECK_NO_DUPLICATE(cmdID);
cmdID = new (ELeave) SmlPcdata_t();
return cmdID;
case ENoResp:
CHECK_NO_DUPLICATE(flags & SmlNoResp_f);
flags |= SmlNoResp_f;
break;
case ECred:
CHECK_NO_DUPLICATE(cred);
cred = new (ELeave) SmlCred_t();
return cred;
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;
// FOTA
case ECorrelator:
CHECK_NO_DUPLICATE(correlator);
correlator = new (ELeave) SmlPcdata_t();
return correlator;
// FOTA end
case EItem:
CHECK_NO_DUPLICATE(item);
item = new (ELeave) SmlItem_t();
return item;
default:
User::Leave(KWBXMLParserErrorInvalidTag);
}
return 0;
}
// ------------------------------------------------------------------------------------------------
CXMLElement::TAction sml_exec_s::EndElementL( TAny* aCallbacks, TUint8 aTag )
{
switch( aTag )
{
case EExec:
((MWBXMLSyncMLCallbacks*)aCallbacks)->smlExecCmdFuncL(this);
return EPopAndDestroy;
case ENoResp:
return ENone;
default:
User::Leave(KWBXMLParserErrorInvalidTag);
}
return EPop;
}
// ------------------------------------------------------------------------------------------------
TBool sml_exec_s::NeedsCleanup() const
{
return ETrue;
}
// ------------------------------------------------------------------------------------------------
// sml_get_put_s
// ------------------------------------------------------------------------------------------------
EXPORT_C sml_get_put_s::sml_get_put_s()
{
}
// ------------------------------------------------------------------------------------------------
EXPORT_C sml_get_put_s::~sml_get_put_s()
{
delete cmdID;
delete lang;
delete cred;
delete meta;
GenericListDelete( itemList );
}
// ------------------------------------------------------------------------------------------------
CXMLElement* sml_get_put_s::BeginElementL( TUint8 aTag, const TXMLElementParams& /*aParams*/ )
{
switch( aTag )
{
case ECmdID:
CHECK_NO_DUPLICATE(cmdID);
cmdID = new (ELeave) SmlPcdata_t();
return cmdID;
case ENoResp:
CHECK_NO_DUPLICATE(flags & SmlNoResp_f);
flags |= SmlNoResp_f;
break;
case ELang:
CHECK_NO_DUPLICATE(lang);
lang = new (ELeave) SmlPcdata_t();
return lang;
case ECred:
CHECK_NO_DUPLICATE(cred);
cred = new (ELeave) SmlCred_t();
return cred;
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;
case EItem:
return AddItemL(&itemList);
default:
User::Leave(KWBXMLParserErrorInvalidTag);
}
return 0;
}
// ------------------------------------------------------------------------------------------------
CXMLElement::TAction sml_get_put_s::EndElementL( TAny* aCallbacks, TUint8 aTag )
{
switch( aTag )
{
case EGet:
((MWBXMLSyncMLCallbacks*)aCallbacks)->smlGetCmdFuncL(this);
return EPopAndDestroy;
case EPut:
((MWBXMLSyncMLCallbacks*)aCallbacks)->smlPutCmdFuncL(this);
return EPopAndDestroy;
case ENoResp:
return ENone;
default:
User::Leave(KWBXMLParserErrorInvalidTag);
}
return EPop;
}
// ------------------------------------------------------------------------------------------------
TBool sml_get_put_s::NeedsCleanup() const
{
return ETrue;
}
// ------------------------------------------------------------------------------------------------
// sml_map_item_s
// ------------------------------------------------------------------------------------------------
EXPORT_C sml_map_item_s::sml_map_item_s()
{
}
// ------------------------------------------------------------------------------------------------
EXPORT_C sml_map_item_s::~sml_map_item_s()
{
delete source;
delete target;
}
// ------------------------------------------------------------------------------------------------
CXMLElement* sml_map_item_s::BeginElementL( TUint8 aTag, const TXMLElementParams& /*aParams*/ )
{
switch( aTag )
{
case ETarget:
CHECK_NO_DUPLICATE(target);
target = new (ELeave) SmlTarget_t();
return target;
case ESource:
CHECK_NO_DUPLICATE(source);
source = new (ELeave) SmlSource_t();
return source;
default:
User::Leave(KWBXMLParserErrorInvalidTag);
}
return 0;
}
// ------------------------------------------------------------------------------------------------
// sml_map_item_list_s
// ------------------------------------------------------------------------------------------------
EXPORT_C sml_map_item_list_s::sml_map_item_list_s()
{
}
// ------------------------------------------------------------------------------------------------
EXPORT_C sml_map_item_list_s::~sml_map_item_list_s()
{
delete mapItem;
}
// ------------------------------------------------------------------------------------------------
// sml_map_s
// ------------------------------------------------------------------------------------------------
EXPORT_C sml_map_s::sml_map_s()
{
}
// ------------------------------------------------------------------------------------------------
EXPORT_C sml_map_s::~sml_map_s()
{
delete cmdID;
delete target;
delete source;
delete cred;
delete meta;
GenericListDelete( mapItemList );
}
// ------------------------------------------------------------------------------------------------
CXMLElement* sml_map_s::BeginElementL( TUint8 aTag, const TXMLElementParams& /*aParams*/ )
{
switch( aTag )
{
case ECmdID:
CHECK_NO_DUPLICATE(cmdID);
cmdID = new (ELeave) SmlPcdata_t();
return cmdID;
case ETarget:
CHECK_NO_DUPLICATE(target);
target = new (ELeave) SmlTarget_t();
return target;
case ESource:
CHECK_NO_DUPLICATE(source);
source = new (ELeave) SmlSource_t();
return source;
case ECred:
CHECK_NO_DUPLICATE(cred);
cred = new (ELeave) SmlCred_t();
return cred;
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;
case EMapItem:
return AddMapItemL(&mapItemList);
default:
User::Leave(KWBXMLParserErrorInvalidTag);
}
return 0;
}
// ------------------------------------------------------------------------------------------------
CXMLElement::TAction sml_map_s::EndElementL( TAny* aCallbacks, TUint8 aTag )
{
switch( aTag )
{
case EMap:
((MWBXMLSyncMLCallbacks*)aCallbacks)->smlMapCmdFuncL(this);
return EPopAndDestroy;
default:
User::Leave(KWBXMLParserErrorInvalidTag);
}
return EPop;
}
// ------------------------------------------------------------------------------------------------
TBool sml_map_s::NeedsCleanup() const
{
return ETrue;
}
// ------------------------------------------------------------------------------------------------
// sml_results_s
// ------------------------------------------------------------------------------------------------
EXPORT_C sml_results_s::sml_results_s()
{
}
// ------------------------------------------------------------------------------------------------
EXPORT_C sml_results_s::~sml_results_s()
{
delete cmdID;
delete msgRef;
delete cmdRef;
delete meta;
delete targetRef;
delete sourceRef;
GenericListDelete( itemList );
}
// ------------------------------------------------------------------------------------------------
CXMLElement* sml_results_s::BeginElementL( TUint8 aTag, const TXMLElementParams& /*aParams*/ )
{
switch( aTag )
{
case ECmdID:
CHECK_NO_DUPLICATE(cmdID);
cmdID = new (ELeave) SmlPcdata_t();
return cmdID;
case EMsgRef:
CHECK_NO_DUPLICATE(msgRef);
msgRef = new (ELeave) SmlPcdata_t();
return msgRef;
case ECmdRef:
CHECK_NO_DUPLICATE(cmdRef);
cmdRef = new (ELeave) SmlPcdata_t();
return cmdRef;
case ETargetRef:
CHECK_NO_DUPLICATE(targetRef);
targetRef = new (ELeave) SmlPcdata_t();
return targetRef;
case ESourceRef:
CHECK_NO_DUPLICATE(sourceRef);
sourceRef = new (ELeave) SmlPcdata_t();
return sourceRef;
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;
case EItem:
return AddItemL(&itemList);
default:
User::Leave(KWBXMLParserErrorInvalidTag);
}
return 0;
}
// ------------------------------------------------------------------------------------------------
CXMLElement::TAction sml_results_s::EndElementL( TAny* aCallbacks, TUint8 aTag )
{
switch( aTag )
{
case EResults:
((MWBXMLSyncMLCallbacks*)aCallbacks)->smlResultsCmdFuncL(this);
return EPopAndDestroy;
default:
User::Leave(KWBXMLParserErrorInvalidTag);
}
return EPop;
}
// ------------------------------------------------------------------------------------------------
TBool sml_results_s::NeedsCleanup() const
{
return ETrue;
}
// ------------------------------------------------------------------------------------------------
// sml_search_s
// ------------------------------------------------------------------------------------------------
EXPORT_C sml_search_s::sml_search_s()
{
}
// ------------------------------------------------------------------------------------------------
EXPORT_C sml_search_s::~sml_search_s()
{
delete cmdID;
delete cred;
delete target;
GenericListDelete( sourceList );
delete lang;
delete meta;
delete data;
}
// ------------------------------------------------------------------------------------------------
CXMLElement* sml_search_s::BeginElementL( TUint8 aTag, const TXMLElementParams& /*aParams*/ )
{
switch( aTag )
{
case ECmdID:
CHECK_NO_DUPLICATE(cmdID);
cmdID = new (ELeave) SmlPcdata_t();
return cmdID;
case ENoResp:
CHECK_NO_DUPLICATE(flags & SmlNoResp_f);
flags |= SmlNoResp_f;
break;
case ENoResults:
CHECK_NO_DUPLICATE(flags & SmlNoResults_f);
flags |= SmlNoResults_f;
break;
case ECred:
CHECK_NO_DUPLICATE(cred);
cred = new (ELeave) SmlCred_t();
return cred;
case ETarget:
CHECK_NO_DUPLICATE(target);
target = new (ELeave) SmlTarget_t();
return target;
case ESource:
return AddSourceListL(&sourceList);
case ELang:
CHECK_NO_DUPLICATE(lang);
lang = new (ELeave) SmlPcdata_t();
return lang;
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;
case EData:
CHECK_NO_DUPLICATE(data);
data = new (ELeave) SmlPcdata_t();
return data;
default:
User::Leave(KWBXMLParserErrorInvalidTag);
}
return 0;
}
// ------------------------------------------------------------------------------------------------
CXMLElement::TAction sml_search_s::EndElementL( TAny* aCallbacks, TUint8 aTag )
{
switch( aTag )
{
case ESearch:
((MWBXMLSyncMLCallbacks*)aCallbacks)->smlSearchCmdFuncL(this);
return EPopAndDestroy;
case ENoResp:
case ENoResults:
return ENone;
default:
User::Leave(KWBXMLParserErrorInvalidTag);
}
return EPop;
}
// ------------------------------------------------------------------------------------------------
TBool sml_search_s::NeedsCleanup() const
{
return ETrue;
}
// ------------------------------------------------------------------------------------------------
// sml_target_ref_list_s
// ------------------------------------------------------------------------------------------------
EXPORT_C sml_target_ref_list_s::sml_target_ref_list_s()
{
}
// ------------------------------------------------------------------------------------------------
EXPORT_C sml_target_ref_list_s::~sml_target_ref_list_s()
{
delete targetRef;
}
// ------------------------------------------------------------------------------------------------
// sml_source_ref_list_s
// ------------------------------------------------------------------------------------------------
EXPORT_C sml_source_ref_list_s::sml_source_ref_list_s()
{
}
// ------------------------------------------------------------------------------------------------
EXPORT_C sml_source_ref_list_s::~sml_source_ref_list_s()
{
delete sourceRef;
}
// ------------------------------------------------------------------------------------------------
// sml_status_s
// ------------------------------------------------------------------------------------------------
EXPORT_C sml_status_s::sml_status_s()
{
}
// ------------------------------------------------------------------------------------------------
EXPORT_C sml_status_s::~sml_status_s()
{
delete cmdID;
delete msgRef;
delete cmdRef;
delete cmd;
GenericListDelete( targetRefList );
GenericListDelete( sourceRefList );
delete cred;
delete chal;
delete data;
GenericListDelete( itemList );
}
// ------------------------------------------------------------------------------------------------
CXMLElement* sml_status_s::BeginElementL( TUint8 aTag, const TXMLElementParams& /*aParams*/ )
{
switch( aTag )
{
case ECmdID:
CHECK_NO_DUPLICATE(cmdID);
cmdID = new (ELeave) SmlPcdata_t();
return cmdID;
case EMsgRef:
CHECK_NO_DUPLICATE(msgRef);
msgRef = new (ELeave) SmlPcdata_t();
return msgRef;
case ECmdRef:
CHECK_NO_DUPLICATE(cmdRef);
cmdRef = new (ELeave) SmlPcdata_t();
return cmdRef;
case ECmd:
CHECK_NO_DUPLICATE(cmd);
cmd = new (ELeave) SmlPcdata_t();
return cmd;
case ETargetRef:
return AddTargetRefL(&targetRefList);
case ESourceRef:
return AddSourceRefL(&sourceRefList);
case ECred:
CHECK_NO_DUPLICATE(cred);
cred = new (ELeave) SmlCred_t();
return cred;
case EChal:
CHECK_NO_DUPLICATE(chal);
chal = new (ELeave) SmlChal_t();
return chal;
case EData:
CHECK_NO_DUPLICATE(data);
data = new (ELeave) SmlPcdata_t();
return data;
case EItem:
return AddItemL(&itemList);
default:
User::Leave(KWBXMLParserErrorInvalidTag);
}
return 0;
}
// ------------------------------------------------------------------------------------------------
CXMLElement::TAction sml_status_s::EndElementL( TAny* aCallbacks, TUint8 aTag )
{
switch( aTag )
{
case EStatus:
((MWBXMLSyncMLCallbacks*)aCallbacks)->smlStatusCmdFuncL(this);
return EPopAndDestroy;
default:
User::Leave(KWBXMLParserErrorInvalidTag);
}
return EPop;
}
// ------------------------------------------------------------------------------------------------
TBool sml_status_s::NeedsCleanup() const
{
return ETrue;
}
// ------------------------------------------------------------------------------------------------
// sml_syncml_s
// ------------------------------------------------------------------------------------------------
EXPORT_C CXMLElement* sml_syncml_s::BeginElementL( TUint8 aTag, const TXMLElementParams& /*aParams*/ )
{
switch( aTag )
{
case ESyncHdr:
return new (ELeave) SmlSyncHdr_t();
case ESyncBody:
return new (ELeave) SmlSyncBody_t();
default:
User::Leave(KWBXMLParserErrorInvalidTag);
}
return 0;
}
// ------------------------------------------------------------------------------------------------
EXPORT_C CXMLElement::TAction sml_syncml_s::EndElementL( TAny* /*aCallbacks*/, TUint8 /*aTag*/ )
{
return EPopAndDestroy;
}
// ------------------------------------------------------------------------------------------------
EXPORT_C TBool sml_syncml_s::NeedsCleanup() const
{
return ETrue;
}
// ------------------------------------------------------------------------------------------------
// sml_syncml_body_s
// ------------------------------------------------------------------------------------------------
CXMLElement* sml_syncml_body_s::BeginElementL( TUint8 aTag, const TXMLElementParams& /*aParams*/ )
{
switch( aTag )
{
case EFinal:
CHECK_NO_DUPLICATE(flags & SmlFinal_f);
flags |= SmlFinal_f;
break;
default:
CXMLElement* e;
if( !CreateBasicCommandL(e, aTag) )
{
User::Leave(KWBXMLParserErrorInvalidTag);
}
return e;
}
return 0;
}
// ------------------------------------------------------------------------------------------------
CXMLElement::TAction sml_syncml_body_s::EndElementL( TAny* aCallbacks, TUint8 aTag )
{
switch( aTag )
{
case ESyncBody:
((MWBXMLSyncMLCallbacks*)aCallbacks)->smlEndMessageFuncL((this->flags & SmlFinal_f) != 0);
return EPopAndDestroy;
case EFinal:
return ENone;
default:
User::Leave(KWBXMLParserErrorInvalidTag);
}
return EPop;
}
// ------------------------------------------------------------------------------------------------
TBool sml_syncml_body_s::NeedsCleanup() const
{
return ETrue;
}