#ifndef __GENERIC_THREAD_H__
#define __GENERIC_THREAD_H__


#include <Message.h>


class GenericThread
{
public:
							GenericThread(const char* 
								thread_name = "generic_thread",
								int32 priority = B_NORMAL_PRIORITY,
								BMessage* message = NULL);
	virtual					~GenericThread();

			BMessage*		GetDataStore();
			void			SetDataStore(BMessage* message);

			status_t		Start();
			status_t		Pause(bool doBlock = TRUE, bigtime_t timeout = 0);
			void			Quit();
			bool			IsPaused();
			bool			HasQuitBeenRequested();
			
			status_t		Suspend();
			status_t		Resume();
			status_t		Kill();
			
			void			ExitWithReturnValue(status_t returnValue);
			status_t		SetExitCallback(void (*callback)(void*),
								void* data);
			status_t		WaitForThread(status_t* exitValue);
			
			status_t		Rename(char* name);
			
			status_t		SendData(int32 code, void* buffer,
								size_t bufferSize);
			int32			ReceiveData(thread_id* sender, void* buffer,
								size_t bufferSize);
			bool			HasData();
			
			status_t		SetPriority(int32 newPriority);

			void			Snooze(bigtime_t microseconds);
			void			SnoozeUntil(bigtime_t microseconds,
								int timebase = B_SYSTEM_TIMEBASE);
				
			status_t		GetInfo(thread_info* threadInfo);
			thread_id		GetThread();
			team_id			GetTeam();
			char*			GetName();
			thread_state	GetState();
			sem_id			GetSemaphore();
			int32			GetPriority();
			bigtime_t		GetUserTime();
			bigtime_t		GetKernelTime();
			void*			GetStackBase();
			void*			GetStackEnd();

protected:
	virtual	status_t		ThreadFunction();
	virtual	status_t		ThreadStartup();
	virtual	status_t		ExecuteUnit();
	virtual	status_t		ThreadShutdown();
	
	virtual	void			ThreadStartupFailed(status_t status);
	virtual	void			ExecuteUnitFailed(status_t status);
	virtual	void			ThreadShutdownFailed(status_t status);

			void			BeginUnit();
			void			EndUnit();

			BMessage*		fThreadDataStore;
				
private:
	static	status_t		_ThreadFunction(void* simpleThreadPtr);
		
			thread_id		fThreadId;
			sem_id			fExecuteUnitSem;
			bool			fQuitRequested;
			bool			fThreadIsPaused;

};

#endif	// __GENERIC_THREAD_H__