/*

* Copyright (c) 2002-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:  CCFEqual class implementation.

*

*/

// INCLUDES

#include "cfequal.h"

#include "cfcontextobject.h"

#include "cfcontextoperationutils.h"

#include "cfbasicoptrace.h"

#include <gmxmlnode.h>

// CONSTANTS

_LIT( KScriptEqualName,     "equal"     );

_LIT( KScriptEqualsName,    "equals"    );

// ============================ MEMBER FUNCTIONS ===============================

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

// CCFEqual::CCFEqual

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CCFEqual::CCFEqual( MCFOperationServices& aServices,

    CCFOperationNode* aParent,

    HBufC* aName,

    HBufC* aSource,

    const CCFContextOperation::TCmpType aType )

    :   CCFContextOperation( aServices, aParent, aName, aSource ),

        iType( aType )

    {

    FUNC_LOG;

    }

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

// CCFEqual::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CCFEqual::ConstructL( const TDesC& aCmpVal )

    {

    FUNC_LOG;

    iCmpValue = aCmpVal.AllocL();

    }

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

// CCFEqual::NewL

// Two-phased constructor.

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

//

CCFEqual* CCFEqual::NewL( MCFOperationServices& aServices,

    CCFOperationNode* aParent,

    TDesC& aName,

    TDesC& aSource,

    const CCFContextOperation::TCmpType aType,

    const TDesC& aCmpVal )

    {

    FUNC_LOG;

    CCFEqual* self

        = NewLC( aServices, aParent, aName, aSource, aType, aCmpVal );

    CleanupStack::Pop( self );

    return self;

    }

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

// CCFEqual::NewLC

// Two-phased constructor.

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

//

CCFEqual* CCFEqual::NewLC( MCFOperationServices& aServices,

    CCFOperationNode* aParent,

    TDesC& aName,

    TDesC& aSource,

    const CCFContextOperation::TCmpType aType,

    const TDesC& aCmpVal )

    {

    FUNC_LOG;

    HBufC* name = aName.AllocLC();

    HBufC* source = aSource.AllocLC();

    CCFEqual* self

        = new( ELeave ) CCFEqual( aServices, aParent, name, source, aType );

    CleanupStack::Pop( source );

    CleanupStack::Pop( name );

    CleanupStack::PushL( self );

    self->ConstructL( aCmpVal );

    return self;

    }

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

// CCFEqual::ParseL

// Construction with parsing from a DOM node.

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

//

CCFEqual* CCFEqual::ParseL( MCFOperationServices& aServices,

    CCFOperationNode* aParent,

    CMDXMLNode& aNode )

    {

    FUNC_LOG;

    if ( aNode.NodeName().CompareF( KScriptEqualName ) != 0

        && aNode.NodeName().CompareF( KScriptEqualsName ) != 0 )

        {

        return NULL; // Cannot create equal operation from the given node.

        }

    TPtrC contextSource;

    TPtrC contextType;

    TCmpType cmpType( CCFContextOperation::EInvalidCmpType );

    TPtrC cmpValue;

    TInt contextLevelDelay( 0 );

    TBool argsOK = CFContextOperationUtils::ParseTwoComparisonArgs( aNode,

            contextSource,

            contextType,

            cmpType,

            cmpValue,

            contextLevelDelay );

    CCFEqual* self = NULL;

    if ( argsOK )

        {

        self = NewL( aServices,

                aParent,

                contextType,

                contextSource,

                cmpType,

                cmpValue );

        if ( contextLevelDelay )

            {

            self->iContextLevelDelay = contextLevelDelay;

            }

        }

    else

        {

        INFO( "CCFEqual::ParseL - Unsupported arguments" );

        }

    CREATE_DOM_INFO( self, aNode );

    return self;

    }

// Destructor

CCFEqual::~CCFEqual()

    {

    FUNC_LOG;

    delete iCmpValue;

    }

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

// CCFEqual::IsTrueL

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

//

TBool CCFEqual::IsTrueL( const CCFContextObject& aContextObject )

    {

    FUNC_LOG;

    TBool value( EFalse );

    switch ( iType )

        {

        case CCFContextOperation::EIntCmp:

            {

            TInt a = CFContextOperationUtils::StringToIntL( *iCmpValue );

            TInt b = CFContextOperationUtils::StringToIntL(

                    aContextObject.Value() );

            value = ( a == b );

            break;

            }

        case CCFContextOperation::ETimeCmp:

            {

            TTime a = CFContextOperationUtils::StringToTimeL( *iCmpValue );

            TTime b = CFContextOperationUtils::StringToTimeL(

                    aContextObject.Value() );

            value = ( a == b );

            break;

            }

        case CCFContextOperation::EFloatCmp:

            {

            TReal a = CFContextOperationUtils::StringToRealL( *iCmpValue );

            TReal b = CFContextOperationUtils::StringToRealL(

                    aContextObject.Value() );

            value = ( a == b );

            break;

            }

        case CCFContextOperation::EStringCmp:

        default:

            {

            value = ( *iCmpValue == aContextObject.Value() );

            break;

            }

        }

    return value;

    }