/*

 * Copyright (c) 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: Definition of entry attribute

 *

 */

// INCLUDE FILES

#include <s32mem.h>

#include "caarraycleanup.inl"

#include "caentryattribute.h"

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

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

// CCaEntryAttribute::~CMenuItemAttr

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

//

CCaEntryAttribute::~CCaEntryAttribute()

    {

    iName.Close();

    iValue.Close();

    }

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

// CCaEntryAttribute::NewL

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

//

EXPORT_C CCaEntryAttribute* CCaEntryAttribute::NewL( const TDesC& aName )

    {

    CCaEntryAttribute* attr = NewLC( aName );

    CleanupStack::Pop( attr );

    return attr;

    }

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

// CCaEntryAttribute::NewLC

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

//

EXPORT_C CCaEntryAttribute* CCaEntryAttribute::NewLC( const TDesC& aName )

    {

    CCaEntryAttribute* attr = new ( ELeave ) CCaEntryAttribute();

    CleanupStack::PushL( attr );

    attr->ConstructL( aName );

    return attr;

    }

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

// CCaEntryAttribute::ConstructL

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

//

void CCaEntryAttribute::ConstructL( const TDesC& aName )

    {

    iName.CreateL( aName );

    }

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

// CCaEntryAttribute::ConstructL

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

//

EXPORT_C void CCaEntryAttribute::SetValueL( const TDesC& aName )

    {

    if( iValue.Length() > 0 )

        {

        iValue.Close();

        }

    iValue.CreateL( aName );

    }

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

// CCaEntryAttribute::ExternalizeL

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

//

void CCaEntryAttribute::ExternalizeL( RWriteStream& aStream ) const

    {

    aStream.WriteUint32L( iName.Length() );

    aStream.WriteL( iName, iName.Length() );

    aStream.WriteUint32L( iValue.Length() );

    aStream.WriteL( iValue, iValue.Length() );

    aStream.CommitL();

    }

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

// CCaEntryAttribute::InternalizeL

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

//

void CCaEntryAttribute::InternalizeL( RReadStream& aStream )

    {

    TUint length = aStream.ReadUint32L();

    iName.Close();

    iName.CreateL( length );

    aStream.ReadL( iName, length );

    length = aStream.ReadUint32L();

    iValue.Close();

    iValue.CreateL( length );

    aStream.ReadL( iValue, length );

    }

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

// RMenuSrvAttrArray::Find

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

//

EXPORT_C TBool RCaEntryAttrArray::Find( const TDesC& aName, TDes& aAttrVal )

    {

    for( TInt i = 0; i < Count(); i++ )

        {

        if( aName.Compare( operator[]( i )->Name() ) == KErrNone )

            {

            aAttrVal = operator[]( i )->Value();

            return ETrue;

            }

        }

    return EFalse;

    }

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

// RCaEntryAttrArray::Exist

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

//

EXPORT_C TBool RCaEntryAttrArray::Exist( const TDesC& aName )

    {

    for( TInt i = 0; i < Count(); i++ )

        {

        if( aName.Compare( operator[]( i )->Name() ) == KErrNone )

            {

            return ETrue;

            }

        }

    return EFalse;

    }

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

// RCaEntryAttrArray::RemoveAttribute

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

//

EXPORT_C void RCaEntryAttrArray::RemoveAttribute( const TDesC& aAttrName )

    {

    for( TInt i = 0; i < Count(); i++ )

        {

        if( aAttrName == operator[]( i )->Name() )

            {

            delete operator[]( i );

            Remove( i );

            break;

            }

        }

    }

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

// RCaEntryAttrArray::ExternalizeL

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

//

void RCaEntryAttrArray::ExternalizeL( RWriteStream& aStream ) const

    {

    aStream.WriteUint16L( Count() );

    for( TInt i = 0; i < Count(); i++ )

        {

        operator[]( i )->ExternalizeL( aStream );

        }

    }

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

// RCaEntryAttrArray::InternalizeL

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

//

void RCaEntryAttrArray::InternalizeL( RReadStream& aStream )

    {

    ResetAndDestroy();

    TUint count = aStream.ReadUint16L();

    for( TInt i = 0; i < count; i++ )

        {

        CCaEntryAttribute* attr = CCaEntryAttribute::NewLC( KNullDesC );

        attr->InternalizeL( aStream );

        AppendL( attr );

        CleanupStack::Pop( attr );

        }

    }

//  End of File