/*

* Copyright (c) 2004 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:  NWSessionSlotID implementation.

*

*/

// INCLUDE FILES

#include    "CPEngNWSessionSlotID2Imp.h"

#include    "CPEngSessionSlotId.h"

#include    <s32strm.h>

#include    <s32mem.h>

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

namespace

    {

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

    // ValueForMatchMode()

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

    //

    const TDesC& ValueForMatchMode( const TDesC& aReqValue,

                                    TPEngNWSSIDMatchMode aMatchMode )

        {

        if ( aMatchMode == EPEngMMWildAny )

            {

            return KPEngMatchSymbolWildAny;

            }

        return aReqValue;

        }

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

    // ExternalizeBufferL()

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

    //

    void ExternalizeBufferL( const HBufC* aBuffer, RWriteStream& aStream )

        {

        if ( aBuffer && aBuffer->Length() != 0 )

            {

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

            aStream.WriteL( *aBuffer );

            }

        else

            {

            aStream.WriteInt32L( 0 );

            }

        }

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

    // InternalizeBufferL()

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

    //

    HBufC* InternalizeBufferL( RReadStream& aStream )

        {

        HBufC* buffer = NULL;

        TInt length = aStream.ReadInt32L();

        if ( length != 0 )

            {

            buffer = HBufC::NewLC( length );

            TPtr ptr( buffer->Des() );

            aStream.ReadL( ptr, length );

            CleanupStack::Pop(); //buffer

            }

        return buffer;

        }

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

    // BufferExternalizeSizeInBytes()

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

    //

    TInt BufferExternalizeSizeInBytes( const HBufC* aBuffer )

        {

        TInt size( 4 ); //Buffer length indicator: 4 bytes

        if ( aBuffer && aBuffer->Length() != 0 )

            {

            size += aBuffer->Size();

            }

        return size;

        }

    }

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

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

// CPEngNWSessionSlotID2Imp::NewL()

// Two-phased constructor.

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

//

CPEngNWSessionSlotID2Imp* CPEngNWSessionSlotID2Imp::NewL()

    {

    CPEngNWSessionSlotID2Imp* self = new ( ELeave ) CPEngNWSessionSlotID2Imp();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CPEngNWSessionSlotID2Imp::CloneL()

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

//

CPEngNWSessionSlotID2Imp* CPEngNWSessionSlotID2Imp::CloneL() const

    {

    CPEngNWSessionSlotID2Imp* clone = CPEngNWSessionSlotID2Imp::NewL();

    CleanupStack::PushL( clone );

    clone->iBasePart->CopyL( *iBasePart );

    if ( iAppId )

        {

        clone->iAppId = iAppId->AllocL();

        }

    clone->iServiceAddressMatchMode = iServiceAddressMatchMode;

    clone->iUserIdMatchMode = iUserIdMatchMode;

    clone->iAppIdMatchMode = iAppIdMatchMode;

    CleanupStack::Pop( clone );

    return clone;

    }

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

// CPEngNWSessionSlotID2Imp::Reset()

// Reset operation.

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

//

void CPEngNWSessionSlotID2Imp::Reset()

    {

    iBasePart->Reset();

    delete iAppId;

    iAppId = NULL;

    iServiceAddressMatchMode = EPEngMMExact;

    iUserIdMatchMode = EPEngMMExact;

    iAppIdMatchMode = EPEngMMExact;

    }

// Destructor

CPEngNWSessionSlotID2Imp::~CPEngNWSessionSlotID2Imp()

    {

    delete iBasePart;

    delete iAppId;

    }

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

// Symbian OS constructor.

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

//

void CPEngNWSessionSlotID2Imp::ConstructL()

    {

    iBasePart = CPEngSessionSlotId::NewL();

    }

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

// CPEngNWSessionSlotID2Imp::CPEngNWSessionSlotID2Imp

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CPEngNWSessionSlotID2Imp::CPEngNWSessionSlotID2Imp()

        : iServiceAddressMatchMode( EPEngMMExact ),

        iUserIdMatchMode( EPEngMMExact ),

        iAppIdMatchMode( EPEngMMExact )

    {

    }

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

// CPEngNWSessionSlotID2Imp::SetServiceAddressL()

// Mutator

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

//

void CPEngNWSessionSlotID2Imp::SetServiceAddressL( const TDesC& aAddress,

                                                   TPEngNWSSIDMatchMode aMatchMode )

    {

    iBasePart->SetServiceAddressL( ValueForMatchMode( aAddress, aMatchMode ) );

    iServiceAddressMatchMode = aMatchMode;

    }

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

// CPEngNWSessionSlotID2Imp::SetUserIdL()

// Mutator

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

//

void CPEngNWSessionSlotID2Imp::SetUserIdL( const TDesC& aUserId,

                                           TPEngNWSSIDMatchMode aMatchMode )

    {

    iBasePart->SetUserIdL( ValueForMatchMode( aUserId, aMatchMode ) );

    iUserIdMatchMode = aMatchMode;

    }

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

// CPEngNWSessionSlotID2Imp::SetAppIdL()

// Mutator

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

//

void CPEngNWSessionSlotID2Imp::SetAppIdL( const TDesC& aAppId,

                                          TPEngNWSSIDMatchMode aMatchMode )

    {

    HBufC* tmpBuf = ValueForMatchMode( aAppId, aMatchMode ).AllocL();

    delete iAppId;

    iAppId = tmpBuf;

    iAppIdMatchMode = aMatchMode;

    }

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

// CPEngNWSessionSlotID2Imp::SetAllL()

// Mutator

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

//

void CPEngNWSessionSlotID2Imp::SetAllL( const CPEngSessionSlotId& aBasePart,

                                        const TDesC& aAppId )

    {

    SetServiceAddressL( aBasePart.ServiceAddress(), EPEngMMExact );

    SetUserIdL( aBasePart.UserId(), EPEngMMExact );

    SetAppIdL( aAppId, EPEngMMExact );

    }

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

// CPEngNWSessionSlotID2Imp::ServiceAddress()

// Accessor

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

//

TPtrC CPEngNWSessionSlotID2Imp::ServiceAddress() const

    {

    return iBasePart->ServiceAddress();

    }

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

// CPEngNWSessionSlotID2Imp::UserId()

// Accessor

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

//

TPtrC CPEngNWSessionSlotID2Imp::UserId() const

    {

    return iBasePart->UserId();

    }

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

// CPEngNWSessionSlotID2Imp::AppId()

// Accessor

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

//

TPtrC CPEngNWSessionSlotID2Imp::AppId() const

    {

    if ( iAppId )

        {

        return *iAppId;

        }

    return KNullDesC();

    }

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

// CPEngNWSessionSlotID2Imp::BasePart()

// Accessor

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

//

const CPEngSessionSlotId& CPEngNWSessionSlotID2Imp::BasePart() const

    {

    return *iBasePart;

    }

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

// CPEngNWSessionSlotID2Imp::IsServiceAddressWild()

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

//

TBool CPEngNWSessionSlotID2Imp::IsServiceAddressWild() const

    {

    return ( iServiceAddressMatchMode != EPEngMMExact );

    }

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

// CPEngNWSessionSlotID2Imp::IsUserIdWild()

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

//

TBool CPEngNWSessionSlotID2Imp::IsUserIdWild() const

    {

    return ( iUserIdMatchMode != EPEngMMExact );

    }

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

// CPEngNWSessionSlotID2Imp::IsAppIdWild()

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

//

TBool CPEngNWSessionSlotID2Imp::IsAppIdWild() const

    {

    return ( iAppIdMatchMode != EPEngMMExact );

    }

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

// CPEngNWSessionSlotID2Imp::IsWild()

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

//

TBool CPEngNWSessionSlotID2Imp::IsWild() const

    {

    return ( IsServiceAddressWild() || IsUserIdWild() || IsAppIdWild() );

    }

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

// CPEngNWSessionSlotID2Imp::IsFullyDefined()

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

//

TBool CPEngNWSessionSlotID2Imp::IsFullyDefined() const

    {

    if ( IsWild() )

        {

        return EFalse;

        }

    if ( ServiceAddress().Length() == 0 )

        {

        return EFalse;

        }

    if ( UserId().Length() == 0 )

        {

        return EFalse;

        }

    if ( AppId().Length() == 0 )

        {

        return EFalse;

        }

    return ETrue;

    }

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

// CPEngNWSessionSlotID2Imp::MatchFullId()

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

//

TInt CPEngNWSessionSlotID2Imp::MatchFullId( const CPEngNWSessionSlotID2Imp& aIdToMatch ) const

    {

    if ( MatchBasePart( aIdToMatch ) != KErrNone )

        {

        return KErrNotFound;

        }

    if ( MatchAppIdPart( aIdToMatch ) != KErrNone )

        {

        return KErrNotFound;

        }

    return KErrNone;

    }

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

// CPEngNWSessionSlotID2Imp::MatchBasePart()

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

//

TInt CPEngNWSessionSlotID2Imp::MatchBasePart(

    const CPEngNWSessionSlotID2Imp& aIdToMatch ) const

    {

    //In case of full ID container, the wild definitions can be

    //in either self object or in parameter one

    //==> must be matched both ways

    if ( MatchBasePart( aIdToMatch.BasePart() ) == KErrNone )

        {

        return KErrNone;

        }

    if ( aIdToMatch.MatchBasePart( BasePart() ) == KErrNone )

        {

        return KErrNone;

        }

    return KErrNotFound;

    }

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

// CPEngNWSessionSlotID2Imp::MatchBasePart()

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

//

TInt CPEngNWSessionSlotID2Imp::MatchBasePart(

    const CPEngSessionSlotId& aBasePartToMatch ) const

    {

    //Both base part fragments must match

    //Check first serviceAddress

    TBool serviceAddressMatch = EFalse;

    if ( IsServiceAddressWild() )

        {

        serviceAddressMatch = ETrue;

        }

    else if ( ServiceAddress().Compare( aBasePartToMatch.ServiceAddress() )

              == KErrNone )

        {

        serviceAddressMatch = ETrue;

        }

    //And then user ID

    TBool userIdMatch = EFalse;

    if ( IsUserIdWild() )

        {

        userIdMatch = ETrue;

        }

    else if ( UserId().Compare( aBasePartToMatch.UserId() ) == KErrNone )

        {

        userIdMatch = ETrue;

        }

    if ( serviceAddressMatch && userIdMatch )

        {

        return KErrNone;

        }

    return KErrNotFound;

    }

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

// CPEngNWSessionSlotID2Imp::MatchAppIdPart()

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

//

TInt CPEngNWSessionSlotID2Imp::MatchAppIdPart(

    const CPEngNWSessionSlotID2Imp& aIdToMatch ) const

    {

    //In case of full ID container, the wild definitions can be

    //in either self object or in parameter one

    //==> must be matched both ways

    if ( MatchAppIdPart( aIdToMatch.AppId() ) == KErrNone )

        {

        return KErrNone;

        }

    if ( aIdToMatch.MatchAppIdPart( AppId() ) == KErrNone )

        {

        return KErrNone;

        }

    return KErrNotFound;

    }

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

// CPEngNWSessionSlotID2Imp::MatchAppIdPart()

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

//

TInt CPEngNWSessionSlotID2Imp::MatchAppIdPart( const TDesC& aAppId ) const

    {

    if ( IsAppIdWild() )

        {

        return KErrNone;

        }

    if ( AppId().Compare( aAppId ) == KErrNone )

        {

        return KErrNone;

        }

    return KErrNotFound;

    }

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

// CPEngNWSessionSlotID2Imp::PackFullLC()

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

//

HBufC8* CPEngNWSessionSlotID2Imp::PackFullLC() const

    {

    TInt size = 6 * 4; //6 static TInts

    //   - Version

    //   - 1 x buffer length

    //   - 3 x matchMode

    //   - Extension length

    size += iBasePart->Size();

    size += BufferExternalizeSizeInBytes( iAppId );