/*

* 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:

*

*/

#ifndef MEMSPYDRIVEROBJECTSSHAREDRHEAP_H

#define MEMSPYDRIVEROBJECTSSHAREDRHEAP_H

// System includes

#include <e32cmn.h>

#include <e32ldr.h>

#include <e32ldr_private.h>

#ifndef __KERNEL_MODE__

#include <e32debug.h>

#endif

// User includes

#include <memspy/driver/memspydriverenumerationsshared.h>

// Defines

//#define __CHECK_CHUNK_NAME

// Classes referenced

class CActiveScheduler;

class CTrapCleanup;

class TMemSpyHeapObjectDataRHeap

    {

public:

    inline TMemSpyHeapObjectDataRHeap()

        : iAccessCount( 0 ),

          iHandleCount( 0 ),

          iHandles( NULL ),

          iFlags( 0 ),

          iCellCount( 0 ),

          iTotalAllocSize ( 0 ),

          //

          iMinLength( 0 ),

          iMaxLength( 0 ),

          iOffset ( 0 ),

          iGrowBy( 0 ),

          iChunkHandle ( 0 ),

          iBase( NULL ),

          iTop( NULL ),

          iAlign( 0 ),

          iMinCell( 0 ),

          iPageSize( 0 ),

          iNestingLevel( 0 ),

          iAllocCount( 0 ),

          iFailRate( 0 ),

          iFailed( EFalse ),

          iFailAllocCount( 0 ),

          iRand( 0 ),

          iTestData( NULL )

        {

        }

public: // API

    inline TUint8* Base() const { return iBase; }

    inline TUint Size() const { return iTop - iBase; }

public: // From RAllocator

	TInt iAccessCount;

	TInt iHandleCount;

	TInt* iHandles;

	TUint32 iFlags;

	TInt iCellCount;

	TInt iTotalAllocSize;

public: // From RHeap

	TInt iMinLength;

	TInt iMaxLength;

	TInt iOffset;

	TInt iGrowBy;

	TInt iChunkHandle;

    RFastLock iLock;

	TUint8* iBase;

	TUint8* iTop;

	TInt iAlign;

	TInt iMinCell;

	TInt iPageSize;

    RHeap::SCell iFree;

	TInt iNestingLevel;

	TInt iAllocCount;

    RAllocator::TAllocFail iFailType;

	TInt iFailRate;

	TBool iFailed;

	TInt iFailAllocCount;

	TInt iRand;

	TAny* iTestData;

    };

/**

 * Base class for MemSpy RHeap statistics

 */

class TMemSpyHeapStatisticsRHeapBase

    {

public: // Type

    enum TType

        {

        ETypeAllocated = 0,

        ETypeFree

        };

public: // Constructors & destructor

    inline TMemSpyHeapStatisticsRHeapBase( TType aType )

        : iType( aType ), 

          iTypeCount( 0 ), 

          iTypeSize( 0 ),

          iLargestCellAddress( NULL ),

          iLargestCellSize( 0 )

        {

        }

public: // API

    inline TType Type() const { return iType; }

    //

    inline TUint TypeCount() const { return iTypeCount; }

    inline void SetTypeCount( TUint aValue ) { iTypeCount = aValue; }

    //

    inline TUint TypeSize() const { return iTypeSize; }

    inline void SetTypeSize( TUint aValue ) { iTypeSize = aValue; }

    //

    inline TAny* LargestCellAddress() const { return iLargestCellAddress; }

    inline void SetLargestCellAddress( TAny* aAddress ) { iLargestCellAddress = aAddress; }

    //

    inline TUint LargestCellSize() const { return iLargestCellSize; }

    inline void SetLargestCellSize( TUint aSize ) { iLargestCellSize = aSize; }

private: // Data members

    TType iType;

    TUint iTypeCount;

    TUint iTypeSize;

    TAny* iLargestCellAddress;

    TUint iLargestCellSize;

    };

/**

 * RHeap statistics for Allocated cell types

 */

class TMemSpyHeapStatisticsRHeapAllocated : public TMemSpyHeapStatisticsRHeapBase

    {

public: // Constructors

    inline TMemSpyHeapStatisticsRHeapAllocated()

        : TMemSpyHeapStatisticsRHeapBase( TMemSpyHeapStatisticsRHeapBase::ETypeAllocated )

        {

        }

public:

    };

/**

 * RHeap statistics for Free cell types

 */

class TMemSpyHeapStatisticsRHeapFree : public TMemSpyHeapStatisticsRHeapBase

    {

public: // Constructors

    inline TMemSpyHeapStatisticsRHeapFree()

        : TMemSpyHeapStatisticsRHeapBase( TMemSpyHeapStatisticsRHeapBase::ETypeFree ),

          iSlackSpace( 0 ), iSlackSpaceCellAddress( NULL ), iChecksum( 0 )

        {

        }

public: // API

    inline TUint SlackSpaceCellSize() const { return iSlackSpace; }

    inline void SetSlackSpaceCellSize( TUint aValue ) { iSlackSpace = aValue; }

    //

    inline TAny* SlackSpaceCellAddress() const { return iSlackSpaceCellAddress; }

    inline void SetSlackSpaceCellAddress( TAny* aAddress ) { iSlackSpaceCellAddress = aAddress; }

    //

    inline TUint32 Checksum() const { return iChecksum; }

    inline void SetChecksum( TUint32 aValue ) { iChecksum = aValue; }

public:

    TUint iSlackSpace;

    TAny* iSlackSpaceCellAddress;

    TUint32 iChecksum;

    };

/**

 * RHeap statistics for common cell types

 */

class TMemSpyHeapStatisticsRHeapCommon

    {

public: // Constructors

    inline TMemSpyHeapStatisticsRHeapCommon()

        : iTotalCellCount( 0 )

        {

        }

public:

    inline TUint TotalCellCount() const { return iTotalCellCount; }

    inline void SetTotalCellCount( TUint aValue ) { iTotalCellCount = aValue; }

private:

    TUint iTotalCellCount;

    };

/**

 * RHeap statistics class

 */

class TMemSpyHeapStatisticsRHeap

    {

public: // Constructors

    inline TMemSpyHeapStatisticsRHeap()

        {

        }

public: // API

    inline TMemSpyHeapStatisticsRHeapFree& StatsFree() { return iStatisticsFree; }

    inline const TMemSpyHeapStatisticsRHeapFree& StatsFree() const { return iStatisticsFree; }

    //

    inline TMemSpyHeapStatisticsRHeapAllocated& StatsAllocated() { return iStatisticsAllocated; }

    inline const TMemSpyHeapStatisticsRHeapAllocated& StatsAllocated() const { return iStatisticsAllocated; }

    //

    inline TMemSpyHeapStatisticsRHeapCommon& StatsCommon() { return iStatisticsCommon; }

    inline const TMemSpyHeapStatisticsRHeapCommon& StatsCommon() const { return iStatisticsCommon; }

private: // Data members

    TMemSpyHeapStatisticsRHeapCommon iStatisticsCommon;

    TMemSpyHeapStatisticsRHeapFree iStatisticsFree;

    TMemSpyHeapStatisticsRHeapAllocated iStatisticsAllocated;

    };

/**

 *

 */

class TMemSpyHeapMetaDataRHeap

    {

public: // Constructors

    inline TMemSpyHeapMetaDataRHeap()

        : iChunkSize( 0 ),

          iChunkHandle( NULL ),

          iChunkBaseAddress( NULL ),

          iDebugAllocator( EFalse ),

          iHeaderSizeFree( 0 ),

          iHeaderSizeAllocated( 0 ),

          iIsUserThread( ETrue ),

          iSharedHeap( EFalse )

        {

        }

public: // API

#ifndef __KERNEL_MODE__

    inline TPtrC ChunkName() const

        {

        TBool alreadyExpanded = ETrue;

#ifdef __CHECK_CHUNK_NAME

        {

        RDebug::Printf( "TMemSpyHeapMetaDataRHeap::ChunkName() - BEF - length: %d", iChunkName.Length() );

        const TUint8* data2 = iChunkName.Ptr();

        const TInt count = iChunkName.Length();

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

            {

            RDebug::Printf( "TMemSpyHeapMetaDataRHeap::ChunkName() - BEF - data[%03d] = 0x%08x = %02x (%c)", i, data2, *data2, *data2 );

            ++data2;

            }

        }

#endif

        // Check if it already has been converted to unicode

        const TUint8* data = iChunkName.Ptr();

        if ( iChunkName.Length() >= 1 )

            {

            const TUint8 highByte = *(data + 1);

            alreadyExpanded = ( highByte == 0 ); 

            }

        // Once expanded, the descriptor is twice the length

        TPtrC ret( (TUint16*) iChunkName.Ptr(), iChunkName.Length() / 2 );

        //

        if ( !alreadyExpanded )

            {

            const TInt halfLength = iChunkName.Length() / 2;

            TMemSpyHeapMetaDataRHeap* self = const_cast< TMemSpyHeapMetaDataRHeap* >( this );

            ret.Set( self->iChunkName.Expand() );

            }

#ifdef __CHECK_CHUNK_NAME

        {

        RDebug::Printf( "TMemSpyHeapMetaDataRHeap::ChunkName() - AFT - length: %d", iChunkName.Length() );

        const TUint8* data2 = iChunkName.Ptr();

        const TInt count = iChunkName.Length();

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

            {

            RDebug::Printf( "TMemSpyHeapMetaDataRHeap::ChunkName() - AFT - data[%03d] = 0x%08x = %02x (%c)", i, data2, *data2, *data2 );

            ++data2;

            }

        const TPtrC pNextRet( (TUint16*) iChunkName.Ptr(), iChunkName.Length() / 2 );

        RDebug::Print( _L("TMemSpyHeapMetaDataRHeap::ChunkName() - ret: [%S], nextRet: [%S]"), &ret, &pNextRet );

        }

#endif

        //

        return ret;

        }

    inline void SetChunkName( const TDesC16& aValue )

        {

        iChunkName.Copy( aValue );

        iChunkName.Collapse();

        }

#else

    inline void SetChunkName( const TDesC8& aValue )

        {

        iChunkName.Copy( aValue );

        }

#endif

    //

    inline TUint ChunkSize() const { return iChunkSize; }

    inline void SetChunkSize( TUint aValue ) { iChunkSize = aValue; }

    //

    inline TAny* ChunkHandle() const { return iChunkHandle; }

    inline void SetChunkHandle( TAny* aValue ) { iChunkHandle = aValue; }

    //

    inline TAny* ChunkBaseAddress() const { return iChunkBaseAddress; }

    inline void SetChunkBaseAddress( TAny* aValue ) { iChunkBaseAddress = aValue; }

    //

    inline TUint HeaderSizeFree() const { return iHeaderSizeFree; }

    inline void SetHeaderSizeFree( TUint aValue ) { iHeaderSizeFree = aValue; }

    //

    inline TUint HeaderSizeAllocated() const { return iHeaderSizeAllocated; }

    inline void SetHeaderSizeAllocated( TUint aValue ) { iHeaderSizeAllocated = aValue; }

    //

    inline TBool IsDebugAllocator() const { return iDebugAllocator; }

    inline void SetDebugAllocator( TBool aValue ) { iDebugAllocator = aValue; }

    //

    inline TBool IsUserThread() const { return iIsUserThread; }

    inline void SetUserThread( TBool aValue ) { iIsUserThread = aValue; }

    //

    inline TBool IsSharedHeap() const { return iSharedHeap; }

    inline void SetSharedHeap( TBool aValue ) { iSharedHeap = aValue; }

    //

    inline TUint VTable() const { return iVTable; }

    inline void SetVTable( TUint aValue ) { iVTable = aValue; }

    //

    inline TUint ClassSize() const { return iClassSize; }

    inline void SetClassSize( TUint aValue ) { iClassSize = aValue; }

private: // Data members

    TBuf8< KMaxFullName * 2 > iChunkName;

    TUint iChunkSize;

    TAny* iChunkHandle;

    TAny* iChunkBaseAddress;

    TBool iDebugAllocator;

    TUint iHeaderSizeFree;

    TUint iHeaderSizeAllocated;

    TBool iSharedHeap;

    TBool iIsUserThread;

    TUint iVTable;

    TUint iClassSize;

    };

/**

 *

 */

class TMemSpyHeapInfoRHeap

    {

public: // Constructors

    inline TMemSpyHeapInfoRHeap()

        {

        }

public: // API

    inline TMemSpyHeapMetaDataRHeap& MetaData() { return iMetaData; }

    inline const TMemSpyHeapMetaDataRHeap& MetaData() const { return iMetaData; }

    //

    inline TMemSpyHeapObjectDataRHeap& ObjectData() { return iObjectData; }

    inline const TMemSpyHeapObjectDataRHeap& ObjectData() const { return iObjectData; }

    //

    inline TMemSpyHeapStatisticsRHeap& Statistics() { return iStatistics; }

    inline const TMemSpyHeapStatisticsRHeap& Statistics() const { return iStatistics; }

private: // Data members

    TMemSpyHeapMetaDataRHeap iMetaData;

    TMemSpyHeapObjectDataRHeap iObjectData;

    TMemSpyHeapStatisticsRHeap iStatistics;

    };

#endif