/** @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 CUpnpArgumentContentHandler class

 *

*/

#include "upnpargumentcontenthandler.h"

#include "upnpcontenthandlerscontroller.h"

#include "upnpignorecontenthandler.h"

#include "upnpargument.h"

#include "upnpserviceliterals.h"

//const TUint8 KReqiuredTagsBoundary(7) //first three bits when

//relatedStateVariable, and direction is required

const TUint8 KReqiuredTagsBoundary(1);

enum TFlagsPositions

    {

    ENamePos = 0,

    EDirectionPos,

    ERelatedStateVariablePos    //reqired, but optional for now

//    ERetvalPos 

    };

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

// CUpnpArgumentContentHandler::NewL

// Two-phased constructor

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

//

CUpnpArgumentContentHandler* CUpnpArgumentContentHandler::NewL(

    CUpnpContentHandlersController& aController, CUpnpArgument& aResultArgument )

    {

	CUpnpArgumentContentHandler* argumentContentHandler = 

        CUpnpArgumentContentHandler::NewLC( aController, aResultArgument );

    CleanupStack::Pop( argumentContentHandler );

	return argumentContentHandler;

    }

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

// CUpnpArgumentContentHandler::NewLC

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

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

//

CUpnpArgumentContentHandler* CUpnpArgumentContentHandler::NewLC(

    CUpnpContentHandlersController& aController, CUpnpArgument& aResultArgument )

    {

    CUpnpArgumentContentHandler* argumentContentHandler = 

        new (ELeave) CUpnpArgumentContentHandler( aController, aResultArgument );

	CleanupStack::PushL( argumentContentHandler );	

	return argumentContentHandler;

    }

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

// CUpnpArgumentContentHandler::~CUpnpArgumentContentHandler

// Destructor of CUpnpArgumentContentHandler class 

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

//

CUpnpArgumentContentHandler::~CUpnpArgumentContentHandler()

    {

    }

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

// CUpnpArgumentContentHandler::CUpnpArgumentContentHandler

// Constructor

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

//

CUpnpArgumentContentHandler::CUpnpArgumentContentHandler(

    CUpnpContentHandlersController& aController, CUpnpArgument& aResultArgument ) :

    CUpnpContentHandler( aController ), iResultArgument( aResultArgument ),

            iCurrentState( EInitial )

    {

    }

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

// CUpnpArgumentContentHandler::OnStartElementL

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

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

//

void CUpnpArgumentContentHandler::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(KUpnpDirection) == 0 )

            {

            RepeatedTagCheckL( EDirectionPos, iFoundTags );

            iCurrentState = EDirection;

            }

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

            {

            RepeatedTagCheckL( ERelatedStateVariablePos, iFoundTags );

            iCurrentState = ERelatedStateVariable;

            }

//        else if ( elementName.Compare(KUpnpRetval) == 0 ) 

//            {

//            RepeatedTagCheckL( ERetvalPos, iFoundTags )

//            iController.SetCurrentContentHandlerL(    

//                    CUpnpRetvalContentHandler::NewL( iController ) 

//                                        )

//            }        

                    else

                        {

                        iController.SetCurrentContentHandlerL( 

                            CUpnpIgnoreContentHandler::NewL( iController ) );

                        }

        }

    else

        {

        iController.SetCurrentContentHandlerL( 

            CUpnpIgnoreContentHandler::NewL( iController ) );

        //User::Leave( KErrArgument ) 

        }

    }

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

// CUpnpArgumentContentHandler::OnEndElementL

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

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

//

void CUpnpArgumentContentHandler::OnEndElementL( const RTagInfo& aElement )

    {

    switch ( iCurrentState )

        {

        case EInitial:

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

            if ( ( iFoundTags.iFlags & KReqiuredTagsBoundary ) == 

                                                        KReqiuredTagsBoundary )

                {

                iController.SetPreviousContentHandler();

                }

            else

                {

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

                }

            break;

        default:

            iCurrentState = EInitial;

        }

    }

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

// CUpnpArgumentContentHandler::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 CUpnpArgumentContentHandler::OnContentL( const TDesC8& aBytes )

    {

    switch ( iCurrentState )

        {

        case EName:

            iResultArgument.SetNameL( aBytes );

            break;

        case EDirection:

            if ( aBytes.Compare( KUpnpIn ) == 0 )

                {

                iResultArgument.SetDirectionL( EIn );

                }

            else //if ( aBytes.Compare( KUpnpOut ) == 0 )

                {

                iResultArgument.SetDirectionL( EOut );

                }

//            else

//                {

//                User::Leave( KErrArgument )  

//                }

            break;

        case ERelatedStateVariable:

            iResultArgument.SetRelatedStateVarL( aBytes );

            break;

        default:

            ASSERT( EInitial == iCurrentState );

            //User::Leave( KErrArgument ) 

            break;

        }

    }

//  End of File