// Copyright (c) 2006-2009 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 "cmtpconnectionmgr.h"

#include "cmtpdataprovidercontroller.h"

#include "cmtpframeworkconfig.h"

#include "cmtpobjectmgr.h"

#include "cmtpobjectstore.h"

#include "cmtpparserrouter.h"

#include "cmtpstoragemgr.h"

#include "rmtpframework.h"

#include "cmtpdatacodegenerator.h"

#include "cmtpservicemgr.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "rmtpframeworkTraces.h"

#endif

// Class constants.

/**

Constructor.

*/

EXPORT_C RMTPFramework::RMTPFramework() :

    iSingletons(NULL)

    {

    }

/**

Opens the singletons reference.

*/

EXPORT_C void RMTPFramework::OpenL()

    {

    OstTraceFunctionEntry0( RMTPFRAMEWORK_OPENL_ENTRY );

    iSingletons = &CSingletons::OpenL();

    iNested     = iSingletons->iConstructing;

    OstTraceFunctionExit0( RMTPFRAMEWORK_OPENL_EXIT );

    }

/**

Opens the singletons reference. The singletons reference is pushed onto the

cleanup stack.

*/

EXPORT_C void RMTPFramework::OpenLC()

    {

    OstTraceFunctionEntry0( RMTPFRAMEWORK_OPENLC_ENTRY );

    ::CleanupClosePushL(*this);

    OpenL();

    OstTraceFunctionExit0( RMTPFRAMEWORK_OPENLC_EXIT );

    }

/**

Closes the singletons reference.

*/

EXPORT_C void RMTPFramework::Close()

    {

    OstTraceFunctionEntry0( RMTPFRAMEWORK_CLOSE_ENTRY );

    if ((iSingletons) && (!iNested))

        {

        iSingletons->Close();

        iSingletons = NULL;

        }

    OstTraceFunctionExit0( RMTPFRAMEWORK_CLOSE_EXIT );

    }

EXPORT_C CMTPConnectionMgr& RMTPFramework::ConnectionMgr() const

    {

    OstTraceFunctionEntry0( RMTPFRAMEWORK_CONNECTIONMGR_ENTRY );

    __ASSERT_DEBUG(iSingletons, User::Invariant());

    __ASSERT_DEBUG(iSingletons->iSingletonConnectionMgr, User::Invariant());

    OstTraceFunctionExit0( RMTPFRAMEWORK_CONNECTIONMGR_EXIT );

    return *(iSingletons->iSingletonConnectionMgr);

    }

EXPORT_C CMTPDataProviderController& RMTPFramework::DpController() const

    {

    OstTraceFunctionEntry0( RMTPFRAMEWORK_DPCONTROLLER_ENTRY );

    __ASSERT_DEBUG(iSingletons, User::Invariant());

    __ASSERT_DEBUG(iSingletons->iSingletonDpController, User::Invariant());

    OstTraceFunctionExit0( RMTPFRAMEWORK_DPCONTROLLER_EXIT );

    return *(iSingletons->iSingletonDpController);

    }

EXPORT_C CMTPFrameworkConfig& RMTPFramework::FrameworkConfig() const

    {

    OstTraceFunctionEntry0( RMTPFRAMEWORK_FRAMEWORKCONFIG_ENTRY );

    __ASSERT_DEBUG(iSingletons, User::Invariant());

    __ASSERT_DEBUG(iSingletons->iSingletonFrameworkConfig, User::Invariant());

    OstTraceFunctionExit0( RMTPFRAMEWORK_FRAMEWORKCONFIG_EXIT );

    return *(iSingletons->iSingletonFrameworkConfig);

    }

EXPORT_C RFs& RMTPFramework::Fs() const

    {

    OstTraceFunctionEntry0( RMTPFRAMEWORK_FS_ENTRY );

    __ASSERT_DEBUG(iSingletons, User::Invariant());

    OstTraceFunctionExit0( RMTPFRAMEWORK_FS_EXIT );

    return iSingletons->iSingletonFs;

    }

EXPORT_C CMTPObjectMgr& RMTPFramework::ObjectMgr() const

    {

    OstTraceFunctionEntry0( RMTPFRAMEWORK_OBJECTMGR_ENTRY );

    __ASSERT_DEBUG(iSingletons, User::Invariant());

    __ASSERT_DEBUG(iSingletons->iSingletonObjectMgr, User::Invariant());

    OstTraceFunctionExit0( RMTPFRAMEWORK_OBJECTMGR_EXIT );

    return *(iSingletons->iSingletonObjectMgr);

    }

EXPORT_C CMTPReferenceMgr& RMTPFramework::ReferenceMgr() const

    {

    OstTraceFunctionEntry0( RMTPFRAMEWORK_REFERENCEMGR_ENTRY );

    __ASSERT_DEBUG(iSingletons, User::Invariant());

    __ASSERT_DEBUG(iSingletons->iSingletonRouter, User::Invariant());

    OstTraceFunctionExit0( RMTPFRAMEWORK_REFERENCEMGR_EXIT );

    return (iSingletons->iSingletonObjectMgr->ObjectStore().ReferenceMgr());

    }

EXPORT_C CMTPParserRouter& RMTPFramework::Router() const

    {

    OstTraceFunctionEntry0( RMTPFRAMEWORK_ROUTER_ENTRY );

    __ASSERT_DEBUG(iSingletons, User::Invariant());

    __ASSERT_DEBUG(iSingletons->iSingletonRouter, User::Invariant());

    OstTraceFunctionExit0( RMTPFRAMEWORK_ROUTER_EXIT );

    return *(iSingletons->iSingletonRouter);

    }

EXPORT_C CMTPStorageMgr& RMTPFramework::StorageMgr() const

    {

    OstTraceFunctionEntry0( RMTPFRAMEWORK_STORAGEMGR_ENTRY );

    __ASSERT_DEBUG(iSingletons, User::Invariant());

    __ASSERT_DEBUG(iSingletons->iSingletonStorageMgr, User::Invariant());

    OstTraceFunctionExit0( RMTPFRAMEWORK_STORAGEMGR_EXIT );

    return *(iSingletons->iSingletonStorageMgr);

    }

EXPORT_C CMTPDataCodeGenerator& RMTPFramework::DataCodeGenerator() const

    {

    OstTraceFunctionEntry0( RMTPFRAMEWORK_DATACODEGENERATOR_ENTRY );

    __ASSERT_DEBUG(iSingletons, User::Invariant());

    __ASSERT_DEBUG(iSingletons->iSingleDataCodeGenerator, User::Invariant());

    OstTraceFunctionExit0( RMTPFRAMEWORK_DATACODEGENERATOR_EXIT );

    return *(iSingletons->iSingleDataCodeGenerator);

    }

EXPORT_C CMTPServiceMgr& RMTPFramework::ServiceMgr() const

    {

    OstTraceFunctionEntry0( RMTPFRAMEWORK_SERVICEMGR_ENTRY );

   __ASSERT_DEBUG(iSingletons, User::Invariant());

   __ASSERT_DEBUG(iSingletons->iSingleServiceMgr, User::Invariant());

   OstTraceFunctionExit0( RMTPFRAMEWORK_SERVICEMGR_EXIT );

   return *(iSingletons->iSingleServiceMgr);

    }

RMTPFramework::CSingletons& RMTPFramework::CSingletons::OpenL()

    {

    OstTraceFunctionEntry0( CSINGLETONS_OPENL_ENTRY );

    CSingletons* self(reinterpret_cast<CSingletons*>(Dll::Tls()));

    if (!self)

        {

        self = new(ELeave) CSingletons();

        Dll::SetTls(reinterpret_cast<TAny*>(self));

        self->ConstructL();

        }

    else if (!self->iConstructing)

        {        

        self->Inc();

        }

    OstTraceFunctionExit0( CSINGLETONS_OPENL_EXIT );

    return *self;

    }

void RMTPFramework::CSingletons::Close()

    {   

    CSingletons* self(reinterpret_cast<CSingletons*>(Dll::Tls()));

    if (self)

        {

        OstTraceFunctionEntry0( CSINGLETONS_CLOSE_ENTRY );

        self->Dec();

        if (self->AccessCount() == 0)

            {

            OstTraceFunctionExit0( CSINGLETONS_CLOSE_EXIT );

            delete self;

            Dll::SetTls(NULL);

            }

        else

            {

            OstTraceFunctionExit0( DUP1_CSINGLETONS_CLOSE_EXIT );

            }

        }

    }

RMTPFramework::CSingletons::~CSingletons()

    {

    OstTraceFunctionEntry0( RMTPFRAMEWORK_CSINGLETONS_CSINGLETONS_DES_ENTRY );

    delete iSingletonStorageMgr;

    delete iSingletonRouter;

    delete iSingletonDpController;

    delete iSingletonObjectMgr;

    delete iSingletonFrameworkConfig;

    delete iSingletonConnectionMgr;

    delete iSingleDataCodeGenerator;

    delete iSingleServiceMgr;

    iSingletonFs.Close();

    OstTraceFunctionExit0( RMTPFRAMEWORK_CSINGLETONS_CSINGLETONS_DES_EXIT );

    }

void RMTPFramework::CSingletons::ConstructL()

    {

    OstTraceFunctionEntry0( CSINGLETONS_CONSTRUCTL_ENTRY );

    iConstructing = ETrue;

	User::LeaveIfError(iSingletonFs.Connect());

    iSingletonFrameworkConfig   = CMTPFrameworkConfig::NewL();

    iSingletonConnectionMgr     = CMTPConnectionMgr::NewL();

    iSingletonObjectMgr         = CMTPObjectMgr::NewL();

    iSingletonDpController      = CMTPDataProviderController::NewL();

    iSingletonRouter            = CMTPParserRouter::NewL();

    iSingletonStorageMgr        = CMTPStorageMgr::NewL();

    iSingleDataCodeGenerator    = CMTPDataCodeGenerator::NewL();

    iSingleServiceMgr           = CMTPServiceMgr::NewL();

    iConstructing = EFalse;

    OstTraceFunctionExit0( CSINGLETONS_CONSTRUCTL_EXIT );

    }