/*
* Copyright (c) 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 <memspy/engine/memspyengineobjectthreadinfocontainer.h>

// System includes
#include <e32svr.h>

// User includes
#include <memspy/engine/memspyengine.h>
#include <memspy/engine/memspyengineoutputsink.h>
#include <memspy/engine/memspyengineobjectprocess.h>
#include <memspy/engine/memspyengineobjectthread.h>
#include <memspy/engine/memspyengineobjectthreadinfoobjects.h>



CMemSpyThreadInfoContainer::CMemSpyThreadInfoContainer( CMemSpyThread& aThread )
:   CMemSpyEngineObject( aThread ), iThread( &aThread )
    {
    }


CMemSpyThreadInfoContainer::~CMemSpyThreadInfoContainer()
    {
    CloseAllInfoItems();
    //
    iItems.Close();
    iObservers.Close();
    }


void CMemSpyThreadInfoContainer::ConstructItemByTypeL( TBool aAsync, TMemSpyThreadInfoItemType aType )
    {
    CMemSpyThreadInfoItemBase* item = NULL;
    //
    switch( aType )
        {
    case EMemSpyThreadInfoItemTypeGeneralInfo:
        item = CMemSpyThreadInfoGeneral::NewLC( *this, aAsync );
        break;
    case EMemSpyThreadInfoItemTypeHeap:
        item = CMemSpyThreadInfoHeap::NewLC( *this, aAsync );
        break;
    case EMemSpyThreadInfoItemTypeStack:
        item = CMemSpyThreadInfoStack::NewLC( *this, aAsync );
        break;
    case EMemSpyThreadInfoItemTypeChunk:
        item = CMemSpyThreadInfoChunk::NewLC( *this, aAsync );
        break;
    case EMemSpyThreadInfoItemTypeCodeSeg:
        item = CMemSpyThreadInfoCodeSeg::NewLC( *this, aAsync );
        break;
    case EMemSpyThreadInfoItemTypeOpenFiles:
        item = CMemSpyThreadInfoOpenFiles::NewLC( *this, aAsync );
        break;
    case EMemSpyThreadInfoItemTypeActiveObject:
        item = CMemSpyThreadInfoActiveObjects::NewLC( *this, aAsync );
        break;
    case EMemSpyThreadInfoItemTypeServer:
        item = CMemSpyThreadInfoServer::NewLC( *this, aAsync );
        break;
    case EMemSpyThreadInfoItemTypeSession:
        item = CMemSpyThreadInfoSession::NewLC( *this, aAsync );
        break;
    case EMemSpyThreadInfoItemTypeSemaphore:
        item = CMemSpyThreadInfoSemaphore::NewLC( *this, aAsync );
        break;
    case EMemSpyThreadInfoItemTypeMutex:
        item = CMemSpyThreadInfoMutex::NewLC( *this, aAsync );
        break;
    case EMemSpyThreadInfoItemTypeTimer:
        item = CMemSpyThreadInfoTimer::NewLC( *this, aAsync );
        break;
    case EMemSpyThreadInfoItemTypeLDD:
        item = CMemSpyThreadInfoLDD::NewLC( *this, aAsync );
        break;
    case EMemSpyThreadInfoItemTypePDD:
        item = CMemSpyThreadInfoPDD::NewLC( *this, aAsync );
        break;
    case EMemSpyThreadInfoItemTypeLogicalChannel:
        item = CMemSpyThreadInfoLogicalChannel::NewLC( *this, aAsync );
        break;
    case EMemSpyThreadInfoItemTypeChangeNotifier:
        item = CMemSpyThreadInfoChangeNotifier::NewLC( *this, aAsync );
        break;
    case EMemSpyThreadInfoItemTypeUndertaker:
        item = CMemSpyThreadInfoUndertaker::NewLC( *this, aAsync );
        break;
    case EMemSpyThreadInfoItemTypeOwnedThreadHandles:
        item = CMemSpyThreadInfoOwnedThreadHandles::NewLC( *this, aAsync );
        break;
    case EMemSpyThreadInfoItemTypeOwnedProcessHandles:
        item = CMemSpyThreadInfoOwnedProcessHandles::NewLC( *this, aAsync );
        break;
    case EMemSpyThreadInfoItemTypeOtherThreads:
        item = CMemSpyThreadInfoOtherThreads::NewLC( *this, aAsync );
        break;
    case EMemSpyThreadInfoItemTypeOtherProcesses:
        item = CMemSpyThreadInfoOtherProcesses::NewLC( *this, aAsync );
        break;
    case EMemSpyThreadInfoItemTypeMemoryTracking:
        item = CMemSpyThreadInfoMemoryTracking::NewLC( *this, aAsync );
        break;
    default:
    case EMemSpyThreadInfoItemTypeMessageQueue:
    case EMemSpyThreadInfoItemTypeConditionalVariable:
        break;
        }
    //
    if  ( item )
        {
        iItems.AppendL( item );
        CleanupStack::Pop( item );
        }
    }


void CMemSpyThreadInfoContainer::ConstructL( TBool aAsync )
    {
    for( TInt type = EMemSpyThreadInfoItemTypeFirst; type<EMemSpyThreadInfoItemTypeLast; type++ )
        {
        const TMemSpyThreadInfoItemType realType = static_cast< TMemSpyThreadInfoItemType >( type );
        ConstructItemByTypeL( aAsync, realType );
        }
    }


CMemSpyThreadInfoContainer* CMemSpyThreadInfoContainer::NewL( CMemSpyThread& aThread, TBool aAsync )
    {
    CMemSpyThreadInfoContainer* self = CMemSpyThreadInfoContainer::NewLC( aThread, aAsync );
    CleanupStack::Pop( self );
    return self;
    }


CMemSpyThreadInfoContainer* CMemSpyThreadInfoContainer::NewLC( CMemSpyThread& aThread, TBool aAsync )
    {
    CMemSpyThreadInfoContainer* self = new(ELeave) CMemSpyThreadInfoContainer( aThread );
    CleanupStack::PushL( self );
    self->ConstructL( aAsync );
    return self;
    }


CMemSpyThreadInfoContainer* CMemSpyThreadInfoContainer::NewLC( CMemSpyThread& aThread, TMemSpyThreadInfoItemType aSpecificType )
    {
    CMemSpyThreadInfoContainer* self = new(ELeave) CMemSpyThreadInfoContainer( aThread );
    CleanupStack::PushL( self );
    self->ConstructItemByTypeL( EFalse, aSpecificType );
    return self;
    }


void CMemSpyThreadInfoContainer::AddItemL( TMemSpyThreadInfoItemType aType )
    {
    const TInt index = InfoItemIndexByType( aType );
    if  ( index == KErrNotFound )
        {
        ConstructItemByTypeL( EFalse, aType );
        }
    }


EXPORT_C void CMemSpyThreadInfoContainer::Open()
    {
    if  ( !OpenOrCloseInProgress() )
        {
        SetOpenOrCloseInProgress( ETrue );
        CMemSpyEngineObject::Open();
        SetOpenOrCloseInProgress( EFalse );
        }
    }


EXPORT_C void CMemSpyThreadInfoContainer::Close()
    {
    if  ( !OpenOrCloseInProgress() )
        {
        SetOpenOrCloseInProgress( ETrue );
        CMemSpyEngineObject::Close();
        SetOpenOrCloseInProgress( EFalse );
        }
    }


EXPORT_C void CMemSpyThreadInfoContainer::PrintL()
    {
    _LIT( KMemSpyFolder, "ThreadInfo" );
    _LIT( KMemSpyContext, "ThreadInfo - %S" );
    //
    CMemSpyEngine& engine = Engine();
    CMemSpyEngineOutputSink& sink = engine.Sink();
    //
    TFullName fullName( iThread->FullName() );
    HBufC* context = HBufC::NewLC( KMaxFileName * 2 );
    TPtr pContext( context->Des() );
    pContext.Format( KMemSpyContext, &fullName );
    sink.DataStreamBeginL( pContext, KMemSpyFolder );
    CleanupStack::PopAndDestroy( context );
    //
    sink.OutputSectionHeadingL( fullName, TChar('=') );
    sink.OutputBlankLineL();
    //
    const TInt count = iItems.Count();
    for( TInt i=0; i<count; i++ )
        {
        CMemSpyThreadInfoItemBase* item = iItems[ i ];
        item->PrintL();
        }
    //
    sink.OutputBlankLineL();
    sink.DataStreamEndL();
    }


EXPORT_C TInt CMemSpyThreadInfoContainer::MdcaCount() const
    {
    return iItems.Count();
    }


EXPORT_C TPtrC CMemSpyThreadInfoContainer::MdcaPoint( TInt aIndex ) const
    {
    return iItems[ aIndex ]->Name();
    }


EXPORT_C CMemSpyEngine& CMemSpyThreadInfoContainer::Engine() const
    {
    return iThread->Engine();
    }


EXPORT_C CMemSpyThreadInfoItemBase& CMemSpyThreadInfoContainer::Item( TInt aIndex )
    {
    return *iItems[ aIndex ];
    }


EXPORT_C CMemSpyThreadInfoItemBase& CMemSpyThreadInfoContainer::Item( TMemSpyThreadInfoItemType aType )
    {
    const TInt index = InfoItemIndexByType( aType );
    CMemSpyThreadInfoItemBase* ret = iItems[ index ];
    __ASSERT_ALWAYS( ret != NULL, User::Invariant() );
    return *ret;
    }


EXPORT_C TInt CMemSpyThreadInfoContainer::InfoItemIndexByType( TMemSpyThreadInfoItemType aType )
    {
    TInt index = KErrNotFound;
    //
    const TInt count = iItems.Count();
    for(TInt i=0; i<count; i++)
        {
        CMemSpyThreadInfoItemBase* item = iItems[ i ];
        if  ( item->Type() == aType )
            {
            index = i;
            break;
            }
        }
    //
    return index;
    }


EXPORT_C void CMemSpyThreadInfoContainer::ObserverAddL( MMemSpyThreadInfoContainerObserver& aObserver )
    {
    const TInt count = iObservers.Count();
    for(TInt i=count-1; i>=0; i--)
        {
        MMemSpyThreadInfoContainerObserver* observer = iObservers[ i ];
        if  ( observer == &aObserver )
            {
            return;
            }
        }

    iObservers.AppendL( &aObserver );
    }


EXPORT_C void CMemSpyThreadInfoContainer::ObserverRemove( MMemSpyThreadInfoContainerObserver& aObserver )
    {
    const TInt count = iObservers.Count();
    for(TInt i=count-1; i>=0; i--)
        {
        MMemSpyThreadInfoContainerObserver* observer = iObservers[ i ];
        if  ( observer == &aObserver )
            {
            iObservers.Remove( i );
            break;
            }
        }
    }


void CMemSpyThreadInfoContainer::NotifyObserverL( MMemSpyThreadInfoContainerObserver::TEvent aEvent, TMemSpyThreadInfoItemType aType )
    {
    if  ( aEvent == MMemSpyThreadInfoContainerObserver::EInfoItemDestroyed )
        {
        // Make sure we remove dead item
        const TInt index = InfoItemIndexByType( aType );
        if  ( index >= 0 )
            {
            iItems.Remove( index );
            }
        }
        
    const TInt count = iObservers.Count();
    for(TInt i=count-1; i>=0; i--)
        {
        MMemSpyThreadInfoContainerObserver* observer = iObservers[ i ];
        observer->HandleMemSpyEngineInfoContainerEventL( aEvent, aType );
        }
    }


void CMemSpyThreadInfoContainer::OpenAllInfoItems()
    {
    const TInt count = iItems.Count();
    for(TInt i=count-1; i>=0; i--)
        {
        CMemSpyThreadInfoItemBase* item = iItems[ i ];
        item->Open();
        }
    }


void CMemSpyThreadInfoContainer::CloseAllInfoItems()
    {
    const TInt count = iItems.Count();
    for(TInt i=count-1; i>=0; i--)
        {
        CMemSpyThreadInfoItemBase* item = iItems[ i ];
        item->Close();
        }
    }