public:

	struct SCell

        {

        TInt len; 

        SCell* next;

        };

    struct SDebugCell

        {

        TInt len;

        TInt nestingLevel;

        TInt allocCount;

        };

    struct _s_align {char c; double d;};

    struct SHeapCellInfo { RHeap* iHeap; TInt iTotalAlloc;	TInt iTotalAllocSize; TInt iTotalFree; TInt iLevelAlloc; SDebugCell* iStranded; };

    enum {ECellAlignment = sizeof(_s_align)-sizeof(double)};

	enum {EFreeCellSize = sizeof(SCell)};

	enum TDebugOp {EWalk=128};

	enum TCellType

		{EGoodAllocatedCell, EGoodFreeCell, EBadAllocatedCellSize, EBadAllocatedCellAddress,

		EBadFreeCellAddress, EBadFreeCellSize};

    enum TDebugHeapId {EUser=0, EKernel=1};

public: // Inlines

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

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

    inline TInt MaxLength() const { return iMaxLength; }

    void CopyObjectDataTo( TMemSpyHeapObjectDataRHeap& aData );

    virtual void AssociateWithKernelChunk( DChunk* aChunk, TLinAddr aAddress, TUint32 aMappingAttributes ) = 0;

    virtual void DisassociateWithKernelChunk() = 0;

    virtual TLinAddr ChunkKernelAddress() const = 0;

    virtual TBool ChunkIsInitialised() const = 0;

    virtual TUint ClientToKernelDelta() const = 0;

    virtual void GetHeapSpecificInfo( TMemSpyHeapInfo& /*aInfo*/ ) const { }

public: // Utilities

    TBool CheckCell( TAny* aCellAddress, TInt aLength ) const;

    static TInt AllocatedCellHeaderSize( TBool aDebugLibrary );

    static TInt FreeCellHeaderSize();

    static TInt CellHeaderSize( const TMemSpyDriverInternalWalkHeapParamsCell& aCell, TBool aDebugEUser );

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;

	SCell iFree;

	TInt iNestingLevel;

	TInt iAllocCount;

    RAllocator::TAllocFail iFailType;

	TInt iFailRate;

	TBool iFailed;

	TInt iFailAllocCount;

	TInt iRand;

	TAny* iTestData;

    TInt ReadFromUserAllocator( DThread& aThread );

    void AssociateWithKernelChunk( DChunk* aChunk, TLinAddr aAddress, TUint32 aMappingAttributes );

    void DisassociateWithKernelChunk();

    TLinAddr ChunkKernelAddress() const;

    TBool ChunkIsInitialised() const;

    TUint ClientToKernelDelta() const;

    TUint iClientToKernelDelta;

class RMemSpyDriverRHeapUser : public RMemSpyDriverRHeapReadFromCopy

public: // New API

    TInt ReadFromUserAllocator( DThread& aThread );

    void DisassociateWithKernelChunk();

    void GetHeapSpecificInfo( TMemSpyHeapInfo& aInfo ) const;

public: // API

    void FailNext();

    void SetKernelHeap( RHeapK& aKernelHeap );

    void Reset();

    void AssociateWithKernelChunk( DChunk* aChunk, TLinAddr aAddress, TUint32 aMappingAttributes );

    void DisassociateWithKernelChunk();

    TLinAddr ChunkKernelAddress() const;

    TBool ChunkIsInitialised() const;

    TUint ClientToKernelDelta() const;

    void GetHeapSpecificInfo( TMemSpyHeapInfo& aInfo ) const;

private: // Internal methods

    void CopyMembersFromKernelHeap();

private: // Internal class

    /**

     * Used when opening the kernel heap

     */

#ifndef __SYMBIAN_KERNEL_HYBRID_HEAP__

    class RHeapKExtended : public RHeapK

        {

    public:

        inline void FailNext()

            {

            SetFailType( RAllocator::EFailNext );

            SetFailRate( 1 );

            ResetFailed();

            ResetFailAllocCount();

            }

        inline void SetFailType( TAllocFail aType ) { iFailType = aType; }

        inline void SetFailRate( TInt aRate ) { iFailRate = aRate; }

        inline void ResetFailed() { iFailed = EFalse; }

        inline void ResetFailAllocCount() { iFailAllocCount = 0; }

        };

#endif

    RHeapK* iKernelHeap;

    DChunk* iChunk;