/*

* Copyright (c) 2008-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:  CCFContextSourceCommandImpl class implementation.

 *

*/

// SYSTEM INCLUDES

#include <s32strm.h>

// USER INCLUDES

#include "cfcontextsourcecommandimpl.h"

#include "cftrace.h"

// CONSTANTS

_LIT( KUidAttribute, "uid" );

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

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

// C++ constructor.

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

//

CCFContextSourceCommandImpl::CCFContextSourceCommandImpl()

    {

    FUNC_LOG;

    }

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

// Symbian 2nd phase constructor.

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

//

void CCFContextSourceCommandImpl::ConstructL()

    {

    FUNC_LOG;

    }

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

// Symbian two phased constructor.

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

//

CCFContextSourceCommandImpl* CCFContextSourceCommandImpl::NewL()

    {

    FUNC_LOG;

    CCFContextSourceCommandImpl* self = CCFContextSourceCommandImpl::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

// Symbian two phased constructor.

// Leaves pointer in the cleanup stack.

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

//

CCFContextSourceCommandImpl* CCFContextSourceCommandImpl::NewLC()

    {

    FUNC_LOG;

    CCFContextSourceCommandImpl* self

            = new( ELeave ) CCFContextSourceCommandImpl;

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// C++ destructor.

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

//

CCFContextSourceCommandImpl::~CCFContextSourceCommandImpl()

    {

    FUNC_LOG;

    iParameters.ResetAndDestroy();

    iAttributes.ResetAndDestroy();

    delete iName;

    }

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

// CCFContextSourceCommandImpl::Sender

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

//

const TCFSourceCommandSenderId& CCFContextSourceCommandImpl::Sender() const

    {

    FUNC_LOG;

    return iSender;

    }

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

// CCFContextSourceCommandImpl::SetSender

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

//

void CCFContextSourceCommandImpl::SetSender(

    const TCFSourceCommandSenderId& aSender )

    {

    FUNC_LOG;

    iSender = aSender;

    }

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

// CCFContextSourceCommandImpl::Name

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

//

const TDesC& CCFContextSourceCommandImpl::Name() const

    {

    FUNC_LOG;

    if ( iName )

        {

        return *iName;

        }

    else

        {

        return KNullDesC;

        }

    }

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

// CCFContextSourceCommandImpl::SetNameL

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

//

void CCFContextSourceCommandImpl::SetNameL( const TDesC& aName )

    {

    FUNC_LOG;

    delete iName;

    iName = NULL;

    iName = aName.AllocL();

    }

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

// CCFContextSourceCommandImpl::SourceUid

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

//

TUid CCFContextSourceCommandImpl::SourceUid() const

    {

    FUNC_LOG;

    TUid sourceUid = KNullUid;

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

        {

        CCFKeyValuePair* keyValue = iAttributes[ i ];

        if ( keyValue->Key().CompareF( KUidAttribute ) == 0 )

            {

            TPtrC uidString( keyValue->Value() );

            TLex lex( uidString );

            // Get rid of '0x'.

            const TInt skip = 2;

            lex.Inc( skip );

            TUint32 uid = 0;

            const TUint KLimit = 0xFFFFFFFF;

            TInt err = lex.BoundedVal( uid, EHex, KLimit );

            if( err == KErrNone )

                {

                sourceUid = TUid::Uid( uid );

                }

            else

                {

                ERROR_1( err, "CCFContextSourceCommandImpl::SourceUid - Converting source uid from [%S] failed.", &uidString );

                }

            break;

            }

        }

    return sourceUid;

    }

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

// CCFContextSourceCommandImpl::Attributes

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

//

const RKeyValueArray& CCFContextSourceCommandImpl::Attributes() const

    {

    FUNC_LOG;

    return iAttributes;

    }

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

// CCFContextSourceCommandImpl::AddAttributeL

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

//

void CCFContextSourceCommandImpl::AddAttributeL(

    CCFKeyValuePair* aAttribute )

    {

    FUNC_LOG;

    iAttributes.AppendL( aAttribute );

    }

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

// CCFContextSourceCommandImpl::AddAttributesL

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

//

void CCFContextSourceCommandImpl::AddAttributesL( RKeyValueArray& aAttributes )

    {

    FUNC_LOG;

    TInt insertPos = iAttributes.Count();

    for ( TInt i = aAttributes.Count() - 1; i >= 0; --i )

        {

        CCFKeyValuePair* attribute = aAttributes[ i ];

        aAttributes.Remove( i );

        CleanupStack::PushL( attribute );       // CLEANUP<< attribute

        iAttributes.Insert( attribute, insertPos );

        CleanupStack::Pop( attribute );         // CLEANUP>> attribute

        }

    }

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

// CCFContextSourceCommandImpl::Parameters

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

//

const RSourceCommandParameterArray&

CCFContextSourceCommandImpl::Parameters() const

    {

    FUNC_LOG;

    return iParameters;

    }

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

// CCFContextSourceCommandImpl::AddParameterL

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

//

void CCFContextSourceCommandImpl::AddParameterL(

    CCFContextSourceCommandParameter* aParameter )

    {

    FUNC_LOG;

    iParameters.AppendL( aParameter );

    }

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

// CCFContextSourceCommandImpl::Size

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

//

TInt CCFContextSourceCommandImpl::Size() const

    {

    FUNC_LOG;

    TInt size = 0;

    // Sender identity

    size += sizeof( TCFSourceCommandSenderId );

    // Name: length and size of iName

    size += sizeof( TInt32 );

    size += iName->Size();

    // Attributes: array count & data

    size += sizeof( TInt32 );

    TInt count = iAttributes.Count();

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

        {

        // Key length & data

        size += sizeof( TInt32 );

        size += iAttributes[ i ]->Key().Size();

        // Value length & data

        size += sizeof( TInt32 );

        size += iAttributes[ i ]->Value().Size();

        }

    // Parameters: array count & data

    size += sizeof( TInt32 );

    count = iParameters.Count();

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

        {

        size += iParameters[ i ]->Size();

        }

    return size;

    }

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

// CCFContextSourceCommandImpl::ExternalizeL

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

//

void CCFContextSourceCommandImpl::ExternalizeL( RWriteStream& aStream ) const

    {

    FUNC_LOG;

    // Sender identity

    const TUint8* senderId = reinterpret_cast< const TUint8* >( &iSender );

    aStream.WriteL( senderId, sizeof( TCFSourceCommandSenderId ) );

    // Name

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

    aStream.WriteL( *iName );

    // Attributes

    TInt count = iAttributes.Count();

    aStream.WriteInt32L( count );

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

        {

        TPtrC buf( KNullDesC );

        // Key length & data

        buf.Set( iAttributes[ i ]->Key() );

        aStream.WriteInt32L( buf.Length() );

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

        // Value length & data

        buf.Set( iAttributes[ i ]->Value() );

        aStream.WriteInt32L( buf.Length() );

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

        }

    // Parameters

    count = iParameters.Count();

    aStream.WriteInt32L( count );

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

        {

        iParameters[ i ]->ExternalizeL( aStream );

        }

    // Commit stream

    aStream.CommitL();

    }

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

// CCFContextSourceCommandImpl::InternalizeL

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

//

void CCFContextSourceCommandImpl::InternalizeL( RReadStream& aStream )

    {

    FUNC_LOG;

    // Clean up just in case

    delete iName;

    iName = NULL;

    iAttributes.ResetAndDestroy();

    iParameters.ResetAndDestroy();

    // Sender identity

    TUint8* senderId = reinterpret_cast< TUint8* >( &iSender );

    aStream.ReadL( senderId, sizeof( TCFSourceCommandSenderId ) );

    // Name

    TInt len = aStream.ReadInt32L();

    iName = HBufC::NewL( len );

    TPtr namePtr = iName->Des();

    aStream.ReadL( namePtr, len );

    // Attributes

    TInt count = aStream.ReadInt32L();

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

        {

        // Key length & data

        len = aStream.ReadInt32L();

        HBufC* key = HBufC::NewLC( len );           // CLEANUP<< key

        TPtr keyPtr = key->Des();

        aStream.ReadL( keyPtr, len );

        // Value length & data

        len = aStream.ReadInt32L();

        HBufC* value = HBufC::NewLC( len );         // CLEANUP<< value

        TPtr valuePtr = value->Des();

        aStream.ReadL( valuePtr, len );

        // Create & append key value pair

        CCFKeyValuePair* keyValuePair = CCFKeyValuePair::NewL( key, value );

        CleanupStack::Pop( value );                 // CLEANUP>> value

        CleanupStack::Pop( key );                   // CLEANUP>> key

        CleanupStack::PushL( keyValuePair );        // CLEANUP<< keyValuePair

        iAttributes.AppendL( keyValuePair );

        CleanupStack::Pop( keyValuePair );          // CLEANUP>> keyValuePair

        }

    // Parameters

    count = aStream.ReadInt32L();

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

        {

        // below                                    // CLEANUP<< param

        CCFContextSourceCommandParameter* param

            = CCFContextSourceCommandParameter::NewLC();

        param->InternalizeL( aStream );

        iParameters.AppendL( param );

        CleanupStack::Pop( param );                 // CLEANUP>> param

        }

    }

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

// CCFContextSourceCommandImpl::CloneL

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

//

CCFContextSourceCommand* CCFContextSourceCommandImpl::CloneL() const

    {

    FUNC_LOG;

    // below                                        // CLEANUP<< cmd

    CCFContextSourceCommandImpl* cmd = CCFContextSourceCommandImpl::NewLC();

    // Copy command sender identity.

    cmd->iSender = iSender;

    // Copy name.

    if ( iName )

        {

        cmd->iName = iName->AllocL();

        }

    // Copy attributes.

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

        {

        CCFKeyValuePair* keyValue = iAttributes[ i ];

        // below                                    // CLEANUP<< attribute

        CCFKeyValuePair* attribute = CCFKeyValuePair::NewLC( keyValue->Key(),

                keyValue->Value() );

        cmd->iAttributes.AppendL( attribute );

        CleanupStack::Pop( attribute );             // CLEANUP>> attribute

        }

    // Copy parameters.

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

        {

        CCFContextSourceCommandParameter* cmdParam = iParameters[ i ];

        // below                                    // CLEANUP<< param

        CCFContextSourceCommandParameter* param = cmdParam->CloneLC();

        cmd->iParameters.AppendL( param );

        CleanupStack::Pop( param );                 // CLEANUP>> param

        }

    CleanupStack::Pop( cmd );                       // CLEANUP>> cmd

    return cmd;

    }

// End of file