/*

* Copyright (c) 2002-2006 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:        

*

*/

// INCLUDE FILES

#include "senwsdescription.h"

#include "sentransportcontext.h"

#include "msencoreservicemanager.h"

#include "senservicesession.h"

#include "sencontextitem.h"

EXPORT_C CSenTransportContext::CSenTransportContext()

: CSenContext(SenContext::EBoth)

    {

    }

EXPORT_C CSenTransportContext::~CSenTransportContext()

    {

    }

EXPORT_C CSenTransportContext* CSenTransportContext::NewL(MSenCoreServiceManager& aCore,

                                                                 CSenWSDescription& aSessionInitializer)

    {

    CSenTransportContext* pNew = CSenTransportContext::NewLC(aCore, aSessionInitializer);

    CleanupStack::Pop();

    return pNew;

    }

EXPORT_C CSenTransportContext* CSenTransportContext::NewLC(MSenCoreServiceManager& aCore,

                                                           CSenWSDescription& aSessionInitializer)

    {

//    CSenXmlReader* reader = aCore.XMLReader();

//    if(!reader) User::Leave(KErrArgument); 

    CSenTransportContext* pNew = new (ELeave) CSenTransportContext();

    CleanupStack::PushL(pNew);

    pNew->BaseConstructL(aCore, aSessionInitializer, NULL);

    return pNew;

    }

EXPORT_C CSenTransportContext* CSenTransportContext::NewL(MSenCoreServiceManager& aCore,

                                                                 CSenWSDescription& aSessionInitializer,

                                                                 CSenServiceSession& aInvoker)

    {

    CSenTransportContext* pNew = CSenTransportContext::NewLC(aCore, aSessionInitializer, aInvoker);

    CleanupStack::Pop();

    return pNew;

    }

EXPORT_C CSenTransportContext* CSenTransportContext::NewLC(MSenCoreServiceManager& aCore,

                                                           CSenWSDescription& aSessionInitializer,

                                                           CSenServiceSession& aInvoker)

    {

    CSenTransportContext* pNew = new (ELeave) CSenTransportContext();

    CleanupStack::PushL(pNew);

    pNew->BaseConstructL(aCore, aSessionInitializer, &aInvoker);

    return pNew;

    }

EXPORT_C void CSenTransportContext::BaseConstructL(MSenCoreServiceManager& aCore,

                                                   CSenWSDescription& aSessionInitializer,

                                                   CSenServiceSession* apInvoker)

    {

    CSenContextItem* pCore = CSenContextItem::NewLC(aCore);

    User::LeaveIfError( iItems.Append( &KSenCtxKeyCoreServiceManager(), pCore ) );

    CleanupStack::Pop(pCore);

    CSenContextItem* pInit = CSenContextItem::NewLC(aSessionInitializer);

    User::LeaveIfError( iItems.Append( &KSenCtxKeySessionInitializer(), pInit ) );

    CleanupStack::Pop(pInit);

    if(apInvoker)

        {

        CSenContextItem* pSess = CSenContextItem::NewLC(*apInvoker);

        User::LeaveIfError( iItems.Append(&KSenCtxKeyServiceSession(), pSess ) );

        CleanupStack::Pop(pSess);

        }

    }

// From MSenTransportContext:

//TInt CSenTransportContext::AddCore(MSenCoreServiceManager& aValue)

//    {

//    }

MSenCoreServiceManager& CSenTransportContext::GetCoreL()

    {

    TInt index = iItems.Find( KSenCtxKeyCoreServiceManager );

    User::LeaveIfError( index );

    const CSenContextItem* pItem = iItems.ValueAt(index);

    if ( pItem == NULL ) 

        {

        User::Leave( KErrNotFound );

        }

    return pItem->ToSenCoreL();

    /*

    TInt leaveCode(KErrNone);

    MSenCoreServiceManager* pCore = NULL;

    TRAP( leaveCode, pCore = pItem->ToSenCoreL(); )

    if( leaveCode == KErrNone ) 

        {

        return pCore;

        }

    */

    }

// TInt CSenTransportContext::AddSession(CSenServiceSession* aValue) { };

// TInt CSenTransportContext::UpdateSession(CSenServiceSession* aValue) { };

//CSenServiceSession& CSenTransportContext::GetSessionL()

const CSenServiceSession* CSenTransportContext::GetSession()

    {

    CSenServiceSession* pSession = NULL;

    TInt index = iItems.Find( KSenCtxKeyServiceSession );

    if(index != KErrNotFound) 

        {

        const CSenContextItem* pItem = iItems.ValueAt(index);

        if ( pItem ) 

            {

            TInt leaveCode(KErrNone);

            TRAP( leaveCode, pSession = &(pItem->ToSenServiceSessionL()); )

            if ( leaveCode != KErrNone )

                {

                pSession = NULL;

                }

            }

        }

    return pSession;

    }

//TInt CSenTransportContext::AddInitializer(CSenWSDescription* aValue) { };

//  TInt CSenTransportContext::UpdateInitializer(CSenWSDescription* aValue);

//const CSenWSDescription* CSenTransportContext::GetInitializer()

CSenWSDescription& CSenTransportContext::GetInitializerL()

     {

    TInt index = iItems.Find( KSenCtxKeySessionInitializer );

    User::LeaveIfError( index );

    const CSenContextItem* pItem = iItems.ValueAt(index);

    if ( pItem == NULL ) 

        {

        User::Leave( KErrNotFound );

        }

    return pItem->ToSenServiceDescriptionL();

    }

// TInt CSenTransportContext::AddServiceDescription(const TDesC8& aKey, CSenWSDescription* aValue);

// TInt CSenTransportContext::UpdateServiceDescription(const TDesC8& aKey, CSenWSDescription* aValue);

// const CSenWSDescription* CSenTransportContext::GetServiceDescriptionL(const TDesC8& aKey);

// TInt CSenTransportContext::Add(const TDesC8& aKey, MSenRemoteServiceSession& aValue); // protected context

// TInt CSenTransportContext::Update(const TDesC8& aKey, MSenRemoteServiceSession& aValue);

// const MSenRemoteServiceSession* CSenTransportContext::GetSenRemoteServiceSessionL(const TDesC8& aKey);

 // From MSenContext:

SenContext::TContextType CSenTransportContext::Type() const

    {

    return SenContext::ETransportContext;

    }

SenContext::TContextDirection CSenTransportContext::Direction() const

    {

    return CSenContext::Direction();

    }

TInt CSenTransportContext::Add(const TDesC8& aKey, const TDesC8& aValue)

    {

    return CSenContext::Add(aKey, aValue);

    }

TInt CSenTransportContext::Update(const TDesC8& aKey, const TDesC8& aValue)

    {

    return CSenContext::Update(aKey, aValue);

    }

const TDesC8* CSenTransportContext::GetDesC8L(const TDesC8& aKey)

    {

    return CSenContext::GetDesC8L(aKey);

    }

TInt CSenTransportContext::Add(const TDesC8& aKey, TInt aValue)

    {

    return CSenContext::Add(aKey, aValue);

    }

TInt CSenTransportContext::Update(const TDesC8& aKey, TInt aValue)

    {

    return CSenContext::Update(aKey, aValue);

    }

const TInt* CSenTransportContext::GetIntL(const TDesC8& aKey)

    {

    return CSenContext::GetIntL(aKey);

    }

TInt CSenTransportContext::Add(const TDesC8& aKey, CSenElement* aValue)

    {

    return CSenContext::Add(aKey, aValue);

    }

TInt CSenTransportContext::Update(const TDesC8& aKey, CSenElement* aValue)

    {

    return CSenContext::Update(aKey, aValue);

    }

const CSenElement* CSenTransportContext::GetSenElementL(const TDesC8& aKey)

    {

    return CSenContext::GetSenElementL(aKey);

    }

TInt CSenTransportContext::Add(const TDesC8& aKey, TAny* aValue)

    {

    return CSenContext::Add(aKey, aValue);

    }

TInt CSenTransportContext::Update(const TDesC8& aKey, TAny* aValue)

    {

    return CSenContext::Update(aKey, aValue);

    }

TAny* CSenTransportContext::GetAnyL(const TDesC8& aKey)	//codescannerwarnings

    {

    return CSenContext::GetAnyL(aKey);	//codescannerwarnings

    }

TInt CSenTransportContext::Remove(const TDesC8& aKey) 

    {

    return CSenContext::Remove(aKey);

    }

TInt CSenTransportContext::Count() const

    {

    return CSenContext::Count();

    }

TPtrC8 CSenTransportContext::KeyAtL(TInt aIndex)

    {

    return CSenContext::KeyAtL(aIndex);

    }

void CSenTransportContext::Reset()

    {

    CSenContext::Reset();

    }

TInt CSenTransportContext::SetDirection( SenContext::TContextDirection aDirection )

    {

    return CSenContext::SetDirection( aDirection );

    }

const CSenXmlReader* CSenTransportContext::GetParser()

    {

    CSenXmlReader* reader = NULL;

    MSenCoreServiceManager* core = NULL;

    TInt leaveCode(KErrNone);

    TRAP( leaveCode, core = &GetCoreL(); )

    if( leaveCode == KErrNone && core)

        {

        TRAP( leaveCode, reader = core->XMLReader(); )

        if( leaveCode == KErrNone && reader )

            {

            return reader;

            }

        }

    return NULL;

    }

// End of File