/*

* Copyright (c) 2002 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:  ImumInSettingsDataAttribute.cpp

*

*/

// INCLUDE FILES

#include <e32base.h>

#include "ImumInSettingsDataAttribute.h"

#include "ImumInSettingsDataCtrl.h"

#include "ImumUtilsLogging.h"

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

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

// CImumInSettingsDataAttribute::NewL()

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

//

CImumInSettingsDataAttribute* CImumInSettingsDataAttribute::NewL(

    const TUint aAttributeId,

    const TInt aAttributeType,

    const TUint aAttributeSize,

    const TAny* aAttributeValue,

    const TAny* aAttributeDefault )

    {

    CImumInSettingsDataAttribute* self = NewLC(

        aAttributeId,

        aAttributeType,

        aAttributeSize,

        aAttributeValue,

        aAttributeDefault );

    CleanupStack::Pop( self );

    return self;

    }

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

// CImumInSetting::NewLC()

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

//

CImumInSettingsDataAttribute* CImumInSettingsDataAttribute::NewLC(

    const TUint aAttributeId,

    const TInt aAttributeType,

    const TUint aAttributeSize,

    const TAny* aAttributeValue,

    const TAny* aAttributeDefault )

    {

    CImumInSettingsDataAttribute* self =

        new ( ELeave ) CImumInSettingsDataAttribute();

    CleanupStack::PushL( self );

    self->ConstructL(

        aAttributeId,

        aAttributeType,

        aAttributeSize,

        aAttributeValue,

        aAttributeDefault );

    return self;

    }

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

// CImumInSettingsDataAttribute::CImumInSettingsDataAttribute()

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

//

CImumInSettingsDataAttribute::CImumInSettingsDataAttribute()

    :

    iType( 0 ),

    iSize( 0 ),

    iValue( NULL ),

    iDefault( NULL )

    {

    }

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

// CImumInSettingsDataAttribute::~CImumInSettingsDataAttribute()

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

//

CImumInSettingsDataAttribute::~CImumInSettingsDataAttribute()

    {

    Cleanup();

    iValue = NULL;

    iDefault = NULL;

    }

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

// CImumInSettingsDataAttribute::ConstructL()

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

//

void CImumInSettingsDataAttribute::ConstructL(

    const TUint aAttributeId,

    const TInt aAttributeType,

    const TUint aAttributeSize,

    const TAny* aAttributeValue,

    const TAny* aAttributeDefault )

    {

    SetAttributeL(

        aAttributeId,

        aAttributeType,

        aAttributeSize,

        aAttributeValue,

        aAttributeDefault );

    }

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

// CImumInSettingsDataAttribute::Cleanup()

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

//

void CImumInSettingsDataAttribute::Cleanup()

    {

    // Delete attribute data accoding to its type

    if ( ImumInSettingsDataCtrl::IsText( iType ) )

        {

        DeleteText();

        }

    else if ( iType == ECmpTInt64 )

        {

        DeleteNumber<TInt64>();

        }

    else

        {

        DeleteNumber<TInt>();

        }

    }

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

// CImumInSettingsDataAttribute::DeleteText()

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

//

void CImumInSettingsDataAttribute::DeleteText()

    {

    // Doing the deletion. Both value and default must be deleted from

    // the memory as both of the items are objects.

    if ( iType == ECmpNormal )

        {

        delete reinterpret_cast<HBufC*>( iValue );

        delete reinterpret_cast<HBufC*>( iDefault );

        }

    else if ( iType == ECmpNormal8 )

        {

        delete reinterpret_cast<HBufC8*>( iValue );

        delete reinterpret_cast<HBufC8*>( iDefault );

        }

    else

        {

        // This just can't simply happen, since it would be a number

        }

    iValue = NULL;

    iDefault = NULL;

    }

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

// CImumInSettingsDataAttribute::SetAttributeL()

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

//

void CImumInSettingsDataAttribute::SetAttributeL(

    const TUint aAttributeId,

    const TInt aAttributeType,

    const TUint aAttributeSize,

    const TAny* aAttributeValue,

    const TAny* aAttributeDefault )

    {

    // Make sure that previous item is cleaned up

    Cleanup();

    iId     = aAttributeId;

    iType   = aAttributeType;

    iSize   = aAttributeSize;

    AllocL( aAttributeValue, aAttributeDefault );

    }

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

// CImumInSettingsDataAttribute::AllocL()

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

//

void CImumInSettingsDataAttribute::AllocL(

    const TAny* aValue,

    const TAny* aDefault )

    {

    // Allocate data only if the values contains valid information

    if ( aValue && aDefault )

        {

        // Create copy of the text

        if ( ImumInSettingsDataCtrl::IsText( iType ) )

            {

            iValue = reinterpret_cast<const TDes*>( aValue )->AllocL();

            iDefault = reinterpret_cast<const TDes*>( aDefault )->AllocL();

            }

        else if ( iType == ECmpTInt64 )

            {

            DoAllocL<TInt64>( aValue, aDefault );

            }

        else

            {

            DoAllocL<TInt>( aValue, aDefault );

            }

        }

    }

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

// CImumInSettingsDataAttribute::CloneL()

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

//

CImumInSettingsDataAttribute* CImumInSettingsDataAttribute::CloneL()

    {

    return NewL( iId, iType, iSize, iValue, iDefault );

    }

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

// CImumInSettingsDataAttribute::Copy()

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

//

void CImumInSettingsDataAttribute::Copy(

    const CImumInSettingsDataAttribute& aAttribute )

    {

    TRAP_IGNORE( SetAttributeL(

        aAttribute.iId,

        aAttribute.iType,

        aAttribute.iSize,

        aAttribute.iValue,

        aAttribute.iDefault ) );

    }

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

// CImumInSettingsDataAttribute::Reset()

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

//

void CImumInSettingsDataAttribute::Reset()

    {

    // Copy the value in the

    if ( iType == ECmpNormal )

        {

        // Only copy if the descriptor contents differ

        if( reinterpret_cast<TDes*>( iValue )->Compare(

        		*reinterpret_cast<TDesC*>( iDefault ) ) )

        	reinterpret_cast<TDes*>( iValue )->Copy(

        			*reinterpret_cast<TDesC*>( iDefault ) );

        }

    else if ( iType == ECmpNormal8 )

        {

        // Only copy if the descriptor contents differ

        if( reinterpret_cast<TDes8*>( iValue )->Compare(

        		*reinterpret_cast<TDesC8*>( iDefault ) ) )

        	reinterpret_cast<TDes8*>( iValue )->Copy(

        			*reinterpret_cast<TDesC8*>( iDefault ) );

        }

    else

        {

        memmove( iValue, iDefault, iSize );

        }

    }

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

// CImumInSettingsDataAttribute::operator==()

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

//

TBool CImumInSettingsDataAttribute::operator==(

    const CImumInSettingsDataAttribute& aAttribute )

    {

    return ( iValue == aAttribute.iValue );

    }

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

// CImumInSettingsDataAttribute::operator!=()

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

//

TBool CImumInSettingsDataAttribute::operator!=(

    const CImumInSettingsDataAttribute& aAttribute )

    {

    return ( iValue != aAttribute.iValue );

    }

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

// CImumInSettingsDataAttribute::SetId()

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

//

void CImumInSettingsDataAttribute::SetId( const TUint aId )

    {

    iId = aId;

    }

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

// CImumInSettingsDataAttribute::IdCompare()

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

//

TBool CImumInSettingsDataAttribute::IdCompare(

    const CImumInSettingsDataAttribute& aLeft,

    const CImumInSettingsDataAttribute& aRight )

    {

    return ( aLeft.Id() == aRight.Id() );

    }

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

// CImumInSettingsDataAttribute::Id()

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

//

TUint CImumInSettingsDataAttribute::Id() const

    {

    return iId;

    }

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

// CImumInSettingsDataAttribute::Type()

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

//

TInt CImumInSettingsDataAttribute::Type() const

    {

    return iType;

    }

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

// CImumInSettingsDataAttribute::Log()

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

//

void CImumInSettingsDataAttribute::Log() const

    {

    IMUM_CONTEXT( CImumInSettingsDataAttribute::Log, 0, KLogDataAttr );

    IMUM_IN();

    IMUM0( 0, "------------------------------------------------------" );

    IMUM1( 0, "Attribute: 0x%x", this );

    IMUM1( 0, "Attribute ID: 0x%x", iId );

    IMUM1( 0, "Attribute type: 0x%x", iType );

    IMUM1( 0, "Attribute size: 0x%x", iSize );

    IMUM1( 0, "Attribute iValue; addr: 0x%x", iValue );

    IMUM1( 0, "Attribute iDefault; addr: 0x%x", iDefault );

    IMUM0( 0, "------------------------------------------------------" );

    IMUM_OUT();

    }

// End of File