/*

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

// Driver includes

#include <memspy/driver/memspydriverclient.h>

// User includes

#include <memspy/engine/memspyengine.h>

#include <memspy/engine/memspyengineutils.h>

#include <memspy/engine/memspyengineoutputsink.h>

#include <memspy/engine/memspyengineoutputlist.h>

#include <memspy/engine/memspyengineobjectthread.h>

#include <memspy/engine/memspyengineobjectprocess.h>

// Constants

const TInt KMemSpyEngineMaxChunkCount = 768;

// Literal constants

_LIT( KMemSpyEngineChunkListOutputComma, ", " );

CMemSpyEngineHelperChunk::CMemSpyEngineHelperChunk( CMemSpyEngine& aEngine )

:   iEngine( aEngine )

    {

    }

CMemSpyEngineHelperChunk::~CMemSpyEngineHelperChunk()

    {

    }

void CMemSpyEngineHelperChunk::ConstructL()

    {

    }

CMemSpyEngineHelperChunk* CMemSpyEngineHelperChunk::NewL( CMemSpyEngine& aEngine )

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

EXPORT_C void CMemSpyEngineHelperChunk::OutputChunkInfoForThreadL( const CMemSpyThread& aThread )

    {

    OutputChunkInfoForThreadL( aThread.Id() );

    }

EXPORT_C void CMemSpyEngineHelperChunk::OutputChunkInfoForThreadL( TThreadId aTid )

    {

    TBuf<512> lineBuffer;

    OutputChunkInfoForThreadL( aTid, lineBuffer );

    }

EXPORT_C void CMemSpyEngineHelperChunk::OutputChunkInfoForThreadL( TThreadId aTid, TDes& aLineBuffer )

    {

    DoOutputChunkInfoForObjectL( aTid, aLineBuffer, EThread );

    }

EXPORT_C void CMemSpyEngineHelperChunk::OutputChunkInfoForProcessL( const CMemSpyProcess& aProcess )

    {

    OutputChunkInfoForProcessL( aProcess.Id() );

    }

EXPORT_C void CMemSpyEngineHelperChunk::OutputChunkInfoForProcessL( TProcessId aPid )

    {

    TBuf<512> lineBuffer;

    OutputChunkInfoForProcessL( aPid, lineBuffer );

    }

EXPORT_C void CMemSpyEngineHelperChunk::OutputChunkInfoForProcessL( TProcessId aPid, TDes& aLineBuffer )

    {

    DoOutputChunkInfoForObjectL( aPid, aLineBuffer, EProcess );

    }

EXPORT_C CMemSpyEngineChunkList* CMemSpyEngineHelperChunk::ListL()

    {

    RArray<TAny*> handles( 128 );

    CleanupClosePushL( handles );

    //

    GetChunkHandlesL( handles, EAll );

    CMemSpyEngineChunkList* list = CreateListFromHandlesL( handles );

    //

    CleanupStack::PopAndDestroy( &handles );

    return list;

    }

EXPORT_C CMemSpyEngineChunkList* CMemSpyEngineHelperChunk::ListForThreadL( TThreadId aTid )

    {

    RArray<TAny*> handles( 128 );

    CleanupClosePushL( handles );

    //

    GetChunkHandlesL( handles, EThread, aTid );

    CMemSpyEngineChunkList* list = CreateListFromHandlesL( handles );

    //

    CleanupStack::PopAndDestroy( &handles );

    return list;

    }

EXPORT_C CMemSpyEngineChunkList* CMemSpyEngineHelperChunk::ListForProcessL( TProcessId aPid )

    {

    RArray<TAny*> handles( 128 );

    CleanupClosePushL( handles );

    //

    GetChunkHandlesL( handles, EProcess, aPid );

    CMemSpyEngineChunkList* list = CreateListFromHandlesL( handles );

    //

    CleanupStack::PopAndDestroy( &handles );

    return list;

    }

void CMemSpyEngineHelperChunk::DoOutputChunkInfoForObjectL( TUint aId, TDes& aLineBuffer, TType aType )

    {

    TFullName ownerName;

	//

    RArray<TAny*> handles( 128 );

    CleanupClosePushL( handles );

    //

    GetChunkHandlesL( handles, aType, aId );

    CMemSpyEngineChunkList* list = CreateListFromHandlesL( handles );

    //

    CleanupStack::PopAndDestroy( &handles );

    CleanupStack::PushL( list );

    //

    const TInt count = list->Count();

    for (TInt i=0; i<count; i++)

    	{

        const CMemSpyEngineChunkEntry& entry = list->At( i );

        //

        _LIT(KLine1, "Name");

        iEngine.Sink().OutputItemAndValueL( KLine1, entry.Name() );

        //

        _LIT(KLine2, "Owner");

        entry.OwnerName( ownerName );

        iEngine.Sink().OutputItemAndValueL( KLine2, ownerName );

        //

        _LIT(KLine3, "Address");

        _LIT(KLine3Format, "0x%08x - 0x%08x");

        aLineBuffer.Format(KLine3Format, entry.BaseAddress(), entry.UpperAddress() );

        iEngine.Sink().OutputItemAndValueL( KLine3, aLineBuffer );

        //

        _LIT(KLine4, "Size (max)");

        _LIT(KLine4Format, "%d (%d)");

        aLineBuffer.Format(KLine4Format, entry.Size(), entry.MaxSize());

        iEngine.Sink().OutputItemAndValueL( KLine4, aLineBuffer );

        //

        if  ( i < count - 1 )

            {

            iEngine.Sink().OutputBlankLineL();

    		}

        }

    //

    CleanupStack::PopAndDestroy( list );

    }

void CMemSpyEngineHelperChunk::GetChunkHandlesL( RArray<TAny*>& aHandles, TType aType, TUint aId )

    {

	TAny* handles[ KMemSpyEngineMaxChunkCount ];

	TInt count = KMemSpyEngineMaxChunkCount;

    TInt r = 0;

    //

    switch( aType )

        {

    case EThread:

        r = iEngine.Driver().GetChunkHandlesForThread( aId, handles, count );

        break;

    case EProcess:

        r = iEngine.Driver().GetChunkHandlesForProcess( aId, handles, count );

        break;

    default:

    case EAll:

        r = iEngine.Driver().GetChunkHandles( handles, count );

        break;

        }

    //

    if  ( r == KErrNone )

    	{

        count = Min( count, KMemSpyEngineMaxChunkCount );

        for( TInt index = 0; index < count; index++ )

            {

            TAny* handle = handles[ index ];

            if  ( aHandles.Find( handle ) == KErrNotFound )

                {

                aHandles.AppendL( handle );

                }

            }

        }

    }

CMemSpyEngineChunkList* CMemSpyEngineHelperChunk::CreateListFromHandlesL( const RArray<TAny*>& aHandles )

    {

    CMemSpyEngineChunkList* list = CMemSpyEngineChunkList::NewLC( iEngine );

    //

    TMemSpyDriverChunkInfo info;

    const TInt count = aHandles.Count();

    //

    for( TInt i=0; i<count; i++ )

        {

        TAny* handle = aHandles[ i ];

        //

    	const TInt error = iEngine.Driver().GetChunkInfo( handle, info );

        if  ( error == KErrNone )

            {

            CMemSpyEngineChunkEntry* entry = CMemSpyEngineChunkEntry::NewLC( iEngine, info );

            list->AddItemL( entry );

            CleanupStack::Pop( entry );

            }

        }

    //

    list->SortBySizeL();

    //

    CleanupStack::Pop( list );

    return list;

    }

CMemSpyEngineChunkList::CMemSpyEngineChunkList( CMemSpyEngine& aEngine )

:   iEngine( aEngine )

    {

    }

EXPORT_C CMemSpyEngineChunkList::~CMemSpyEngineChunkList()

    {

    iItems.ResetAndDestroy();

    iItems.Close();

    }

void CMemSpyEngineChunkList::ConstructL()

    {

    }

CMemSpyEngineChunkList* CMemSpyEngineChunkList::NewLC( CMemSpyEngine& aEngine )

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

EXPORT_C TInt CMemSpyEngineChunkList::Count() const

    {

    return iItems.Count();

    }

EXPORT_C CMemSpyEngineChunkEntry& CMemSpyEngineChunkList::At( TInt aIndex )

    {

    return *iItems[ aIndex ];

    }

EXPORT_C const CMemSpyEngineChunkEntry& CMemSpyEngineChunkList::At( TInt aIndex ) const

    {

    return *iItems[ aIndex ];

    }

EXPORT_C void CMemSpyEngineChunkList::SortByNameL()

    {

    TLinearOrder< CMemSpyEngineChunkEntry > comparer( CompareByName );

    iItems.Sort( comparer );

    }

EXPORT_C void CMemSpyEngineChunkList::SortBySizeL()

    {

    TLinearOrder< CMemSpyEngineChunkEntry > comparer( CompareBySize );

    iItems.Sort( comparer );

    }

EXPORT_C TInt CMemSpyEngineChunkList::ItemIndex( const CMemSpyEngineChunkEntry& aEntry ) const

    {

    TInt ret = KErrNotFound;

    //

    const TInt count = Count();

    for( TInt i=0; i<count; i++ )

        {

        const CMemSpyEngineChunkEntry* item = iItems[ i ];

        //

        if  ( item == &aEntry )

            {

            ret = i;

            break;

            }

        }

    //

    return ret;

    }

EXPORT_C void CMemSpyEngineChunkList::OutputDataColumnsL( CMemSpyEngine& aEngine )

    {

    HBufC* columns = HBufC::NewLC( 1024 );

    TPtr pColumns( columns->Des() );

    //

    _LIT(KCol1, "Name");

    pColumns.Append( KCol1 );

    pColumns.Append( KMemSpyEngineChunkListOutputComma );

    //

    _LIT(KCol2, "Owning Process");

    pColumns.Append( KCol2 );

    pColumns.Append( KMemSpyEngineChunkListOutputComma );

    //

    _LIT(KCol3, "Size");

    pColumns.Append( KCol3 );

    pColumns.Append( KMemSpyEngineChunkListOutputComma );

    //

    _LIT(KCol4, "Max. Size");

    pColumns.Append( KCol4 );

    pColumns.Append( KMemSpyEngineChunkListOutputComma );

    //

    _LIT(KCol5, "Address");

    pColumns.Append( KCol5 );

    //

    aEngine.Sink().OutputLineL( pColumns );

    CleanupStack::PopAndDestroy( columns );

    }

EXPORT_C TBool CMemSpyEngineChunkList::EntryExists( TAny* aHandle ) const

    {

    TBool ret = EFalse;

    //

    const TInt count = Count();

    for( TInt i=0; i<count && !ret; i++ )

        {

        const CMemSpyEngineChunkEntry* item = iItems[ i ];

        ret = ( item->Handle() == aHandle );

        }

    //

    return ret;

    }

void CMemSpyEngineChunkList::AddItemL( CMemSpyEngineChunkEntry* aItem )

    {

    iItems.AppendL( aItem );

    }

void CMemSpyEngineChunkList::Remove( TInt aIndex )

    {

    CMemSpyEngineChunkEntry* item = iItems[ aIndex ];

    delete item;

    iItems.Remove( aIndex );

    }

void CMemSpyEngineChunkList::RemoveByHandle( TAny* aChunkHandle )

    {

    const TInt index = ItemIndexByChunkHandle( aChunkHandle );

    if  ( index >= 0 )

        {

        Remove( index );

        }

    }

TInt CMemSpyEngineChunkList::ItemIndexByProcessId( TUint aPid ) const

    {

    const TInt ret = ItemIndexByProcessId( aPid, 0 );

    return ret;

    }

TInt CMemSpyEngineChunkList::ItemIndexByProcessId( TUint aPid, TInt aStartIndex ) const

    {

    TInt ret = KErrNotFound;

    //

    const TInt count = Count();

    for( TInt i=aStartIndex; i<count; i++ )

        {

        const CMemSpyEngineChunkEntry* item = iItems[ i ];

        //

        if  ( item->OwnerId() == aPid )

            {

            ret = i;

            break;

            }

        }

    //

    return ret;

    }

TInt CMemSpyEngineChunkList::ItemIndexByProcessId( TUint aPid, TMemSpyDriverChunkType aType ) const

    {

    TInt ret = KErrNotFound;

    //

    const TInt count = Count();

    for( TInt i=0; i<count; i++ )

        {

        const CMemSpyEngineChunkEntry* item = iItems[ i ];

        //

        if  ( item->OwnerId() == aPid && item->Info().iType == aType )

            {

            ret = i;

            break;

            }

        }

    //

    return ret;

    }

TInt CMemSpyEngineChunkList::ItemIndexByChunkHandle( TAny* aHandle ) const

    {

    TInt ret = KErrNotFound;

    //

    const TInt count = Count();

    for( TInt i=0; i<count; i++ )

        {

        const CMemSpyEngineChunkEntry* item = iItems[ i ];

        //

        if  ( item->Handle() == aHandle )

            {

            ret = i;

            break;

            }

        }

    //

    return ret;

    }

EXPORT_C TInt CMemSpyEngineChunkList::MdcaCount() const

    {

    return Count();

    }

EXPORT_C TPtrC CMemSpyEngineChunkList::MdcaPoint( TInt aIndex ) const

    {

    const CMemSpyEngineChunkEntry& item = At( aIndex );

    return TPtrC( item.Caption() );

    }

TInt CMemSpyEngineChunkList::CompareByName( const CMemSpyEngineChunkEntry& aLeft, const CMemSpyEngineChunkEntry& aRight )

    {