/*

* Copyright (c) 2005-2007 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

*

*/

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

// Includes

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

#include "sconconmlgenerator.h"

#include "sconconmlhandlererror.h"

#include "sconconmldtd.h"

#include "sconxmlelement.h"

#include "debug.h"

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

// CSConConMLGenerator

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

CSConConMLGenerator::CSConConMLGenerator()

    {

    }

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

// ~CSConConMLGenerator

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

CSConConMLGenerator::~CSConConMLGenerator()

    {

    if (iCmdStack)

        {

        iCmdStack->Reset();

        delete iCmdStack;

        iCmdStack = NULL;

        }

    if ( iWBXMLWorkspace )

        {

        delete iWBXMLWorkspace;

        iWBXMLWorkspace = NULL;

        }

    if ( iXMLWorkspace )

        {

        delete iXMLWorkspace;

        iXMLWorkspace = NULL;

        }

    if (iCleanupStack)

        {

        iCleanupStack->ResetAndDestroy();

        delete iCleanupStack;

        iCleanupStack = NULL;

        }

    iElemStack.Close();

    }

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

// NewL

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

CSConConMLGenerator* CSConConMLGenerator::NewL ()

    {

    LOGGER_ENTERFN( "CSConConMLGenerator::NewL()" );

    CSConConMLGenerator* self = new ( ELeave ) CSConConMLGenerator();

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(); // self

    LOGGER_LEAVEFN( "CSConConMLGenerator::NewL()" );

    return self;

    }

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

// ConstructL

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

void CSConConMLGenerator::ConstructL()

    {

    LOGGER_ENTERFN( "CSConConMLGenerator::ConstructL()" );

    iCmdStack = CXMLStack<CXMLElement>::NewL();

    iCleanupStack = CXMLStack<CXMLElement>::NewL();

    iWBXMLWorkspace = CXMLWorkspace::NewL();

    iXMLWorkspace = CXMLWorkspace::NewL();

    LOGGER_LEAVEFN( "CSConConMLGenerator::ConstructL()" );

    }

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

// SetCallbacks

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

void CSConConMLGenerator::SetCallback ( MWBXMLConMLCallback* aCallback )

    {

    LOGGER_ENTERFN( "CSConConMLGenerator::SetCallbacks()" );

    iCallback = aCallback;

    LOGGER_LEAVEFN( "CSConConMLGenerator::SetCallbacks()" );

    }

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

// StartDocument

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

void CSConConMLGenerator::StartDocument( 

    TUint8 /*aVersion*/, TInt32 /*aPublicId*/, TUint32 /*aCharset*/ )

    {

    LOGGER_ENTERFN( "CSConConMLGenerator::StartDocumentL()" );

    iCmdStack->Reset();

    LOGGER_LEAVEFN( "CSConConMLGenerator::StartDocumentL()" );

    }

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

// StartDocument

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

void CSConConMLGenerator::StartDocument( 

    TUint8 /*aVersion*/, const TDesC8& /*aPublicIdStr*/, TUint32 /*aCharset*/ )

    {

    LOGGER_ENTERFN( "CSConConMLGenerator::StartDocumentL()" );

    iCmdStack->Reset();

    LOGGER_LEAVEFN( "CSConConMLGenerator::StartDocumentL()" );

    }

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

// StartElementL

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

void CSConConMLGenerator::StartElementL( TWBXMLTag aTag )

    {

    LOGGER_ENTERFN( "CSConConMLGenerator::StartElementL()" );

    if( iCmdStack->Top() != 0 )

        {

        AddElementL(iCmdStack->Top()->BeginElementL( 

            aTag, TXMLElementParams(iCallback, iCmdStack, iCleanupStack ) ) );

        }

    else

        {

        if( aTag == EConML )

            {

            ConML_ConML_t* element = new (ELeave) ConML_ConML_t();

            CleanupStack::PushL( element );

            AddElementL( element );

            CleanupStack::Pop( element );

            }

        else

            {

            LOGGER_WRITE( "CSConConMLGenerator::StartElementL() : Leave KWBXMLParserErrorInvalidTag" );

            User::Leave(KWBXMLParserErrorInvalidTag);

            }

        }

    LOGGER_LEAVEFN( "CSConConMLGenerator::StartElementL()" );

    }

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

// AddElement

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

void CSConConMLGenerator::AddElementL( CXMLElement* aElement )

    {

    LOGGER_ENTERFN( "CSConConMLGenerator::AddElement()" );

    if( aElement )

        {

        iCmdStack->PushL(aElement);

        if( aElement->NeedsCleanup() )

            {

            iCleanupStack->PushL(aElement);

            }

        }

    LOGGER_LEAVEFN( "CSConConMLGenerator::AddElement()" );

    }

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

// CharactersL

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

void CSConConMLGenerator::CharactersL( const TDesC8& aBuffer )

    {

    LOGGER_ENTERFN( "CSConConMLGenerator::CharactersL()" );

    if( iCmdStack->Top() != 0 )

        {

        iCmdStack->Top()->SetDataL(aBuffer);

        }

    else

        {

        LOGGER_WRITE( "CSConConMLGenerator::CharactersL() : Leave KWBXMLParserErrorInvalidTag" );

        User::Leave(KWBXMLParserErrorInvalidTag);

        }

    LOGGER_LEAVEFN( "CSConConMLGenerator::CharactersL()" );

    }

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

// EndElementL

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

void CSConConMLGenerator::EndElementL( TWBXMLTag aTag )

    {

    LOGGER_ENTERFN( "CSConConMLGenerator::EndElementL()" );

    if( iCmdStack->Top() != 0 )

        {

        CXMLElement::TAction action = iCmdStack->Top()->EndElementL( 

            iCallback, aTag );

        if( action != CXMLElement::ENone )

            {

            CXMLElement* elem = iCmdStack->Pop();

            if( iCleanupStack->Top() == elem )

                {

                iCleanupStack->Pop();

                }

            if( action == CXMLElement::EPopAndDestroy )

                {

                delete elem;

                }

            }

        }

    LOGGER_LEAVEFN( "CSConConMLGenerator::EndElementL()" );

    }

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

// WriteMUint32L

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

void CSConConMLGenerator::WriteMUint32L( TUint32 aValue )

    {

    LOGGER_ENTERFN( "CSConConMLGenerator::WriteMUint32L()" );

    TUint8 temp[5];

    TInt i(4);

    temp[i--] = TUint8(aValue & 0x7F);

    aValue >>= 7;

    while( aValue > 0 )

        {

        temp[i--] = TUint8((aValue & 0x7F) | 0x80);

        aValue >>= 7;

        }

    while( i < 4 )

        {

        iWBXMLWorkspace->WriteL(temp[++i]);

        }

    LOGGER_LEAVEFN( "CSConConMLGenerator::WriteMUint32L()" );

    }

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

// WriteOpaqueDataL

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

void CSConConMLGenerator::WriteOpaqueDataL( const TDesC8& aData )

    {

    LOGGER_ENTERFN( "CSConConMLGenerator::WriteOpaqueDataL()" );

    iWBXMLWorkspace->WriteL( OPAQUE );

    WriteMUint32L( aData.Size() );

    iWBXMLWorkspace->WriteL( aData );

    iXMLWorkspace->WriteL( aData );

    LOGGER_LEAVEFN( "CSConConMLGenerator::WriteOpaqueDataL()" );

    }

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

// WriteInlineStringL

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

void CSConConMLGenerator::WriteInlineStringL( const TDesC8& aData )

    {

    LOGGER_ENTERFN( "CSConConMLGenerator::WriteInlineStringL()" );

    iWBXMLWorkspace->WriteL( STR_I );

    iWBXMLWorkspace->WriteL( aData );

    iWBXMLWorkspace->WriteL( 0 );

    iXMLWorkspace->WriteL( aData );

    LOGGER_LEAVEFN( "CSConConMLGenerator::WriteInlineStringL()" );

    }

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

// IndentL

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

void CSConConMLGenerator::IndentL()

    {

    LOGGER_ENTERFN( "CSConConMLGenerator::IndentL()" );

    for( TInt i = 0; i < iElemStack.Count() + iInitialIndentLevel; i++ )

        {

        iXMLWorkspace->WriteL(KXMLIndent());

        }

    LOGGER_LEAVEFN( "CSConConMLGenerator::IndentL()" );

    }

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

// TranslateElement

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

TPtrC8 CSConConMLGenerator::TranslateElement( TUint8 aElement )

    {

    LOGGER_ENTERFN( "CSConConMLGenerator::TranslateElement()" );

    TPtrC8 buf( KConMLElements );

    while( aElement-- )

        {

        TInt pos = buf.Find(KXMLElemenentSeparator());

        if( pos == KErrNotFound )

            {

            return TPtrC8();

            }

        buf.Set(buf.Right(buf.Length() - pos - 1));

        }

    TInt pos = buf.Find(KXMLElemenentSeparator());

    if( pos != KErrNotFound )

        {

        buf.Set(buf.Left(pos));

        }

    LOGGER_LEAVEFN( "CSConConMLGenerator::TranslateElement()" );

    return buf;

    }

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

// EndDocument

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

void CSConConMLGenerator::EndDocument()

    {

    LOGGER_ENTERFN( "CSConConMLGenerator::EndDocument()" );

    LOGGER_LEAVEFN( "CSConConMLGenerator::EndDocument()" );

    }

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

// GenerateConMLDocument

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

TInt CSConConMLGenerator::GenerateConMLDocument ( ConML_ConMLPtr_t aContent )

    {

    LOGGER_ENTERFN( "CSConConMLGenerator::GenerateConMLDocument()" );

    iWBXMLWorkspace->Reset();

    iWBXMLWorkspace->BeginTransaction();

    iXMLWorkspace->Reset();

    iXMLWorkspace->BeginTransaction();

    TRAPD(result, AppendConMLL(aContent));

    LOGGER_WRITE_1( "CSConConMLGenerator::GenerateConMLDocument()\

     : returned %d", result );

    return HandleResult(result);

    }

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

// AppendConMLL

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

void CSConConMLGenerator::AppendConMLL( ConML_ConMLPtr_t aContent )

    {

    LOGGER_ENTERFN( "CSConConMLGenerator::AppendConMLL()" );

    BeginDocumentL(KSConConMLVersion, KSConConMLPublicId, KSConConMLUTF8);

    BeginElementL(EConML, ETrue);

    AppendExecuteL( aContent->execute );

    AppendGetStatusL( aContent->getStatus );

    AppendCancelL( aContent->cancel );

    AppendStatusL( aContent->status );

    EndElementL(); // EConML

    LOGGER_LEAVEFN( "CSConConMLGenerator::AppendConMLL()" );

    }

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

// AppendExecuteL

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

void CSConConMLGenerator::AppendExecuteL( ConML_ExecutePtr_t aContent )

    {

    LOGGER_ENTERFN( "CSConConMLGenerator::AppendExecuteL()" );

    if ( aContent )

        {

        BeginElementL( EConMLExecute, ETrue );

        AppendPCDataL( EConMLID, aContent->id );

        AppendInstallL( aContent->install );

        AppendUnInstallL( aContent->unInstall );

        AppendListInstalledAppsL( aContent->listInstalledApps );

        AppendListDataOwnersL( aContent->listDataOwners );

        AppendSetBURModeL( aContent->setBurMode );

        AppendGetDataSizeL( aContent->getDataSize );

        AppendRequestDataL( aContent->requestData );

        AppendUpdateDeviceInfoL( aContent->updateDeviceInfo );

        AppendListPublicFilesL( aContent->listPublicFiles );

        AppendSupplyDataL( aContent->supplyData );

        AppendGetDataOwnerStatusL( aContent->getDataOwnerStatus );

        AppendGetMetadataL( aContent->getMetadata );

        if ( aContent->reboot )

            {

            BeginElementL( EConMLReboot );

            }

        EndElementL(); // EConMLExecute

        }

    LOGGER_LEAVEFN( "CSConConMLGenerator::AppendExecuteL()" );

    }

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

// AppendSupplyDataL

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

void CSConConMLGenerator::AppendSupplyDataL( ConML_SupplyDataPtr_t aContent )

    {

    LOGGER_ENTERFN( "CSConConMLGenerator::AppendSupplyDataL()" );

    if ( aContent )

        {

        BeginElementL( EConMLSupplyData, ETrue );

        AppendSIDListL( aContent->sid );

        AppendResultsL( aContent->results );

        EndElementL(); // EConMLSupplyData

        }

    LOGGER_LEAVEFN( "CSConConMLGenerator::AppendSupplyDataL()" );

    }

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

// AppendInstallL

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

void CSConConMLGenerator::AppendInstallL( ConML_InstallPtr_t aContent )

    {

    LOGGER_ENTERFN( "CSConConMLGenerator::AppendInstallL()" );

    if ( aContent)

        {

        BeginElementL( EConMLInstall, ETrue );

        AppendPCDataL( EConMLName, aContent->name );

        if ( aContent->instParams) 

            {

            if ( aContent->instParams->param )

                {

                AppendInstParamsL( aContent->instParams );  

                }

            else 

                {

                BeginElementL( EConMLInstParams );

                }

            }

        AppendResultsL( aContent->results );

        EndElementL(); // EConMLInstall

        }

    LOGGER_LEAVEFN( "CSConConMLGenerator::AppendInstallL()" );

    }

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

// AppendCancelL

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

void CSConConMLGenerator::AppendCancelL ( ConML_CancelPtr_t aContent )

    {

    LOGGER_ENTERFN( "CSConConMLGenerator::AppendCancelL()" );

    if ( aContent )

        {

        BeginElementL( EConMLCancel, ETrue );

        AppendPCDataL ( EConMLID, aContent->id );

        AppendPCDataL( EConMLAll, aContent->all);

        EndElementL(); // EConMLCancel

        }

    LOGGER_LEAVEFN( "CSConConMLGenerator::AppendCancelL()" );

    }

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

// AppendStatusL

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

void CSConConMLGenerator::AppendStatusL ( ConML_StatusPtr_t aContent )

    {

    LOGGER_ENTERFN( "CSConConMLGenerator::AppendStatusL()" );

    if ( aContent )

        {

        if ( aContent->task )

            {

            BeginElementL( EConMLStatus, ETrue );

            AppendTaskListL( aContent->task );

            EndElementL(); // EConMLStatus

            }

        else

            {

            BeginElementL( EConMLStatus );  

            }

        }

    LOGGER_LEAVEFN( "CSConConMLGenerator::AppendStatusL()" );

    }

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

// AppendGetStatusL

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

void CSConConMLGenerator::AppendGetStatusL( ConML_GetStatusPtr_t aContent )

    {

    LOGGER_ENTERFN( "CSConConMLGenerator::AppendGetStatusL()" );

    if ( aContent )

        {

        BeginElementL( EConMLGetStatus, ETrue );

        AppendPCDataL( EConMLID, aContent->id);

        if ( aContent->all )

            {

            BeginElementL( EConMLAll );

            }

        EndElementL(); // EConMLGetStatus

        }

    LOGGER_ENTERFN( "CSConConMLGenerator::AppendGetStatusL()" );

    }

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

// AppendRebootL

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

void CSConConMLGenerator::AppendRebootL( ConML_RebootPtr_t aContent )

    {

    if ( aContent )

        {

        BeginElementL( EConMLReboot, ETrue );

        AppendResultsL( aContent->results );

        EndElementL(); // EConMLReboot

        }

    }

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

// AppendTaskL

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

void CSConConMLGenerator::AppendTaskL( ConML_TaskPtr_t aContent )

    {

    LOGGER_ENTERFN( "CSConConMLGenerator::AppendTaskL()" );

    if ( aContent )

        {

        BeginElementL( EConMLTask, ETrue );

        AppendPCDataL( EConMLID, aContent->id );

        AppendInstallL(aContent->install );

        AppendUnInstallL( aContent->unInstall );

        AppendListInstalledAppsL ( aContent->listInstalledApps );

        AppendListDataOwnersL ( aContent->listDataOwners );

        AppendSetBURModeL ( aContent->setBurMode );

        AppendGetDataSizeL ( aContent->getDataSize );

        AppendRequestDataL ( aContent->requestData );

        AppendUpdateDeviceInfoL ( aContent->updateDeviceInfo);

        AppendListPublicFilesL ( aContent->listPublicFiles );

        AppendGetDataOwnerStatusL( aContent->getDataOwnerStatus );

        AppendSupplyDataL( aContent->supplyData );

        AppendRebootL( aContent->reboot );

        AppendGetMetadataL( aContent->getMetadata );

        EndElementL();

        }

    LOGGER_LEAVEFN( "CSConConMLGenerator::AppendTaskL()" );

    }

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

// AppendTaskListL

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

void CSConConMLGenerator::AppendTaskListL( ConML_TaskListPtr_t aContent )

    {

    LOGGER_ENTERFN( "CSConConMLGenerator::AppendTaskListL()" );

    for ( ConML_TaskListPtr_t p = aContent; p && p->data; p=p->next )