/*

* Copyright (c) 2005 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:  Container of one reactive authorization item

*

*/

// INCLUDE FILES

#include    "CPEngAuthorizationItem.h"

#include    "PEngListLibraryPanics.h"

#include    <e32std.h>

#include    <s32strm.h>

// ============================ LOCAL FUNCTIONS ===============================

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

// Compares two TUint32 numbers.

// Follows standard comparison rules.

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

//

TInt CompareTUint32( const TUint32& aA, const TUint32& aB )

    {

    return aA - aB;

    }

#define ARRAY_ORDER TLinearOrder<TUint32> ( CompareTUint32 )

// CONST

// Space required in stream to store one TInt32 - 4 bytes

const TInt KTIntStoreSize =  4;

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

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

// CPEngAuthorizationItem::CPEngAuthorizationItem

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

//

CPEngAuthorizationItem::CPEngAuthorizationItem( TInt& aSize )

        : iSize( aSize )

    {

    // length of the User Id => 4 bytes

    iSize += KTIntStoreSize;

    }

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

// CPEngAuthorizationItem::ConstructL()

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

//

void CPEngAuthorizationItem::ConstructL( const TDesC& aUserId )

    {

    iUserId = aUserId.AllocL();

    iSize += ( aUserId.Length() );

    }

// Destructor

CPEngAuthorizationItem::~CPEngAuthorizationItem()

    {

    if ( iUserId )

        {

        iSize -= ( KTIntStoreSize + iUserId->Length() );

        }

    else

        {

        iSize -= KTIntStoreSize;

        }

    delete iUserId;

    }

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

// CPEngAuthorizationItem::UserId()

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

//

const TDesC& CPEngAuthorizationItem::Id() const

    {

    return *iUserId;

    }

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

// CPEngAuthorizationItem::LocalFlags()

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

//

TInt CPEngAuthorizationItem::LocalFlags() const

    {

    return iLocalFlags;

    }

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

// CPEngAuthorizationItem::SetLocalFlags()

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

//

void CPEngAuthorizationItem::SetLocalFlags( TInt aLocalFlag )

    {

    iLocalFlags = aLocalFlag;

    }

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

// CPEngAuthorizationItem::ExternalizeL()

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

//

void CPEngAuthorizationItem::ExternalizeL( RWriteStream& aStream ) const

    {

    aStream.WriteInt32L( iUserId->Length() );

    aStream << *iUserId;

    }

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

// CPEngAuthorizationItem::InternalizeL()

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

//

void CPEngAuthorizationItem::InternalizeL( RReadStream& aStream )

    {

    __ASSERT_DEBUG( !iUserId, Panic( EReactiveAuthInternalizeMisused ) );

    // user Id

    TInt length( aStream.ReadInt32L() );

    iUserId = HBufC::NewL( aStream, length );

    iSize += length;

    }

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

// CPEngAuthorizationItem::ExternalizeArrayL()

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

//

void CPEngAuthorizationItem::ExternalizeArrayL( RWriteStream& aStream,

                                                const RArray<TUint32>& aArray )

    {

    TInt count( aArray.Count() );

    aStream.WriteInt32L( count );

    for ( TInt x( 0 ) ; x < count ; ++x )

        {

        aStream.WriteInt32L( aArray[ x ] );

        }

    }

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

// CPEngAuthorizationItem::InternalizeArrayL()

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

//

void CPEngAuthorizationItem::InternalizeArrayL( RReadStream& aStream,

                                                RArray<TUint32>& aArray,

                                                TInt& aSize )

    {

    // 4 bytes per each number

    aSize -= ( KTIntStoreSize * aArray.Count() );

    TInt count( aStream.ReadInt32L() );

    aArray.Reset();

    for ( TInt x( 0 ) ; x < count ; ++x )

        {

        aArray.AppendL( aStream.ReadInt32L() );

        //  4 bytes per each attribute

        aSize += KTIntStoreSize;

        }

    }

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

// CPEngAuthorizationItem::SizeOfArray()

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

//

TInt CPEngAuthorizationItem::SizeOfArray( const RArray<TUint32>& aArray )

    {

    // 4 bytes per each element of array + count of the array

    return KTIntStoreSize * ( aArray.Count() + 1 );

    }

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

// CPEngAuthorizationItem::AddAttributeToArrayL()

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

//

TInt CPEngAuthorizationItem::AddAttributeToArrayL( RArray<TUint32>& aArray,

                                                   TUint32 aAttribute )

    {

    TInt err( aArray.InsertInOrder( aAttribute, ARRAY_ORDER ) );

    if ( err == KErrAlreadyExists )

        {

        return 0; //nothing was added => size change 0

        }

    User::LeaveIfError( err );

    return KTIntStoreSize;

    }

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

// CPEngAuthorizationItem::CopyArrayContentL()

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

//

TInt CPEngAuthorizationItem::CopyArrayContentL( RArray<TUint32>& aTarget,

                                                const TArray<TUint32>& aSource )

    {

    TInt sizeDelta( 0 );

    TInt count( aSource.Count() );

    for ( TInt x( 0 ) ; x < count ; ++x )

        {

        sizeDelta += AddAttributeToArrayL( aTarget, aSource[ x ] );

        }

    return sizeDelta;

    }

//  End of File