diff -r 000000000000 -r a03f92240627 memspy/Engine/Source/Helpers/MemSpyEngineHelperKernelContainers.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/memspy/Engine/Source/Helpers/MemSpyEngineHelperKernelContainers.cpp	Tue Feb 02 01:57:15 2010 +0200
@@ -0,0 +1,532 @@
+/*
+* 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 );
+    //
+    UpdateNameL();
+    }
+
+
+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();
+    }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+