/*

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

#define MEMSPYTHREADINFOOBJECTS_H

// System includes

#include <e32base.h>

#include <badesca.h>

// User includes

#include <memspy/engine/memspyengineobject.h>

#include <memspy/driver/memspydriverobjectsshared.h>

#include <memspy/engine/memspyengineprocessmemorytracker.h>

// Classes referenced

class CMemSpyEngine;

class CMemSpyThread;

class CMemSpyThreadInfoContainer;

class CMemSpyEngineChunkList;

class CMemSpyEngineCodeSegList;

class CMemSpyEngineActiveObjectArray;

// Enumerations

enum TMemSpyThreadInfoItemType

    {

    EMemSpyThreadInfoItemTypeFirst = 0,

    //

    EMemSpyThreadInfoItemTypeGeneralInfo = EMemSpyThreadInfoItemTypeFirst,

    EMemSpyThreadInfoItemTypeHeap,

    EMemSpyThreadInfoItemTypeStack,

    EMemSpyThreadInfoItemTypeChunk,

    EMemSpyThreadInfoItemTypeCodeSeg,

    EMemSpyThreadInfoItemTypeOpenFiles,

    EMemSpyThreadInfoItemTypeActiveObject,

    EMemSpyThreadInfoItemTypeOwnedThreadHandles,

    EMemSpyThreadInfoItemTypeOwnedProcessHandles,

    EMemSpyThreadInfoItemTypeServer,

    EMemSpyThreadInfoItemTypeSession,

    EMemSpyThreadInfoItemTypeSemaphore,

    EMemSpyThreadInfoItemTypeOtherThreads,

    EMemSpyThreadInfoItemTypeOtherProcesses,

    EMemSpyThreadInfoItemTypeMutex,

    EMemSpyThreadInfoItemTypeTimer,

    EMemSpyThreadInfoItemTypeLogicalChannel,

    EMemSpyThreadInfoItemTypeChangeNotifier,

    EMemSpyThreadInfoItemTypeUndertaker,

    EMemSpyThreadInfoItemTypeMessageQueue,

    EMemSpyThreadInfoItemTypeConditionalVariable,

    EMemSpyThreadInfoItemTypeLDD,

    EMemSpyThreadInfoItemTypePDD,

    EMemSpyThreadInfoItemTypeMemoryTracking,

    EMemSpyThreadInfoItemTypeMemoryTrackingCurrent,

    EMemSpyThreadInfoItemTypeMemoryTrackingHWM,

    EMemSpyThreadInfoItemTypeMemoryTrackingPeak,

    //

    EMemSpyThreadInfoItemTypeLast

    };

// Constants

const TInt KMemSpyDefaultMaxHandleCount = 128;

NONSHARABLE_CLASS( CMemSpyThreadInfoItemBase ) : public CMemSpyEngineObject, public MDesCArray

    {

protected:

    CMemSpyThreadInfoItemBase( CMemSpyThreadInfoContainer& aContainer, TMemSpyThreadInfoItemType aType, TBool aAsyncConstruction );

    ~CMemSpyThreadInfoItemBase();

    virtual void ConstructL() = 0;

private: // Construction support

    static TInt CallConstructL( TAny* aSelf );

public: // API

    virtual TPtrC Name() const = 0;

    IMPORT_C TMemSpyThreadInfoItemType Type() const;

    IMPORT_C virtual void RebuildL();

    inline CMemSpyThreadInfoContainer& Container() { return iContainer; }

    IMPORT_C TBool IsReady() const;

    IMPORT_C CMemSpyEngine& Engine() const;

    IMPORT_C void PrintL();

public: // From MDesCArray

    IMPORT_C TInt MdcaCount() const;

    IMPORT_C TPtrC MdcaPoint(TInt aIndex) const;

protected:

    class CItem : public CBase

        {

        public:

            static CItem* NewLC( const CItem& aCopyMe );

            static CItem* NewLC( const TDesC& aCaption );

            static CItem* NewLC( const TDesC& aCaption, const TDesC& aValue );

            static CItem* NewHexLC( const TDesC& aCaption, TUint aValue );

            static CItem* NewDecimalLC( const TDesC& aCaption, TInt aValue );

            static CItem* NewLongLC( const TDesC& aCaption, const TInt64& aValue );

            static CItem* NewYesNoLC( const TDesC& aCaption, TBool aYes );

            static CItem* NewOnOffLC( const TDesC& aCaption, TBool aOn );

            static CItem* NewPercentageLC( const TDesC& aCaption, TInt aOneHundredPercentValue, TInt aValue );

            ~CItem();

        private:

            CItem();

            void ConstructL( const TDesC& aCaption, const TDesC& aValue );

        public: // API

            inline const TDesC& Caption() const { return *iCaption; }

            inline const TDesC& Value() const { return *iValue; }

            inline const TDesC& Combined() const { return *iCombined; }

        public:

            void SetValueL( const TDesC& aValue );

            void SetHexL( TUint aValue );

            void SetDecimalL( TInt aValue );

            void SetLongL( const TInt64& aValue );

            void SetYesNoL( TBool aYes );

            void SetOnOffL( TBool aOn );

            void SetPercentageL( TInt aOneHundredPercentValue, TInt aValue );

        private: // Internal

            void UpdateCombinedL();

        private:

            HBufC* iCaption;

            HBufC* iValue;

            HBufC* iCombined;

        };

protected: // Internal API

    void AddItemL( const TDesC& aCaption, const TDesC& aValue );

    void AddItemHexL( const TDesC& aCaption, TUint aValue );

    void AddItemDecimalL( const TDesC& aCaption, TInt aValue );

    void AddItemLongL( const TDesC& aCaption, const TInt64& aValue );

    void AddItemYesNoL( const TDesC& aCaption, TBool aYes );

    void AddItemOnOffL( const TDesC& aCaption, TBool aOn );

    void AddItemPercentageL( const TDesC& aCaption, TInt aOneHundredPercentValue, TInt aValue );

    void StripProcessAndThreadNames( TDes& aText );

    void StripProcessName( TDes& aText );

    void StripThreadName( TDes& aText );

    CItem& Item( TInt aIndex );

    const CItem& Item( TInt aIndex ) const;

    virtual void Reset();

private:

    mutable CMemSpyThreadInfoContainer& iContainer;

    TBool iReady;

    TBool iIsEmpty;

    RPointerArray<CItem> iItems;

    CAsyncCallBack iCallBack;

    const TMemSpyThreadInfoItemType iType;

    };

NONSHARABLE_CLASS( CMemSpyThreadInfoGeneral ) : public CMemSpyThreadInfoItemBase

    {

public:

    static CMemSpyThreadInfoGeneral* NewLC( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );

private: // From CMemSpyThreadInfoItemBase

    CMemSpyThreadInfoGeneral( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );

    void ConstructL();

public: // From CMemSpyThreadInfoItemBase

    IMPORT_C TPtrC Name() const;

private: // Internal methods

    void MakeRegisterListingL( RThread& aThread );

    };

NONSHARABLE_CLASS( CMemSpyThreadInfoHeap ) : public CMemSpyThreadInfoItemBase

    {

public:

    static CMemSpyThreadInfoHeap* NewLC( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );

private: // From CMemSpyThreadInfoItemBase

    CMemSpyThreadInfoHeap( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );

    void ConstructL();

public: // From CMemSpyThreadInfoItemBase

    IMPORT_C TPtrC Name() const;

    };

NONSHARABLE_CLASS( CMemSpyThreadInfoOpenFiles ) : public CMemSpyThreadInfoItemBase

    {

public:

    static CMemSpyThreadInfoOpenFiles* NewLC( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );

private: // From CMemSpyThreadInfoItemBase

    CMemSpyThreadInfoOpenFiles( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );

    void ConstructL();

public: // From CMemSpyThreadInfoItemBase

    IMPORT_C TPtrC Name() const;

    };

NONSHARABLE_CLASS( CMemSpyThreadInfoActiveObjects ) : public CMemSpyThreadInfoItemBase

    {

public:

    static CMemSpyThreadInfoActiveObjects* NewLC( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );

    ~CMemSpyThreadInfoActiveObjects();

private: // From CMemSpyThreadInfoItemBase

    CMemSpyThreadInfoActiveObjects( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );

    void ConstructL();

public: // From CMemSpyThreadInfoItemBase

    IMPORT_C TPtrC Name() const;

public: // From MDesCArray

    IMPORT_C TInt MdcaCount() const;

    IMPORT_C TPtrC MdcaPoint(TInt aIndex) const;

public: // API

    inline CMemSpyEngineActiveObjectArray& Array() { return *iItems; }

private: // Member data

    CMemSpyEngineActiveObjectArray* iItems;

    };

NONSHARABLE_CLASS( CMemSpyThreadInfoStack ) : public CMemSpyThreadInfoItemBase

    {

public:

    static CMemSpyThreadInfoStack* NewLC( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );

private: // From CMemSpyThreadInfoItemBase

    CMemSpyThreadInfoStack( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );

    void ConstructL();

public: // From CMemSpyThreadInfoItemBase

    IMPORT_C TPtrC Name() const;

    };

NONSHARABLE_CLASS( CMemSpyThreadInfoChunk ) : public CMemSpyThreadInfoItemBase

    {

public:

    static CMemSpyThreadInfoChunk* NewLC( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );

    ~CMemSpyThreadInfoChunk();

private: // From CMemSpyThreadInfoItemBase

    CMemSpyThreadInfoChunk( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );

    void ConstructL();

public: // From CMemSpyThreadInfoItemBase

    IMPORT_C TPtrC Name() const;

public: // From MDesCArray

    IMPORT_C TInt MdcaCount() const;

    IMPORT_C TPtrC MdcaPoint(TInt aIndex) const;

public: // API

    inline CMemSpyEngineChunkList& List() { return *iList; }

    inline void NullifyList() { iList = NULL; }

private:

    CMemSpyEngineChunkList* iList;

    };

NONSHARABLE_CLASS( CMemSpyThreadInfoCodeSeg ) : public CMemSpyThreadInfoItemBase

    {

public:

    static CMemSpyThreadInfoCodeSeg* NewLC( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );

    ~CMemSpyThreadInfoCodeSeg();

private: // From CMemSpyThreadInfoItemBase

    CMemSpyThreadInfoCodeSeg( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );

    void ConstructL();

public: // From CMemSpyThreadInfoItemBase

    IMPORT_C TPtrC Name() const;

public: // From MDesCArray

    IMPORT_C TInt MdcaCount() const;

    IMPORT_C TPtrC MdcaPoint(TInt aIndex) const;

public: // API

    inline CMemSpyEngineCodeSegList& List() { return *iList; }

    inline void NullifyList() { iList = NULL; }

private: // Data members

    CMemSpyEngineCodeSegList* iList;

    };

NONSHARABLE_CLASS( CMemSpyThreadInfoHandleObjectBase ) : public CMemSpyThreadInfoItemBase

    {

public:

    ~CMemSpyThreadInfoHandleObjectBase();

protected: // From CMemSpyThreadInfoItemBase

    CMemSpyThreadInfoHandleObjectBase( CMemSpyThreadInfoContainer& aContainer, TMemSpyThreadInfoItemType aItemType, TMemSpyDriverContainerType aContainerType, TBool aAsyncConstruction );

    void ConstructL();

public: // New API

    inline TMemSpyDriverContainerType ContainerType() const { return iContainerType; }

    inline TInt DetailsCount() const { return iInfoItems.Count(); }

    inline TMemSpyDriverHandleInfoGeneric& DetailsAt( TInt aIndex ) { return iInfoItems[ aIndex ]; }

    inline const TMemSpyDriverHandleInfoGeneric& DetailsAt( TInt aIndex ) const { return iInfoItems[ aIndex ]; }

    IMPORT_C TInt DetailsIndexByEntry( const TMemSpyDriverHandleInfoGeneric& aEntry ) const;

    IMPORT_C TInt DetailsIndexByHandle( TAny* aHandle ) const;

protected: // Internal class

    class THandleWrapper

        {

    public:

        inline THandleWrapper( TAny* aHandle, TMemSpyDriverContainerType aType ) : iHandle( aHandle ), iType( aType ), iRefCount( 1 ) { }

    public: // API

        static TBool Match( const THandleWrapper& aLeft, const THandleWrapper& aRight );

    public: // Data members

        TAny* iHandle;

        TMemSpyDriverContainerType iType;

        TInt iRefCount;

        };

protected: // Internal API

    virtual void GetHandlesL( RArray<THandleWrapper>& aArray ) = 0;

protected: // New internal framework API

    virtual void HandleContainerItemL( TMemSpyDriverHandleInfoGeneric& aItem, TInt aRefCount, TDes& aFullName ) = 0;

    virtual void HandleAllItemsLocatedL() { }

private: // Data members

    const TMemSpyDriverContainerType iContainerType;

    RArray< TMemSpyDriverHandleInfoGeneric > iInfoItems;

    };

NONSHARABLE_CLASS( CMemSpyThreadInfoHandleByContainer ) : public CMemSpyThreadInfoHandleObjectBase

    {

protected: // From CMemSpyThreadInfoItemBase

    CMemSpyThreadInfoHandleByContainer( CMemSpyThreadInfoContainer& aContainer, TMemSpyThreadInfoItemType aItemType, TMemSpyDriverContainerType aContainerType, TBool aAsyncConstruction );

protected: // From CMemSpyThreadInfoHandleObjectBase

    void GetHandlesL( RArray<THandleWrapper>& aArray );

    };

NONSHARABLE_CLASS( CMemSpyThreadInfoReferencedBy ) : public CMemSpyThreadInfoHandleObjectBase

    {

protected: // From CMemSpyThreadInfoItemBase

    CMemSpyThreadInfoReferencedBy( CMemSpyThreadInfoContainer& aContainer, TMemSpyThreadInfoItemType aItemType, TMemSpyDriverContainerType aContainerType, TBool aAsyncConstruction );

protected: // From CMemSpyThreadInfoHandleObjectBase

    void GetHandlesL( RArray<THandleWrapper>& aArray );

    };

NONSHARABLE_CLASS( CMemSpyThreadInfoServer ) : public CMemSpyThreadInfoHandleByContainer

    {

public:

    static CMemSpyThreadInfoServer* NewLC( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );

private:

    CMemSpyThreadInfoServer( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );

public: // From CMemSpyThreadInfoItemBase

    IMPORT_C TPtrC Name() const;

    IMPORT_C static TPtrC SessionType( TIpcSessionType aType );

private: // From CMemSpyThreadInfoHandleByContainer

    void HandleContainerItemL( TMemSpyDriverHandleInfoGeneric& aItem, TInt aRefCount, TDes& aFullName );

    };

NONSHARABLE_CLASS( CMemSpyThreadInfoSession ) : public CMemSpyThreadInfoHandleByContainer

    {

public:

    static CMemSpyThreadInfoSession* NewLC( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );

    ~CMemSpyThreadInfoSession();

private:

    CMemSpyThreadInfoSession( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );

public: // From CMemSpyThreadInfoItemBase

    IMPORT_C TPtrC Name() const;

public: // API

    IMPORT_C TInt ConnectionCount( const TDesC& aName ) const;

private: // From CMemSpyThreadInfoHandleByContainer

    void HandleContainerItemL( TMemSpyDriverHandleInfoGeneric& aItem, TInt aRefCount, TDes& aFullName );

    void HandleAllItemsLocatedL();

protected: // From CMemSpyThreadInfoItemBase

    void Reset();

private: // Internal object

    class CSessionInfoEntry : public CBase

        {

    public:

        inline CSessionInfoEntry( HBufC* aName ) : iCount(1), iName( aName ) { }

        inline ~CSessionInfoEntry() { delete iName; }

    public:

        TInt iCount;

        HBufC* iName;

        };

private: // Internal methods

    static TBool CompareEntries( const CSessionInfoEntry& aLeft, const CSessionInfoEntry& aRight );

private:

    RPointerArray<CSessionInfoEntry> iServerNames;

    };

NONSHARABLE_CLASS( CMemSpyThreadInfoSemaphore ) : public CMemSpyThreadInfoHandleByContainer

    {

public:

    static CMemSpyThreadInfoSemaphore* NewLC( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );

private:

    CMemSpyThreadInfoSemaphore( CMemSpyThreadInfoContainer& aContainer, TBool aAsyncConstruction );

public: // From CMemSpyThreadInfoItemBase

    IMPORT_C TPtrC Name() const;

private: // From CMemSpyThreadInfoHandleByContainer

    void HandleContainerItemL( TMemSpyDriverHandleInfoGeneric& aItem, TInt aRefCount, TDes& aFullName );