/** @file

* Copyright (c) 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:  Implements the CUpnpActionContentHandler class

 *

*/

#include "upnpstatevariablecontenthandler.h"

#include "upnpcontenthandlerscontroller.h"

#include "upnpignorecontenthandler.h"

#include "upnpallowedvaluerangecontenthandler.h"

#include "upnpallowedvaluelistcontenthandler.h"

#include "upnpstatevariable.h"

#include "upnpserviceliterals.h"

const TUint8 KReqiuredTagsBoundary(3); //first two bits

enum TFlagsPositions

    {

    ENamePos = 0,

    EDataTypePos,

    EDefaultValuePos, //optional

    EAllowedValuePos //optional, AllowedValueList or AllowedValueRange

    };

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

// CUpnpStateVariableContentHandler::NewL

// Two-phased constructor

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

//

CUpnpStateVariableContentHandler* CUpnpStateVariableContentHandler::NewL(

    CUpnpContentHandlersController& aController,

    CUpnpStateVariable& aResultStateVariable )

    {

    CUpnpStateVariableContentHandler* actionContentHandler = 

        CUpnpStateVariableContentHandler::NewLC( aController, aResultStateVariable );

    CleanupStack::Pop( actionContentHandler );

    return actionContentHandler;

    }

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

// CUpnpStateVariableContentHandler::NewLC

// Two-phased constructor. Leaves teh object on the CleanupStack

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

//

CUpnpStateVariableContentHandler* CUpnpStateVariableContentHandler::NewLC(

    CUpnpContentHandlersController& aController,

    CUpnpStateVariable& aResultStateVariable )

    {

    CUpnpStateVariableContentHandler* actionContentHandler = 

        new (ELeave) CUpnpStateVariableContentHandler( aController, 

            aResultStateVariable );

    CleanupStack::PushL( actionContentHandler );

    return actionContentHandler;

    }

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

// CUpnpStateVariableContentHandler::~CUpnpStateVariableContentHandler

// Destructor of CUpnpStateVariableContentHandler class 

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

//

CUpnpStateVariableContentHandler::~CUpnpStateVariableContentHandler()

    {

    }

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

// CUpnpStateVariableContentHandler::CUpnpStateVariableContentHandler

// Constructor

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

//

CUpnpStateVariableContentHandler::CUpnpStateVariableContentHandler(

    CUpnpContentHandlersController& aController,

    CUpnpStateVariable& aResultStateVariable ) :

        CUpnpContentHandler( aController ),

        iResultStateVariable( aResultStateVariable ),

        iCurrentState( EInitial )

    {

    }

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

// CUpnpStateVariableContentHandler::OnStartElementL

// This method is a callback to indicate an element has been parsed.

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

//

void CUpnpStateVariableContentHandler::OnStartElementL(

    const RTagInfo& aElement, const RAttributeArray& /*aAttributes*/ )

    {

    if ( iCurrentState == EInitial )

        {

        const TDesC8& elementName( aElement.LocalName().DesC() );

        if ( elementName.Compare( KUpnpName ) == 0 )

            {

            RepeatedTagCheckL( ENamePos, iFoundTags );

            iCurrentState = EName;

            }

        else if ( elementName.Compare( KUpnpDataType ) == 0 )

            {

            RepeatedTagCheckL( EDataTypePos, iFoundTags );

            iCurrentState = EDataType;

            }

        else if ( elementName.Compare( KUpnpDefaultValue ) == 0 )

            {

            RepeatedTagCheckL( EDefaultValuePos, iFoundTags );

            iCurrentState = EDefaultValue;

            }

        else if ( elementName.Compare( KUpnpAllowedValueList ) == 0 )

            {

            RepeatedTagCheckL( EAllowedValuePos, iFoundTags );

            iController.SetCurrentContentHandlerL( 

                CUpnpAllowedValueListContentHandler::NewL(

                    iController, iResultStateVariable ) );

            }

        else if ( elementName.Compare( KUpnpAllowedValueRange ) == 0 )

            {

            RepeatedTagCheckL( EAllowedValuePos, iFoundTags );

            iController.SetCurrentContentHandlerL( 

                CUpnpAllowedValueRangeContentHandler::NewL(

                    iController, iResultStateVariable ) );

            }

        else

            {

            iController.SetCurrentContentHandlerL( 

                CUpnpIgnoreContentHandler::NewL( iController ) );

            }

        }

    else

        {

        //User::Leave( KErrArgument ) //content="textOnly" not checked now

        iController.SetCurrentContentHandlerL( 

            CUpnpIgnoreContentHandler::NewL( iController ) );

        }

    }

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

// CUpnpStateVariableContentHandler::OnEndElementL

// This method is a callback to indicate the end of the element has been reached.

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

//

void CUpnpStateVariableContentHandler::OnEndElementL( const RTagInfo& aElement )

    {

    switch ( iCurrentState )

        {

        case EInitial:

            ASSERT( aElement.LocalName().DesC().Compare(KUpnpStateVariable)==0 );

            if ( (iFoundTags.iFlags & KReqiuredTagsBoundary) == 

                    KReqiuredTagsBoundary )

                {

                iController.SetPreviousContentHandler();

                }

            else

                {

                //User::Leave( KErrArgument ) //required tag not found                    

                iController.SetPreviousContentHandler();

                }

            break;

        default:

            iCurrentState = EInitial;

        }

    }

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

// CUpnpStateVariableContentHandler::OnContentL

// This method is a callback that sends the content of the element.

// aErrorCode must be KErrNone, and that aBytes should contains complete

// content (one chunk).

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

//

void CUpnpStateVariableContentHandler::OnContentL( const TDesC8& aBytes )

    {

    switch ( iCurrentState )

        {

        case EName:

            iResultStateVariable.SetNameL( aBytes );

            break;

        case EDataType:

            iResultStateVariable.SetTypeL( aBytes );

            break;

        case EDefaultValue:

            iResultStateVariable.SetDefaultValueL( aBytes );

            break;

        default:

            //User::Leave( KErrArgument ) //eltOnly not checked now

            break;

        }

    }

//  End of File