/*

* Copyright (c) 2005-2008 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:  ConML parser/generator

*

*/

#include "sconconmldtd.h"

#include "sconconmltags.h"

#include "sconconmlhandler.h"

#include "sconconmlhandlererror.h"

#include "debug.h"

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

// Macros

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

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

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

// pcdata_s

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

pcdata_s::pcdata_s( const pcdataType_t aType, const pcdataExtension_t aExt )

	: contentType(aType), extension(aExt)

    {

    }

pcdata_s::pcdata_s() : contentType(SML_PCDATA_OPAQUE), 

                       extension(SML_EXT_UNDEFINED)

    {

    }

pcdata_s::~pcdata_s()

    {

    FreeContent();

    }

void pcdata_s::FreeContent()

    {

    User::Free(content);

    content = 0;

    }

void pcdata_s::SetDataL( const TDesC8& aData )

    {

    FreeContent();

    length = aData.Length();

    content = User::AllocL(length);

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

    }

TPtrC8 pcdata_s::Data() const

    {

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

    }

void pcdata_s::TruncateL( TInt aConsumed )

    {

    HBufC8* buffer = TPtrC8((TUint8*)content + aConsumed, 

                             length - aConsumed).AllocLC();

    SetDataL(*buffer);

    CleanupStack::PopAndDestroy(); // buffer

    }

pcdata_list_s::pcdata_list_s()

    {

    }

pcdata_list_s::~pcdata_list_s()

    {

    delete data;

    delete next;

    }

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

// AddDriveL

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

CXMLElement* AddDriveL(  ConML_DriveListPtr_t* aList )

    {

    ConML_DriveListPtr_t itemL = new ( ELeave ) ConML_DriveList_t();

    CleanupStack::PushL( itemL );

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

    GenericListAddL(aList, itemL);

    CleanupStack::Pop(); // itemL

    return itemL->data;

    }

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

// AddSIDL

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

CXMLElement* AddSIDL( ConML_SIDListPtr_t * aList )

    {

    ConML_SIDListPtr_t itemL = new ( ELeave ) ConML_SIDList_t();

    CleanupStack::PushL( itemL );

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

    GenericListAddL(aList, itemL);

    CleanupStack::Pop(); // itemL

    return itemL->data;

    }

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

// AddFileL

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

CXMLElement* AddFileL( ConML_FileListPtr_t * aList )

    {

    ConML_FileListPtr_t itemL = new ( ELeave ) ConML_FileList_t();

    CleanupStack::PushL( itemL );

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

    GenericListAddL(aList, itemL);

    CleanupStack::Pop(); // itemL

    return itemL->data;

    }

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

// AddApplicationL

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

CXMLElement* AddApplicationL( ConML_ApplicationListPtr_t * aList )

    {   

    ConML_ApplicationListPtr_t itemL = new ( ELeave ) ConML_ApplicationList_t();

    CleanupStack::PushL( itemL );

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

    GenericListAddL(aList, itemL);

    CleanupStack::Pop(); // itemL

    return itemL->data;

    }

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

// AddTaskL

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

CXMLElement* AddTaskL( ConML_TaskListPtr_t * aList )

    {

    ConML_TaskListPtr_t itemL = new ( ELeave ) ConML_TaskList_t();

    CleanupStack::PushL( itemL );

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

    GenericListAddL(aList, itemL);

    CleanupStack::Pop(); // itemL

    return itemL->data;

    }

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

// AddParamL

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

CXMLElement* AddParamL( ConML_ParamListPtr_t * aList )

    {

    ConML_ParamListPtr_t itemL = new ( ELeave ) ConML_ParamList_t();

    CleanupStack::PushL( itemL );

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

    GenericListAddL(aList, itemL);

    CleanupStack::Pop(); // itemL

    return itemL->data;

    }

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

// ConML_Drive_s

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

ConML_Drive_s::ConML_Drive_s()

    {

    }

ConML_Drive_s::~ConML_Drive_s()

    {

    delete name;

    }

CXMLElement* ConML_Drive_s::BeginElementL( 

    TUint8 aTag, const TXMLElementParams& /*aParams*/ )

    {

    switch ( aTag )

        {

        case EConMLName:

            CHECK_NO_DUPLICATE ( name );

            name = new ( ELeave ) pcdata_t();

            return name;

        default:

            LOGGER_WRITE_1( "ConML_Drive_s::BeginElement() : Unknown element  %02x", aTag );

            User::Leave( KWBXMLParserErrorInvalidTag );

        }

    return KErrNone;

    }

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

// ConML_DriveList_s

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

ConML_DriveList_s::ConML_DriveList_s()	

    {

    }

ConML_DriveList_s::~ConML_DriveList_s()	

    {

    delete data;

    delete next;

    }

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

// ConML_Drives_s

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

ConML_Drives_s::ConML_Drives_s()

    {

    }

ConML_Drives_s::~ConML_Drives_s()

    {

    delete drive;

    }

CXMLElement* ConML_Drives_s::BeginElementL( 

    TUint8 aTag, const TXMLElementParams& /*aParams*/ )

    {

    switch ( aTag )

        {

        case EConMLDrive:

            return AddDriveL ( &drive );

        default:

            LOGGER_WRITE_1( "ConML_Drives_s::BeginElement()\

             : Unknown element  %02x ", aTag );

            User::Leave( KWBXMLParserErrorInvalidTag );

        }

    return KErrNone;

    }

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

// ConML_BUROptions_s

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

ConML_BUROptions_s::ConML_BUROptions_s()

    {

    }

ConML_BUROptions_s::~ConML_BUROptions_s()

    {

    delete requiresReboot;

    delete hasFiles;

    delete supportsInc;

    delete delayToPrepareData;

    }

CXMLElement* ConML_BUROptions_s::BeginElementL ( 

        TUint8 aTag, const TXMLElementParams& /*aParams*/ )

    {

    switch ( aTag )

        {

        case EConMLRequiresReboot:

            CHECK_NO_DUPLICATE ( requiresReboot );

            requiresReboot = new ( ELeave ) pcdata_t();

            return requiresReboot;

        case EConMLHasFiles:

            CHECK_NO_DUPLICATE ( hasFiles );

            hasFiles = new ( ELeave ) pcdata_t();

            return hasFiles;

        case EConMLSupportsInc:

            CHECK_NO_DUPLICATE ( supportsInc );

            supportsInc = new ( ELeave ) pcdata_t();

            return supportsInc;

        case EConMLDelayToPrepareData:

            CHECK_NO_DUPLICATE ( delayToPrepareData );

            delayToPrepareData = new ( ELeave ) pcdata_t();

            return delayToPrepareData;

        default:

            LOGGER_WRITE_1( "ConML_BUROptions_s::BeginElement()\

             : Unknown element  %02x ", aTag );

            User::Leave( KWBXMLParserErrorInvalidTag );

        }

    return KErrNone;

    }

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

// ConML_PackageInfo_s

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

ConML_PackageInfo_s::ConML_PackageInfo_s()

    {

    }

ConML_PackageInfo_s::~ConML_PackageInfo_s()

    {

    delete name;

    }

CXMLElement* ConML_PackageInfo_s::BeginElementL( 

    TUint8 aTag, const TXMLElementParams& /*aParams*/ )	

    {

    switch ( aTag )

        {

        case EConMLName:

            CHECK_NO_DUPLICATE ( name )

            name = new ( ELeave ) pcdata_t();

            return name;

        default:

            LOGGER_WRITE_1( "ConML_PackageInfo_s::BeginElement()\

             : Unknown element  %02x ", aTag );

            User::Leave( KWBXMLParserErrorInvalidTag );

        }

    return KErrNone;

    }

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

// ConML_SID_s

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

ConML_SID_s::ConML_SID_s()

    {

    }

ConML_SID_s::~ConML_SID_s()

    {

    delete type;

    delete uid;

    delete drives;

    delete packageInfo;

    delete burOptions;

    delete size;

    delete transferDataType;

    delete data;

    delete moreData;

    delete dataOwnerStatus;

    }

CXMLElement* ConML_SID_s::BeginElementL( 

    TUint8 aTag, const TXMLElementParams& /*aParams*/ )	

    {

    switch ( aTag )

        {

        case EConMLType:

            CHECK_NO_DUPLICATE ( type );

            type = new ( ELeave ) pcdata_t();

            return type;

        case EConMLUID:

            CHECK_NO_DUPLICATE ( uid )

            uid = new ( ELeave ) pcdata_t();

            return uid;

        case EConMLDrives:

            drives = new ( ELeave ) ConML_Drives_t();

            return drives;

        case EConMLPackageInfo:

            CHECK_NO_DUPLICATE ( packageInfo );

            packageInfo = new ( ELeave ) ConML_PackageInfo_t();

            return packageInfo;

        case EConMLBUROptions:

            CHECK_NO_DUPLICATE ( burOptions )

            burOptions = new ( ELeave )	ConML_BUROptions_t();

            return burOptions;

        case EConMLSize:

            CHECK_NO_DUPLICATE ( size );

            size = new ( ELeave ) pcdata_t();

            return size;

        case EConMLTransferDataType:

            CHECK_NO_DUPLICATE ( transferDataType );

            transferDataType = new ( ELeave ) pcdata_t();

            return transferDataType;

        case EConMLData:

            CHECK_NO_DUPLICATE ( data );

            data = new ( ELeave ) pcdata_t();

            return data;

        case EConMLMoreData:

            CHECK_NO_DUPLICATE ( moreData );

            moreData = new ( ELeave ) pcdata_t();

            return moreData;

        case EConMLDataOwnerStatus:

            CHECK_NO_DUPLICATE ( dataOwnerStatus );

            dataOwnerStatus = new ( ELeave ) pcdata_t();

            return dataOwnerStatus;

        default:

            LOGGER_WRITE_1( "ConML_SID_s::BeginElement()\

             : Unknown element  %02x ", aTag );

            User::Leave( KWBXMLParserErrorInvalidTag );

        }

    return KErrNone;

    }

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

// ConML_SIDList_s

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

ConML_SIDList_s::ConML_SIDList_s()

    {

    }

ConML_SIDList_s::~ConML_SIDList_s()

    {

    delete data;

    delete next;

    }

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

// ConML_DataOwners_s

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

ConML_DataOwners_s::ConML_DataOwners_s()

    {

    }

ConML_DataOwners_s::~ConML_DataOwners_s()

    {

    delete sid;

    }

CXMLElement* ConML_DataOwners_s::BeginElementL(

    TUint8 aTag, const TXMLElementParams& /*aParams*/ )	

    {

    switch ( aTag )

        {

        case EConMLSID:

            return AddSIDL( &sid );

        default:

            LOGGER_WRITE_1( "ConML_DataOwners_s::BeginElement()\

             : Unknown element  %02x ", aTag);

            User::Leave( KWBXMLParserErrorInvalidTag );

        }

    return KErrNone;

    }

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

// ConML_Application_s

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

ConML_Application_s::ConML_Application_s()

    {

    }

ConML_Application_s::~ConML_Application_s()

    {

    delete name;

    delete uid;

    }

CXMLElement* ConML_Application_s::BeginElementL( 

    TUint8 aTag, const TXMLElementParams& /*aParams*/ )	

    {

    switch ( aTag )

    	{

    	case EConMLName:

            CHECK_NO_DUPLICATE ( name );

            name = new ( ELeave ) pcdata_t();

            return name;

        case EConMLUID:

            CHECK_NO_DUPLICATE ( uid );

            uid = new ( ELeave ) pcdata_t();

            return uid;

        default:

            LOGGER_WRITE_1( "ConML_Application_s::BeginElement()\

             : Unknown element  %02x ", aTag );

            User::Leave( KWBXMLParserErrorInvalidTag );

        }

    return KErrNone;

    }

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

// ConML_ApplicationList_s

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

ConML_ApplicationList_s::ConML_ApplicationList_s()

    {

    }

ConML_ApplicationList_s::~ConML_ApplicationList_s()

    {

    delete data;

    delete next;

    }

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

// ConML_Applications_s

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

ConML_Applications_s::ConML_Applications_s()	

    {

    }

ConML_Applications_s::~ConML_Applications_s()	

    {

    delete application;

    }

CXMLElement* ConML_Applications_s::BeginElementL(

    TUint8 aTag, const TXMLElementParams& /*aParams*/ )	

    {

    switch ( aTag )

        {

        case EConMLApplication:

            return AddApplicationL( &application );

        default:

            LOGGER_WRITE_1( "ConML_DataOwners_s::BeginElement()\

             : Unknown element  %02x ", aTag );

            User::Leave( KWBXMLParserErrorInvalidTag );

        }

    return KErrNone;

    }

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

// ConML_SupportedMethod_s

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

ConML_SupportedMethods_s::ConML_SupportedMethods_s()

    {

    }

ConML_SupportedMethods_s::~ConML_SupportedMethods_s()

    {

    delete install;

    delete unInstall;

    delete setInstParams;

    delete listInstalledApps;

    delete listDataOwners;

    delete setBurMode;

    delete getDataSize;