/*

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

*

*/

#include "hnmdbasekey.h"

#include "hnmdstring8key.h"

#include "hnmdintegerkey.h"

#include "hnmdinteger64key.h"

#include "hnmduintegerkey.h"

#include "hnmduidkey.h"

#include "hnmdbooleankey.h"

#include "hnmdstring16key.h"

#include "hnmdmapkey.h"

#include "hnmdlistkey.h"

#include "hnmdundefkey.h"

#include "hnglobals.h"

#include "hnmdkeyfactory.h"

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

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

// 

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

//

EXPORT_C CHnMdBaseKey* HnMdKeyFactory::CreateLC( TXmlEngElement aElement )

    {

    CHnMdBaseKey* self = NULL;

    // First we are testing if the key contains any

    // runtime alterable parameters. If so, they have to be constructed 

    // differently

//    if ( aElement.HasAttributeL( KValueAttrName8) && 

//            aElement.HasAttributeL( KTypeAttrName8 ) ) 

//        {

//        TXmlEngAttr keyValue = aElement.AttributeNodeL( KValueAttrName8 );

//        TXmlEngAttr keyType = aElement.AttributeNodeL( KTypeAttrName8 );

//        if ( keyValue.Value().Find( HnEvent::KEventArgNamespace) 

//                != KErrNotFound)

//            {

//            self = CHnMdDynamicKey::NewL( keyType.Value() );

//            }

//        }

    if ( aElement.HasAttributeL( KTypeAttrName8 ) )

        {

        TXmlEngAttr type = aElement.AttributeNodeL( KTypeAttrName8 );

        const TPtrC8 &name = type.Value();

        self = HnMdKeyFactory::CreateL( name );

        }

    else

        {

        self = CHnMdMapKey::NewL();

        }

    CleanupStack::PushL( self );

    self->BaseConstructL( aElement );

    return self;

    }

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

// 

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

//

EXPORT_C CHnMdBaseKey* HnMdKeyFactory::CreateL( TXmlEngElement aElement )

    {

    CHnMdBaseKey* self = HnMdKeyFactory::CreateLC( aElement );

    CleanupStack::Pop( self );

    return self;

    }

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

// 

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

//

EXPORT_C CHnMdBaseKey* HnMdKeyFactory::CreateL(

    const TDesC8& aName,

    const TDesC8& aType,

    const TDesC8& aValue )

    {

    CHnMdBaseKey* self = HnMdKeyFactory::CreateL( aType );

    CleanupStack::PushL( self );

    self->SetValueL( aValue );

    self->SetKeyNameL( aName );

    CleanupStack::Pop( self );

    return self;

    }

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

// 

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

//

EXPORT_C CHnMdBaseKey* HnMdKeyFactory::CreateL(

    const TDesC8& aName,

    const TDesC8& aType,

    const TDesC& aValue )

    {

    CHnMdBaseKey* self = HnMdKeyFactory::CreateL( aType );

    CleanupStack::PushL( self );

    self->SetValueL( aValue );

    self->SetKeyNameL( aName );

    CleanupStack::Pop( self );

    return self;

    }

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

// 

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

//

CHnMdBaseKey* HnMdKeyFactory::CreateL( const TDesC8& aType )

    {

    CHnMdBaseKey* key = NULL;

    if ( !aType.Compare( KKeyTypeString ) )

        {

        key = CHnMdString16Key::NewL(); //String

        }

    else if ( !aType.Compare( KKeyTypeString8 ) )

        {

        key = CHnMdString8Key::NewL(); //String8

        }

    else if ( !aType.Compare( KKeyTypeInteger ) )

        {

        key = CHnMdIntegerKey::NewL(); //Integer

        }

    else if ( !aType.Compare( KKeyTypeInteger64 ) )

        {

        key = CHnMdInteger64Key::NewL(); //Integer64

        }

    else if ( !aType.Compare( KKeyTypeUInteger ) )

        {

        key = CHnMdUIntegerKey::NewL(); //Unsigned Integer

        }

    else if ( !aType.Compare( KKeyTypeUid ) )

        {

        key = CHnMdUidKey::NewL(); //Uid

        }

    else if ( !aType.Compare( KKeyTypeBoolean ) )

        {

        key = CHnMdBooleanKey::NewL(); //Boolean

        }

    else if ( !aType.Compare( KKeyTypeString16 ) )

        {

        key = CHnMdString16Key::NewL(); //String16

        }

    else if ( !aType.Compare( KKeyTypeMap ) )

        {

        key = CHnMdMapKey::NewL(); //Map

        }

    else if ( !aType.Compare( KKeyTypeList ) )

        {

        key = CHnMdListKey::NewL(); //List

        }

    else

        {

        key = CHnMdUndefKey::NewL(); //Undefined

        }

    return key;

    }