// Copyright (c) 2000-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "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 __SPACE__

#define __SPACE__

#include "trace.h"

#include "symbols.h"

#include <vector>

#include <map>

// This class define the interface used by the distribution sampler to allocate

// a 'bucket' for a given PC value

//

// This also provide a minimual implementation that allocates all samples to 'other'

class CodeSpace

	{

public:

	enum {KOtherBucket = 0};

	enum TOrder {ERandom, EOrdered, ELinear};

public:

	// the number of buckets (including the 'other' bucket)

	virtual int Size() const;

	// map a PC to a bucket

	virtual int Bucket(PC aPc) const;

	// name a bucket

	virtual const char* Name(int aBucket) const;

	// determine whether the results should be ordered

	virtual TOrder Ordering() const;

	};

class AddressCodeSpace : public CodeSpace

	{

public:

	enum TType {EAbsolute, ERelative};

public:

	AddressCodeSpace(PC aBase, PC aLimit, unsigned aBucketSize, TType aType);

private:

	int Size() const;

	int Bucket(PC aPc) const;

	const char* Name(int aBucket) const;

	TOrder Ordering() const;

private:

	PC iBase;

	unsigned iBucketShift;

	unsigned iBuckets;

	TType iType;

	mutable char iBuffer[10];

	};

class MappedCodeSpace : public CodeSpace

	{

	friend class NonXIP;

	struct Element

		{

		inline Element()

			{}

		inline Element(PC aBase, PC aLimit, const char* aName)

			:iBase(aBase), iLimit(aLimit), iName(aName), iBucket(0), iUnloaded(false)

			{}

		//

		PC iBase;

		PC iLimit;

		const char* iName;

		int iBucket;

		bool iUnloaded;

		};

	typedef std::multimap<PC, Element> Map;

	struct IdNames

		{

		IdNames(int aId, int aIndex) : iId(aId), iIndex(aIndex) {}

		int iId;

		int iIndex;

		};

	typedef std::multimap<const char*, IdNames> NamesMap;

public:

	class Partition : public SymbolFile::Parser

		{

		friend class MappedCodeSpace;

		friend class NonXIP;

	protected:

		inline Partition()

			{}

		inline void Add(PC aBase, PC aLimit, const char* aName)

			{iCodeSpace->Add(aBase, aLimit, aName);}

		inline void Done(PC aFirstPc=0, PC aLastPc=0, int aModuleId=0)

			{iCodeSpace->Done(aFirstPc, aLastPc, aModuleId);}

	private:

		MappedCodeSpace* iCodeSpace;

		};

	friend class Partition;

public:

	MappedCodeSpace();

	MappedCodeSpace(const SymbolFile& aSymbols, Partition& aPartition);

	std::pair<const char*,unsigned> Lookup(PC aPc) const;

protected:

//	MappedCodeSpace();

	void Add(PC aBase, PC aLimit, const char* aName);

	void Done(PC aFirstPc, PC aLastPc, int aModuleId);

private:

	const Element* Find(PC aPc) const;

//

	int Size() const;

	int Bucket(PC aPc) const;

	const char* Name(int aBucket) const;

private:

	Map iMap;

	std::vector<const char*> iNames;

	NamesMap iNamesMap;

	};

class PartitionByFunction : public MappedCodeSpace::Partition

	{

public:

	PartitionByFunction(const char* aFile, const char* aFunction);

private:

	void File(const char* aName);

	bool Symbol(const char* aName, PC aPc, int aLength);

private:

	const char* iFile;

	const char* iFunction;

	bool iActive;

	};

class PartitionByDll : public MappedCodeSpace::Partition

	{

public:

	PartitionByDll(const char* aFile)

		:iMatch(aFile), iLastFile(0), iLastFileAddress(0), iCurrentFile(0)

		{}

private:

	void File(const char* aName);

	bool Symbol(const char* aName, PC aPc, int aLength);

private:

	const char* iMatch;

	const char* iLastFile;

	PC iLastFileAddress;

	const char* iCurrentFile;

	};

#endif // __SPACE__