// 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"

// Class constants.

__FLOG_STMT(_LIT8(KComponent,"Framework");)

/**

Constructor.

*/

EXPORT_C RMTPFramework::RMTPFramework() :

    iSingletons(NULL)

    {

    }

/**

Opens the singletons reference.

*/

EXPORT_C void RMTPFramework::OpenL()

    {

    __FLOG_OPEN(KMTPSubsystem, KComponent);

    __FLOG(_L8("OpenL - Entry"));

    iSingletons = &CSingletons::OpenL();

    iNested     = iSingletons->iConstructing;

    __FLOG(_L8("OpenL - Exit"));

    }

/**

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

cleanup stack.

*/

EXPORT_C void RMTPFramework::OpenLC()

    {

    __FLOG_OPEN(KMTPSubsystem, KComponent);

    __FLOG(_L8("OpenLC - Entry"));

    ::CleanupClosePushL(*this);

    OpenL();

    __FLOG(_L8("OpenLC - Exit"));

    }

/**

Closes the singletons reference.

*/

EXPORT_C void RMTPFramework::Close()

    {

    __FLOG(_L8("Close - Entry"));

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

        {

        iSingletons->Close();

        iSingletons = NULL;

        }

    __FLOG(_L8("Close - Exit"));

    __FLOG_CLOSE;

    }

EXPORT_C CMTPConnectionMgr& RMTPFramework::ConnectionMgr() const

    {

    __FLOG(_L8("ConnectionMgr - Entry"));

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

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

    __FLOG(_L8("ConnectionMgr - Exit"));

    return *(iSingletons->iSingletonConnectionMgr);

    }

EXPORT_C CMTPDataProviderController& RMTPFramework::DpController() const

    {

    __FLOG(_L8("DpController - Entry"));

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

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

    __FLOG(_L8("DpController - Exit"));

    return *(iSingletons->iSingletonDpController);

    }

EXPORT_C CMTPFrameworkConfig& RMTPFramework::FrameworkConfig() const

    {

    __FLOG(_L8("FrameworkConfig - Entry"));

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

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

    __FLOG(_L8("FrameworkConfig - Exit"));

    return *(iSingletons->iSingletonFrameworkConfig);

    }

EXPORT_C RFs& RMTPFramework::Fs() const

    {

    __FLOG(_L8("Fs - Entry"));

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

    __FLOG(_L8("Fs - Exit"));

    return iSingletons->iSingletonFs;

    }

EXPORT_C CMTPObjectMgr& RMTPFramework::ObjectMgr() const

    {

    __FLOG(_L8("ObjectMgr - Entry"));

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

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

    __FLOG(_L8("ObjectMgr - Exit"));

    return *(iSingletons->iSingletonObjectMgr);

    }

EXPORT_C CMTPReferenceMgr& RMTPFramework::ReferenceMgr() const

    {

    __FLOG(_L8("ReferenceMgr - Entry"));

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

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

    __FLOG(_L8("ReferenceMgr - Exit"));

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

    }

EXPORT_C CMTPParserRouter& RMTPFramework::Router() const

    {

    __FLOG(_L8("Router - Entry"));

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

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

    __FLOG(_L8("Router - Exit"));

    return *(iSingletons->iSingletonRouter);

    }

EXPORT_C CMTPStorageMgr& RMTPFramework::StorageMgr() const

    {

    __FLOG(_L8("StorageMgr - Entry"));

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

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

    __FLOG(_L8("StorageMgr - Exit"));

    return *(iSingletons->iSingletonStorageMgr);

    }

EXPORT_C CMTPDataCodeGenerator& RMTPFramework::DataCodeGenerator() const

    {

    __FLOG(_L8("DataCodeGenerator - Entry"));

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

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

    __FLOG(_L8("DataCodeGenerator - Exit"));

    return *(iSingletons->iSingleDataCodeGenerator);

    }

EXPORT_C CMTPServiceMgr& RMTPFramework::ServiceMgr() const

    {

    __FLOG(_L8("ServiceMgr - Entry"));

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

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

   __FLOG(_L8("ServiceMgr - Exit"));

   return *(iSingletons->iSingleServiceMgr);

    }

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

    {

    __FLOG_STATIC(KMTPSubsystem, KComponent, _L8("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();

        }

    __FLOG_STATIC(KMTPSubsystem, KComponent, _L8("CSingletons::OpenL - Exit"));

    return *self;

    }

void RMTPFramework::CSingletons::Close()

    {

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

    if (self)

        {

        __FLOG(_L8("CSingletons::Close - Entry"));

        self->Dec();

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

            {

            __FLOG(_L8("CSingletons::Close - Exit"));

            delete self;

            Dll::SetTls(NULL);

            }

        else

            {

            __FLOG(_L8("CSingletons::Close - Exit"));

            }

        }

    }

RMTPFramework::CSingletons::~CSingletons()

    {

    __FLOG(_L8("CSingletons::~CSingletons - Entry"));

    delete iSingletonStorageMgr;

    delete iSingletonRouter;

    delete iSingletonDpController;

    delete iSingletonObjectMgr;

    delete iSingletonFrameworkConfig;

    delete iSingletonConnectionMgr;

    delete iSingleDataCodeGenerator;

    delete iSingleServiceMgr;

    iSingletonFs.Close();

    __FLOG(_L8("CSingletons::~CSingletons - Exit"));

    __FLOG_CLOSE;

    }

void RMTPFramework::CSingletons::ConstructL()

    {

    __FLOG_OPEN(KMTPSubsystem, KComponent);

    __FLOG(_L8("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;

    __FLOG(_L8("CSingletons::ConstructL - Exit"));

    }