// license: public domain
// authors: jonas.sundstrom@kirilla.com
#ifndef _GENERIC_THREAD_H
#define _GENERIC_THREAD_H


#include <OS.h>
#include <Message.h>


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

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

			status_t			Start(void);
			status_t			Pause(bool shouldBlock = true,
									bigtime_t timeout = 0);
			void				Quit(void);
			bool				IsPaused(void);
			bool				HasQuitBeenRequested(void);

			status_t			Suspend(void);
			status_t			Resume(void);
			status_t			Kill(void);

			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 size);
			int32				ReceiveData(thread_id* sender, void* buffer,
									size_t size);
			bool				HasData(void);

			status_t			SetPriority(int32 priority);

			void				Snooze(bigtime_t delay);
			void				SnoozeUntil(bigtime_t delay,
									int timeBase = B_SYSTEM_TIMEBASE);

			status_t			GetInfo(thread_info* info);
			thread_id			GetThread(void);
			team_id				GetTeam(void);
			char*				GetName(void);
			thread_state		GetState(void);
			sem_id				GetSemaphore(void);
			int32				GetPriority(void);
			bigtime_t			GetUserTime(void);
			bigtime_t			GetKernelTime(void);
			void*				GetStackBase(void);
			void*				GetStackEnd(void);

protected:
	virtual	status_t			ThreadFunction(void);
	virtual	status_t			ThreadStartup(void);
	virtual	status_t			ExecuteUnit(void);
	virtual	status_t			ThreadShutdown(void);

	virtual	void				ThreadStartupFailed(status_t status);
	virtual	void				ExecuteUnitFailed(status_t status);
	virtual	void				ThreadShutdownFailed(status_t status);

			void				BeginUnit(void);
									// acquire m_execute_cycle
			void				EndUnit(void);
									// release m_execute_cycle

		BMessage*				fThreadDataStore;

private:
		static	 status_t		private_thread_function(void* pointer);

				thread_id		fThreadId;

				sem_id			fExecuteUnit;
									// acquire/relase within tread_function...
									// for Pause()

				bool			fQuitRequested;
				bool			fThreadIsPaused;
};


#endif	// _GENERIC_THREAD_H