haiku.git

/*
 * Copyright (c) 1999-2000, Eric Moon.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions, and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions, and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * 3. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */


// BasicThread.h
// based on ThreadPrimitive from the Be Newsletter
//
// HISTORY
//   e.moon		12jul99: now in cortex namespace
//   - The stop mechanism has changed a bit; it's now up to the
//     run() implementation to indicate that it has completed by
//     calling done().
//                    
//   e.moon		11may99: brought into the beDub support kit

#ifndef __BasicThread_H__
#define __BasicThread_H__

#include <Debug.h>
#include <KernelKit.h>
#include <String.h>


#include "cortex_defs.h"
__BEGIN_CORTEX_NAMESPACE

class BasicThread {

protected:				// hooks
	virtual void run()=0;

public:					// ctor/dtor
	virtual ~BasicThread() {

		if(m_thread > 0) {
			kill();
		}
	}
	
	BasicThread(
		int32 priority=B_LOW_PRIORITY,
		const char* name=0,
		bool killOnDelete=true) :
		
		m_thread(-1),
		m_priority(priority),
		m_name(name ? name : "BasicThread [?]"),
		m_running(false),
		m_stopping(false) {}
	
	bool running() const { return m_running; }
	bool stopping() const { return m_stopping; }
	
	thread_id thread() const { return m_thread; }
	const char* name() const { return m_name.String(); }
		
public:					// operations
	status_t start() {

		if(running())
			return B_ERROR;
			
		m_thread = spawn_thread(
			&BasicThread::Run,
			m_name.String(),
			m_priority,
			this);

		status_t err = resume_thread(m_thread);
		if(err == B_OK)
			m_running = true;
		return err;
	}

	// reworked 12jul99 e.moon
	status_t stop(bool wait=true) {

		if(!running())
			return B_ERROR;

		thread_id thread = m_thread; // +++++ is this safe?
		if(thread <= 0)
			return B_OK;

		// signal stop
		m_stopping = true;
		
		if(wait) {
			status_t ret;
			while(wait_for_thread(thread, &ret) == B_INTERRUPTED) {
				PRINT(("stopping thread %" B_PRId32 ": B_INTERRUPTED\n",
					thread));
			}
		}
		
		return B_OK;
	}

protected:					// internal methods	

	// Blunt force trauma.
	// added 12jul99 e.moon
	status_t kill() {
		if(m_thread <= 0)
			return B_ERROR;

		kill_thread(m_thread);
		
		m_thread = -1;
		m_running = false;
		m_stopping = false;
		return B_OK;
	}

	// Call this method at the end of your run() implementation.
	// added 12jul99 e.moon
	void done() {
		m_running = false;
		m_stopping = false;
		m_thread = -1;
	}

private:						// static impl. methods
	static status_t Run(void* user) {

		BasicThread* instance = static_cast<BasicThread*>(user);
		instance->run();
		return B_OK;
	}
	
private:						// impl members
	thread_id		m_thread;
	int32				m_priority;
	BString			m_name;

	bool					m_running;	
	bool					m_stopping;
};

__END_CORTEX_NAMESPACE
#endif /* __BasicThread_H__ */