/*

* 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/memspyenginehelperkernelcontainers.h>

// User includes

#include <memspy/engine/memspyengine.h>

#include <memspy/engine/memspyengineutils.h>

#include <memspy/engine/memspyengineoutputsink.h>

#include <memspy/engine/memspyengineobjectthread.h>

#include <memspy/engine/memspyengineobjectprocess.h>

#include <memspy/engine/memspyengineobjectcontainer.h>

// Driver includes

#include <memspy/driver/memspydriverclient.h>

#include <memspy/driver/memspydriverconstants.h>

#include <memspy/driver/memspydriverenumerationsshared.h>

// Constants

const TInt KMaxGenericHandleCount = 1024 * 2;

_LIT( KMemSpyMarkerKernelContainer, "<%SMEMSPY_KERNEL_CONTAINER_%02d>" );

_LIT( KMemSpyMarkerKernelContainersAll, "<%SMEMSPY_KERNEL_CONTAINERS>" );

CMemSpyEngineHelperKernelContainers::CMemSpyEngineHelperKernelContainers( CMemSpyEngine& aEngine )

:   iEngine( aEngine )

    {

    }

CMemSpyEngineHelperKernelContainers::~CMemSpyEngineHelperKernelContainers()

    {

    }

void CMemSpyEngineHelperKernelContainers::ConstructL()

    {

    }

CMemSpyEngineHelperKernelContainers* CMemSpyEngineHelperKernelContainers::NewL( CMemSpyEngine& aEngine )

    {

    CMemSpyEngineHelperKernelContainers* self = new(ELeave) CMemSpyEngineHelperKernelContainers( aEngine );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

EXPORT_C CMemSpyEngineGenericKernelObjectList* CMemSpyEngineHelperKernelContainers::ObjectsForSpecificContainerL( TMemSpyDriverContainerType aForContainer )

    {

    CMemSpyEngineGenericKernelObjectList* list = CMemSpyEngineGenericKernelObjectList::NewLC( aForContainer, iEngine );

    AddObjectsFromContainerL( *list, aForContainer );

    CleanupStack::Pop( list );

    return list;

    }

EXPORT_C CMemSpyEngineGenericKernelObjectContainer* CMemSpyEngineHelperKernelContainers::ObjectsAllL()

    {

    CMemSpyEngineGenericKernelObjectContainer* container = CMemSpyEngineGenericKernelObjectContainer::NewLC();

    //

    for( TInt i=EMemSpyDriverContainerTypeFirst; i<=EMemSpyDriverContainerTypeLast; i++ )

        {

        const TMemSpyDriverContainerType type = static_cast< TMemSpyDriverContainerType >( i );

        //

        CMemSpyEngineGenericKernelObjectList* list = CMemSpyEngineGenericKernelObjectList::NewLC( type, iEngine );

        AddObjectsFromContainerL( *list, type );

        container->AddListL( list );

        CleanupStack::Pop( list );

        }

    //

    CleanupStack::Pop( container );

    return container;

    }

CMemSpyEngineGenericKernelObjectContainer* CMemSpyEngineHelperKernelContainers::ObjectsAllLightweightL()

    {

    CMemSpyEngineGenericKernelObjectContainer* container = CMemSpyEngineGenericKernelObjectContainer::NewLC();

    //

    for( TInt i=EMemSpyDriverContainerTypeFirst; i<=EMemSpyDriverContainerTypeLast; i++ )

        {

        const TMemSpyDriverContainerType type = static_cast< TMemSpyDriverContainerType >( i );

        //

        CMemSpyEngineGenericKernelObjectList* list = CMemSpyEngineGenericKernelObjectList::NewLC( type, iEngine );

        AddObjectsFromContainerL( *list, type, EFalse );

        container->AddListL( list );

        CleanupStack::Pop( list );

        }

    //

    CleanupStack::Pop( container );

    return container;

    }

TMemSpyDriverContainerType CMemSpyEngineHelperKernelContainers::MapToType( TObjectType aType )

    {

    TMemSpyDriverContainerType ret = EMemSpyDriverContainerTypeUnknown;

    //

    if ( aType >= EMemSpyDriverContainerTypeFirst && aType <= EMemSpyDriverContainerTypeLast )

        {

        ret = (TMemSpyDriverContainerType) aType;

        }

    //

    return ret;

    }

EXPORT_C void CMemSpyEngineHelperKernelContainers::OutputL( const CMemSpyEngineGenericKernelObjectContainer& aContainer ) const

    {

    aContainer.OutputL( iEngine.Sink() );

    }

CMemSpyEngine& CMemSpyEngineHelperKernelContainers::Engine() const

    {

    return iEngine;

    }

void CMemSpyEngineHelperKernelContainers::AddObjectsFromContainerL( CMemSpyEngineGenericKernelObjectList& aList, TMemSpyDriverContainerType aContainer, TBool aGetInfo )

    {

	TAny* handles[KMaxGenericHandleCount];

	TInt c = KMaxGenericHandleCount;

	TInt r = iEngine.Driver().GetContainerHandles( aContainer, handles, c );

	if  ( r == KErrNone )

    	{

        if  ( c > 0 )

            {

        	if (c > KMaxGenericHandleCount)

        		{

        		c = KMaxGenericHandleCount;

        		}

        	TMemSpyDriverHandleInfoGeneric info;

        	for (TInt i=0; i<c && r == KErrNone; i++)

        		{

                if  ( aGetInfo )

                    {

        		    r = iEngine.Driver().GetGenericHandleInfo( KMemSpyDriverEnumerateContainerHandles, aContainer, handles[i], info );

        		    if  ( r == KErrNone )

        			    {

        			    aList.AddItemL( info );

        			    }

                    }

                else

                    {

                    aList.AddItemL( handles[ i ] );

                    }

        		}

            }

        }

    }

CMemSpyEngineGenericKernelObjectList::CMemSpyEngineGenericKernelObjectList( TMemSpyDriverContainerType aType )

:   iType( aType ), iItems( 25 ), iHandles( 25 )

    {

    }

EXPORT_C CMemSpyEngineGenericKernelObjectList::~CMemSpyEngineGenericKernelObjectList()

    {

    delete iName;

    iHandles.Close();

    iItems.Close();

    }

void CMemSpyEngineGenericKernelObjectList::ConstructL( CMemSpyEngine& aEngine )

    {

    iName = HBufC::NewL( KMaxFullName );

    iSize = aEngine.Driver().GetApproximateKernelObjectSize( iType );

    UpdateNameL();

    }

CMemSpyEngineGenericKernelObjectList* CMemSpyEngineGenericKernelObjectList::NewLC( TMemSpyDriverContainerType aType, CMemSpyEngine& aEngine )

    {

    CMemSpyEngineGenericKernelObjectList* self = new(ELeave) CMemSpyEngineGenericKernelObjectList( aType );

    CleanupStack::PushL( self );

    self->ConstructL( aEngine );

    return self;

    }

EXPORT_C TInt CMemSpyEngineGenericKernelObjectList::Count() const

    {

    return iHandles.Count();

    }

EXPORT_C const TMemSpyDriverHandleInfoGeneric& CMemSpyEngineGenericKernelObjectList::At( TInt aIndex ) const

    {

    return iItems[ aIndex ];

    }

EXPORT_C TMemSpyDriverContainerType CMemSpyEngineGenericKernelObjectList::Type() const

    {

    return iType;

    }

EXPORT_C TPtrC CMemSpyEngineGenericKernelObjectList::TypeAsString( TMemSpyDriverContainerType aType )

    {

    _LIT( KTypeUnknown, "Unknown Type" );

    _LIT( KTypeThread, "Thread" );

    _LIT( KTypeProcess, "Process" );

    _LIT( KTypeChunk, "Chunk" );

    _LIT( KTypeLibrary, "Library" );

    _LIT( KTypeSemaphore, "Semaphore" );

    _LIT( KTypeMutex, "Mutex" );

    _LIT( KTypeTimer, "Timer" );

    _LIT( KTypeServer, "Server" );

    _LIT( KTypeSession, "Session" );

    _LIT( KTypeLogicalDevice, "Logical Device" );

    _LIT( KTypePhysicalDevice, "Physical Device" );

    _LIT( KTypeLogicalChannel, "Logical Channel" );

    _LIT( KTypeChangeNotifier, "Change Notifier" );

    _LIT( KTypeUndertaker, "Undertaker" );

    _LIT( KTypeMsgQueue, "Msg. Queue" );

    _LIT( KTypePropertyRef, "Property Ref." );

    _LIT( KTypeCondVar, "Conditional Var." );

     //

    TPtrC pType( KTypeUnknown );

    //

    switch( aType )

        {

    case EMemSpyDriverContainerTypeThread:

        pType.Set( KTypeThread );

        break;

    case EMemSpyDriverContainerTypeProcess:

        pType.Set( KTypeProcess );

        break;

    case EMemSpyDriverContainerTypeChunk:

        pType.Set( KTypeChunk );

        break;

    case EMemSpyDriverContainerTypeLibrary:

        pType.Set( KTypeLibrary );

        break;

    case EMemSpyDriverContainerTypeSemaphore:

        pType.Set( KTypeSemaphore );

        break;

    case EMemSpyDriverContainerTypeMutex:

        pType.Set( KTypeMutex );

        break;

    case EMemSpyDriverContainerTypeTimer:

        pType.Set( KTypeTimer );

        break;

    case EMemSpyDriverContainerTypeServer:

        pType.Set( KTypeServer );

        break;

    case EMemSpyDriverContainerTypeSession:

        pType.Set( KTypeSession );

        break;

    case EMemSpyDriverContainerTypeLogicalDevice:

        pType.Set( KTypeLogicalDevice );

        break;

    case EMemSpyDriverContainerTypePhysicalDevice:

        pType.Set( KTypePhysicalDevice );

        break;

    case EMemSpyDriverContainerTypeLogicalChannel:

        pType.Set( KTypeLogicalChannel );

        break;

    case EMemSpyDriverContainerTypeChangeNotifier:

        pType.Set( KTypeChangeNotifier );

        break;

    case EMemSpyDriverContainerTypeUndertaker:

        pType.Set( KTypeUndertaker );

        break;

    case EMemSpyDriverContainerTypeMsgQueue:

        pType.Set( KTypeMsgQueue );

        break;

    case EMemSpyDriverContainerTypePropertyRef:

        pType.Set( KTypePropertyRef );

        break;

    case EMemSpyDriverContainerTypeCondVar:

        pType.Set( KTypeCondVar );

        break;

    default:

        break;

        }

    //

    return pType;

    }

EXPORT_C TPtrC CMemSpyEngineGenericKernelObjectList::Name() const

    {

    return TPtrC( *iName );

    }

EXPORT_C void CMemSpyEngineGenericKernelObjectList::OutputL( CMemSpyEngineOutputSink& aSink ) const

    {

    // Start marker

    aSink.OutputLineFormattedL( KMemSpyMarkerKernelContainer, &KNullDesC, iType );

    TBuf<70> itemPrefix;

    TBuf<KMaxFullName + 128> buf;

    const TInt entryCount = Count();

    const TInt64 size( iSize * entryCount );

    const TMemSpySizeText sizeText( MemSpyEngineUtils::FormatSizeText( size, 0 ) );

    //    

    _LIT(KContainerTitle, "CONTAINER \'%S\' => %d item(s), %S");

    const TPtrC pType( TypeAsString( iType ) );

    buf.Format(KContainerTitle, &pType, entryCount, &sizeText);

    aSink.OutputSectionHeadingL( buf, '=' );

    //

    for( TInt entryIndex=0; entryIndex<entryCount; entryIndex++ )

        {

        const TMemSpyDriverHandleInfoGeneric& entry = At( entryIndex );

        //

        _LIT( KItemPrefixFormat, "[KernCont] {%04d} 0x%08x" );

        itemPrefix.Format( KItemPrefixFormat, entryIndex, entry.iHandle );

        buf.Copy( entry.iName );

        aSink.OutputItemAndValueL( itemPrefix, buf );

        }

    // End marker

    aSink.OutputBlankLineL();

    aSink.OutputLineFormattedL( KMemSpyMarkerKernelContainer, &KMemSpySinkTagClose, iType );

    aSink.OutputBlankLineL();

    }

TAny* CMemSpyEngineGenericKernelObjectList::HandleAt( TInt aIndex ) const

    {

    return iHandles[ aIndex ];

    }

void CMemSpyEngineGenericKernelObjectList::AddItemL( TAny* aHandle )

    {

    iHandles.InsertInAddressOrderL( aHandle );

    }

void CMemSpyEngineGenericKernelObjectList::AddItemL( const TMemSpyDriverHandleInfoGeneric& aItem )

    {

    AddItemL( aItem.iHandle );

    iItems.AppendL( aItem );

    //

    }

void CMemSpyEngineGenericKernelObjectList::UpdateNameL()

    {

    const TInt count = iItems.Count();

    const TInt64 size( iSize * count );

    const TMemSpySizeText sizeText( MemSpyEngineUtils::FormatSizeText( size, 0 ) );

    //

    _LIT(KNameFormat, "\t%S\t\t%d item");

    TPtr pName( iName->Des() );

    //

    const TPtrC pType( TypeAsString( iType ) );

    //

    pName.Format( KNameFormat, &pType, count );

    //

    if  ( count == 0 || count > 1 )

        {

        pName.Append( _L("s") );

        }

    pName.AppendFormat( _L(", %S"), &sizeText );

    }

CMemSpyEngineGenericKernelObjectContainer::CMemSpyEngineGenericKernelObjectContainer()

:   iItems( 25 )

    {

    }

EXPORT_C CMemSpyEngineGenericKernelObjectContainer::~CMemSpyEngineGenericKernelObjectContainer()

    {

    iItems.ResetAndDestroy();

    iItems.Close();

    }

void CMemSpyEngineGenericKernelObjectContainer::ConstructL()

    {

    }

CMemSpyEngineGenericKernelObjectContainer* CMemSpyEngineGenericKernelObjectContainer::NewLC()

    {

    CMemSpyEngineGenericKernelObjectContainer* self = new(ELeave) CMemSpyEngineGenericKernelObjectContainer();

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

EXPORT_C TInt CMemSpyEngineGenericKernelObjectContainer::Count() const

    {

    return iItems.Count();

    }

EXPORT_C const CMemSpyEngineGenericKernelObjectList& CMemSpyEngineGenericKernelObjectContainer::At( TInt aIndex ) const

    {

    return *iItems[ aIndex ];

    }

EXPORT_C void CMemSpyEngineGenericKernelObjectContainer::OutputL( CMemSpyEngineOutputSink& aSink ) const

    {

    // Start marker

    aSink.OutputLineFormattedL( KMemSpyMarkerKernelContainersAll, &KNullDesC );

    const TInt listCount= Count();

    for( TInt listIndex=0; listIndex<listCount; listIndex++ )

        {

        const CMemSpyEngineGenericKernelObjectList& list = At( listIndex );

        list.OutputL( aSink );

        }

    // End marker

    aSink.OutputLineFormattedL( KMemSpyMarkerKernelContainersAll, &KMemSpySinkTagClose );

    }

void CMemSpyEngineGenericKernelObjectContainer::AddListL( CMemSpyEngineGenericKernelObjectList* aList )

    {

    iItems.AppendL( aList );

    }

EXPORT_C TInt CMemSpyEngineGenericKernelObjectContainer::MdcaCount() const

    {

    return Count();

    }

EXPORT_C TPtrC CMemSpyEngineGenericKernelObjectContainer::MdcaPoint( TInt aIndex ) const

    {

    const CMemSpyEngineGenericKernelObjectList& item = At( aIndex );

    return item.Name();

    }