/*

* 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 response

*

*/

// INCLUDE FILES

#include    <e32std.h>

#include    <s32strm.h>

#include    "CPEngAuthorizationResponse.h"

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

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

// CPEngAuthorizationResponse::CPEngAuthorizationResponse()

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

//

CPEngAuthorizationResponse::CPEngAuthorizationResponse( TInt& aSize )

        : CPEngAuthorizationItem( aSize )

    {

    //state, attributes count, 4 bytes per each

    iSize += 8;

    }

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

// CPEngAuthorizationResponse::ConstructL()

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

//

void CPEngAuthorizationResponse::ConstructL( const TDesC& aUserId )

    {

    CPEngAuthorizationItem::ConstructL( aUserId );

    }

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

// CPEngAuthorizationResponse::NewLC()

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

//

CPEngAuthorizationResponse* CPEngAuthorizationResponse::NewLC( const TDesC& aUserId,

                                                               TInt& aSize )

    {

    CPEngAuthorizationResponse* self =

        new ( ELeave ) CPEngAuthorizationResponse( aSize );

    CleanupStack::PushL( self );

    self->ConstructL( aUserId );

    return self;

    }

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

// CPEngAuthorizationResponse::NewLC()

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

//

CPEngAuthorizationResponse* CPEngAuthorizationResponse::NewLC( RReadStream& aStream,

                                                               TInt& aSize )

    {

    CPEngAuthorizationResponse* self =

        new( ELeave ) CPEngAuthorizationResponse( aSize );

    CleanupStack::PushL( self );

    self->InternalizeL( aStream );

    return self;

    }

// Destructor

CPEngAuthorizationResponse::~CPEngAuthorizationResponse()

    {

    // 4 bytes per number: State

    iSize -= ( 4 + SizeOfArray( iAttributes ) );

    iAttributes.Reset();

    }

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

// CPEngAuthorizationResponse::UpdateLocalFlags()

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

//

void CPEngAuthorizationResponse::DoUpdateLocalFlags(

    const CPEngAuthorizationItem& aSource )

    {

    const CPEngAuthorizationResponse& source =

        static_cast< const CPEngAuthorizationResponse&> ( aSource );

    if ( ( source.AuthorizationStatus() == AuthorizationStatus() )

         && ( source.AuthorizedAttributes().Count() == iAttributes.Count() ) )

        {

        iLocalFlags = source.LocalFlags();

        }

    }

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

// CPEngAuthorizationResponse::UserId()

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

//

const TDesC& CPEngAuthorizationResponse::UserId() const

    {

    return Id();

    }

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

// CPEngAuthorizationResponse::AuthorizationStatus()

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

//

TInt CPEngAuthorizationResponse::AuthorizationStatus() const

    {

    return iResponseType;

    }

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

// CPEngAuthorizationResponse::AuthorizedAttributes()

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

//

const RArray<TUint32>& CPEngAuthorizationResponse::AuthorizedAttributes() const

    {

    return iAttributes;

    }

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

// CPEngAuthorizationResponse::SetResponseType()

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

//

void CPEngAuthorizationResponse::SetResponseType( TInt aResponseType )

    {

    iResponseType = aResponseType;

    }

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

// CPEngAuthorizationResponse::SetAttributesToAuthorizeL()

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

//

void CPEngAuthorizationResponse::SetAttributesToAuthorizeL(

    const TArray<TUint32>& aAttributes,

    const RArray<TUint32>* aAuthorizedAttributes )

    {

    // 4 bytes per each attribute

    iSize -= ( 4 * iAttributes.Count() );

    iAttributes.Reset();

    iSize += CopyArrayContentL( iAttributes, aAttributes );

    // shall already authorized attributes be included

    if ( aAuthorizedAttributes )

        {

        iSize += CopyArrayContentL( iAttributes, aAuthorizedAttributes->Array() );

        }

    }

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

// CPEngAuthorizationResponse::AddAttributeL()

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

//

void CPEngAuthorizationResponse::AddAttributeL( TUint32 aAttribute )

    {

    AddAttributeToArrayL( iAttributes, aAttribute );

    }

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

// CPEngAuthorizationResponse::ExternalizeL()

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

//

void CPEngAuthorizationResponse::ExternalizeL( RWriteStream& aStream ) const

    {

    // base class

    CPEngAuthorizationItem::ExternalizeL( aStream );

    // response type

    aStream.WriteInt32L( iResponseType );

    // Attributes

    ExternalizeArrayL( aStream, iAttributes );

    }

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

// CPEngAuthorizationResponse::ExternalizeCachedL()

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

//

void CPEngAuthorizationResponse::InternalizeL( RReadStream& aStream )

    {

    // base class

    CPEngAuthorizationItem::InternalizeL( aStream );

    // response type

    iResponseType = aStream.ReadInt32L();

    // Attributes

    InternalizeArrayL( aStream, iAttributes, iSize );

    }

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

// CPEngAuthorizationResponse::Compare()

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

//

TInt CPEngAuthorizationResponse::Compare( const CPEngAuthorizationResponse& aFirst,

                                          const CPEngAuthorizationResponse& aSecond )

    {

    return aFirst.Id().CompareF( aSecond.Id() ) ;

    }

//  End of File