////////////////////////////////////////////////////////////
//
//     	Declaration of classes
//	ASignalThread, ASignalThreadControl
//
// When a signal arrives, it uses a time slot of a current thread
// (there is no need to block it for any thread), and
// ASignalThread::signal_handler() (long jump, call-back) is executed.
// It stores signal's code in a global fifo and signals a global event.
// When ASignalThread gets its turn,
// it is awaken from the wait on this event and it executes process_signals()
// for all signal codes in this fifo.
// A function catch_signal(signal_code) specifies signals handled this way,
// the rest of signals should be ignored - sigignore(), if possible.
//
// Need to reinstall signal_handler in process_signals(int signal_code ) call
// catch_signal_again(int signal_code);
//
//      Copyright 2001 Alexander Liss
//
////////////////////////////////////////////////////////////

#ifndef __SIGNALTHREAD_H__
#define __SIGNALTHREAD_H__

#include "AThread.h"


	// ASignalThread
	// if a different signal processing is neded
	// override process_signals()
	
class ASignalThread: public AThread
{
friend class ASignalThreadControl;
ASignalThread(const ASignalThread&);		// forbidden
ASignalThread& operator=(const ASignalThread&);	// forbidden
public:
	ASignalThread(){}
	~ASignalThread(){}
	
	int catch_signal(int signal_code);
	int catch_signal_again(int signal_code);
	
	virtual void process_signals(int /* signal_code */){}
	
private:
	int loop(bool& continue_loop);
};
		
	// ASignalThreadControl
	
class ASignalThreadControl: public AThreadControl
{
ASignalThreadControl(const ASignalThreadControl&);		// forbidden
ASignalThreadControl operator=(const ASignalThreadControl&);	// forbidden
public:
	ASignalThreadControl(){}
	~ASignalThreadControl();
	
	int launch_signal_thread(ASignalThread&);	
};


#endif