/*
* 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:  NWSessionSlotID implementation.
*
*/

// INCLUDE FILES
#include    "CPEngSessionSlotId.h"
#include    "PEngCoreUtilsTools.h"

// CONSTANTS


// ============================ LOCAL FUNCTIONS ===============================
// -----------------------------------------------------------------------------
// CopyBufferL()
// -----------------------------------------------------------------------------
void CopyBufferL( HBufC*& aDest, const HBufC* aSource )
    {
    if ( aSource )
        {
        aDest = aSource->AllocL();
        }
    }



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

// -----------------------------------------------------------------------------
// CPEngSessionSlotId::CPEngSessionSlotId
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CPEngSessionSlotId::CPEngSessionSlotId()
    {
    }

// -----------------------------------------------------------------------------
// CPEngSessionSlotId::NewL()
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
EXPORT_C CPEngSessionSlotId* CPEngSessionSlotId::NewL()
    {
    CPEngSessionSlotId* self = new ( ELeave ) CPEngSessionSlotId();
    return self;
    }


// -----------------------------------------------------------------------------
// CPEngSessionSlotId::NewLC()
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
EXPORT_C CPEngSessionSlotId* CPEngSessionSlotId::NewLC()
    {
    CPEngSessionSlotId* self = new ( ELeave ) CPEngSessionSlotId();
    CleanupStack::PushL( self );
    return self;
    }

// Destructor
CPEngSessionSlotId::~CPEngSessionSlotId()
    {
    delete iServiceAddress;
    delete iUserId;
    }

// -----------------------------------------------------------------------------
// CPEngSessionSlotId::CloneL()
// Two-phased clone constructor.
// -----------------------------------------------------------------------------
//
EXPORT_C CPEngSessionSlotId* CPEngSessionSlotId::CloneL() const
    {
    CPEngSessionSlotId* clone = CloneLC();
    CleanupStack::Pop( clone );
    return clone;
    }

// -----------------------------------------------------------------------------
// CPEngSessionSlotId::CloneLC()
// Two-phased clone constructor.
// -----------------------------------------------------------------------------
//
EXPORT_C CPEngSessionSlotId* CPEngSessionSlotId::CloneLC() const
    {
    CPEngSessionSlotId* clone = new ( ELeave ) CPEngSessionSlotId();
    CleanupStack::PushL( clone );

    clone->CopyL( *this );

    return clone;
    }


// -----------------------------------------------------------------------------
// CPEngSessionSlotId::CopyL()
// Copy operation.
// -----------------------------------------------------------------------------
//
EXPORT_C void CPEngSessionSlotId::CopyL( const CPEngSessionSlotId& aSource )
    {
    CopyBufferL( iServiceAddress, aSource.iServiceAddress );
    CopyBufferL( iUserId, aSource.iUserId );
    }

// -----------------------------------------------------------------------------
// CPEngSessionSlotId::Reset()
// Reset operation.
// -----------------------------------------------------------------------------
//
EXPORT_C void CPEngSessionSlotId::Reset()
    {
    delete iServiceAddress;
    delete iUserId;

    iServiceAddress = NULL;
    iUserId = NULL;
    }



// -----------------------------------------------------------------------------
// CPEngSessionSlotId::SetServiceAddressL()
// Mutator
// -----------------------------------------------------------------------------
//
EXPORT_C void CPEngSessionSlotId::SetServiceAddressL( const TDesC& aAddress )
    {
    DoSetDescriptorL( iServiceAddress, aAddress );
    }


// -----------------------------------------------------------------------------
// CPEngSessionSlotId::SetUserIdL()
// Mutator
// -----------------------------------------------------------------------------
//
EXPORT_C void CPEngSessionSlotId::SetUserIdL( const TDesC& aUserId )
    {
    DoSetDescriptorL( iUserId, aUserId );
    }

// -----------------------------------------------------------------------------
// CPEngSessionSlotId::ServiceAddress()
// Accessor
// -----------------------------------------------------------------------------
//
EXPORT_C TPtrC CPEngSessionSlotId::ServiceAddress() const
    {
    return DoGetDescriptor( iServiceAddress );
    }

// -----------------------------------------------------------------------------
// CPEngSessionSlotId::UserId()
// Accessor
// -----------------------------------------------------------------------------
//
EXPORT_C TPtrC CPEngSessionSlotId::UserId() const
    {
    return DoGetDescriptor( iUserId );
    }


// -----------------------------------------------------------------------------
// CPEngSessionSlotId::Match()
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CPEngSessionSlotId::Match( const CPEngSessionSlotId& aIdToMatch ) const
    {
    //Use ServiceAddress() and UserId() accessors to avoid NULL pointer problems
    if ( aIdToMatch.ServiceAddress().Compare( ServiceAddress() ) != KErrNone )
        {
        return KErrNotFound;
        }

    if ( aIdToMatch.UserId().Compare( UserId() ) != KErrNone )
        {
        return KErrNotFound;
        }

    return KErrNone;
    }


// -----------------------------------------------------------------------------
// CPEngSessionSlotId::PackLC()
// -----------------------------------------------------------------------------
//
EXPORT_C HBufC8* CPEngSessionSlotId::PackLC() const
    {
    HBufC8* packBuffer = HBufC8::NewLC( Size() );
    TPtr8 pack( packBuffer->Des() );

    RDesWriteStream ws;
    ws.Open( pack );                        // CSI: 65 #
    CleanupClosePushL( ws );

    ExternalizeL( ws );

    ws.CommitL();
    CleanupStack::PopAndDestroy(); //ws


    packBuffer = packBuffer->ReAllocL( packBuffer->Length() );
    CleanupStack::Pop();
    CleanupStack::PushL( packBuffer ); //Due realloc

    return packBuffer;
    }

// -----------------------------------------------------------------------------
// CPEngSessionSlotId::UnPackFullL()
// -----------------------------------------------------------------------------
//
EXPORT_C void CPEngSessionSlotId::UnPackL( const TDesC8& aPack )
    {
    RDesReadStream rs;
    rs.Open( aPack );                       // CSI: 65 #
    CleanupClosePushL( rs );

    InternalizeL( rs );

    CleanupStack::PopAndDestroy(); //rs
    }



// -----------------------------------------------------------------------------
// CPEngSessionSlotId::ExternalizeL()
// -----------------------------------------------------------------------------
//
EXPORT_C void CPEngSessionSlotId::ExternalizeL( RWriteStream& aStream ) const
    {
    ExternalizeBufferL( iServiceAddress, aStream );
    ExternalizeBufferL( iUserId, aStream );
    }


// -----------------------------------------------------------------------------
// CPEngSessionSlotId::InternalizeL()
// -----------------------------------------------------------------------------
//
EXPORT_C void CPEngSessionSlotId::InternalizeL( RReadStream& aStream )
    {
    delete iServiceAddress;
    iServiceAddress = NULL;
    iServiceAddress = InternalizeBufferL( aStream );


    delete iUserId;
    iUserId = NULL;
    iUserId = InternalizeBufferL( aStream );
    }


// -----------------------------------------------------------------------------
// CPEngSessionSlotId::Size()
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CPEngSessionSlotId::Size() const
    {
    TInt size = BufferExternalizeSizeInBytes( iServiceAddress );
    size += BufferExternalizeSizeInBytes( iUserId );
    return size;
    }


// End of File