haiku.git

/*
 * Copyright 2008-2010, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */
#ifndef PROFILE_RESULT_H
#define PROFILE_RESULT_H


#include <Referenceable.h>

#include <util/DoublyLinkedList.h>

#include "SharedImage.h"


class ProfiledEntity;
class Team;


class ImageProfileResult : public BReferenceable {
public:
								ImageProfileResult(SharedImage* image,
									image_id id);
	virtual						~ImageProfileResult();

	virtual	status_t			Init();

	inline	image_id			ID() const;
	inline	SharedImage*		GetImage() const;

	inline	int64				TotalHits() const;

protected:
			SharedImage*		fImage;
			int64				fTotalHits;
			image_id			fImageID;
};


class ImageProfileResultContainer {
public:
			class Visitor;


public:
	virtual						~ImageProfileResultContainer();

	virtual	int32				CountImages() const = 0;
	virtual	ImageProfileResult*	VisitImages(Visitor& visitor) const = 0;
	virtual	ImageProfileResult*	FindImage(addr_t address,
									addr_t& _loadDelta) const = 0;
};


class ImageProfileResultContainer::Visitor {
public:
	virtual						~Visitor();

	virtual	bool				VisitImage(ImageProfileResult* image) = 0;
};


class ProfileResult : public BReferenceable {
public:
								ProfileResult();
	virtual						~ProfileResult();

	virtual	status_t			Init(ProfiledEntity* entity);

			ProfiledEntity*		Entity() const	{ return fEntity; }

	virtual	void				SetInterval(bigtime_t interval);
			bigtime_t			Interval() const { return fInterval; }

	virtual	void				AddSamples(
									ImageProfileResultContainer* container,
									addr_t* samples,
									int32 sampleCount) = 0;
	virtual	void				AddExpectedTicks(int32 expected) = 0;
	virtual	void				AddDroppedTicks(int32 dropped) = 0;
	virtual	void				PrintResults(
									ImageProfileResultContainer* container) = 0;

	virtual status_t			GetImageProfileResult(SharedImage* image,
									image_id id,
									ImageProfileResult*& _imageResult) = 0;

protected:
			template<typename ImageProfileResultType>
			int32				GetHitImages(
									ImageProfileResultContainer* container,
									ImageProfileResultType** images) const;

protected:
			ProfiledEntity*		fEntity;
			bigtime_t			fInterval;
};


// #pragma mark - ImageProfileResult


image_id
ImageProfileResult::ID() const
{
	return fImageID;
}


SharedImage*
ImageProfileResult::GetImage() const
{
	return fImage;
}


int64
ImageProfileResult::TotalHits() const
{
	return fTotalHits;
}


// #pragma mark - ProfileResult


template<typename ImageProfileResultType>
int32
ProfileResult::GetHitImages(ImageProfileResultContainer* container,
	ImageProfileResultType** images) const
{
	struct Visitor : ImageProfileResultContainer::Visitor {
		ImageProfileResultType**	images;
		int32						imageCount;

		virtual bool VisitImage(ImageProfileResult* image)
		{
			if (image->TotalHits() > 0) {
				images[imageCount++]
					= static_cast<ImageProfileResultType*>(image);
			}
			return false;
		}
	} visitor;

	visitor.images = images;
	visitor.imageCount = 0;

	container->VisitImages(visitor);

	return visitor.imageCount;
}


#endif	// PROFILE_RESULT_H