projects/smsdaemon/PosixSignalDispatcher.h

//
// C++ Interface: %{MODULE}
//
// Description:
//
//
// Author: %{AUTHOR} <%{EMAIL}>, (C) %{YEAR}
//
// Copyright: See COPYING file that comes with this distribution
//
//
#ifndef _PosixSignalDispatcher_h_
#define _PosixSignalDispatcher_h_

#include <stdexcept>

/*
 * Forward declarations.
 */
class PosixSignalHandler ;

/**

@note The signal dispatcher will not interfere with any signals for which
there are no signal handlers attached. Similarly, if a signal handler
function is already attached to a signal that the dispatcher is asked to
administer, that signal handler will be called after all the attached
PosixSignalHandlers.

@todo Make this a singleton class.

*/
class PosixSignalDispatcher
{
public:
    /**
     * This is a singleton class and there is only one instance of this
     * class per process. This instance can be obtained using the
     * GetInstance() method.
     */
    static PosixSignalDispatcher& Instance() ;

    /**
     * Exception thrown when AttachHandler() fails due to a runtime
     * error.
     */
    class CannotAttachHandler : public std::runtime_error
    {
    public:
        CannotAttachHandler( const std::string& whatArg ) :
            runtime_error(whatArg) { }
    } ;

    /**
     * Exception thrown when DetachHandler() fails due to a runtime
     * error.
     */
    class CannotDetachHandler : public std::runtime_error
    {
    public:
        CannotDetachHandler( const std::string& whatArg ) :
            runtime_error(whatArg) { }
    } ;

    /**
     * Attach a signal handler to the signal dispatcher. The signal
     * handler's HandlePosixSignal() method will be called every time
     * the specified signal is received. The signal handler should
     * not be destroyed while it attached to the signal dispatcher.
     * Otherwise, weird things are bound to happen (i.e. "undefined
     * behavior" shall ensue). Make sure you call DetachHandler() from
     * the destructor of the signal handler.
     *
     * If a PosixSignalHandler is attached to the same signal number
     * multiple times, it will be called multiple times. Furthermore,
     * it should also be detached as many times as it was attached
     * before it is destroyed. Otherwise, undefined behavior may result.
     *
     * @param posixSignalNumber The signal number that will result in
     * call to the HandlePosixSignal() method of the signal handler.
     *
     * @param signalHandler The signal handler to be invoked on receiving
     * a posixSignalNumber signal.
     */
    void AttachHandler( const int           posixSignalNumber,
                        PosixSignalHandler& signalHandler )
        throw( CannotAttachHandler ) ;

    /**
     * Detach the specified signal handler from the signal dispatcher.
     * The signal handler will stop being called on receiving the
     * corresponding POSIX signal. If the signal handler is not
     * attached to the signal dispatcher when this method is called
     * then this method has no effect.
     *
     * @param posixSignalNumber The signal number corresponding to
     * the signal handler.
     *
     * @param signalHandler The signal handler to be detached.
     */
    void DetachHandler( const int                 posixSignalNumber,
                        const PosixSignalHandler& signalHandler )
        throw( CannotDetachHandler,
               std::logic_error ) ;
private:
    /**
     * This is a singleton class and the only instances of this class
     * can only be accessed using the Instance() method. This is
     * enforced by making the default constructor a private member
     * disalloweing construction of new instances of this class
     */
    PosixSignalDispatcher() ;

    /**
     * This class cannot be subclassed. We enforce this by making
     * the destructor a private member.
     */
    ~PosixSignalDispatcher() ;

    /**
     * Copying of an instance of this class is not allowed. We
     * enforce this by making the copy constructor and the
     * assignment operator private members.
     */
    PosixSignalDispatcher( const PosixSignalDispatcher& otherInstance ) ;

    /**
     * Copying of an instance of this class is not allowed. We
     * enforce this by making the copy constructor and the
     * assignment operator private members.
     */
    const PosixSignalDispatcher&
    operator=( const PosixSignalDispatcher& otherInstance ) ;
} ;

#endif
1	torben	26	//
2			// C++ Interface: %{MODULE}
3			//
4			// Description:
5			//
6			//
7			// Author: %{AUTHOR} <%{EMAIL}>, (C) %{YEAR}
8			//
9			// Copyright: See COPYING file that comes with this distribution
10			//
11			//
12			#ifndef _PosixSignalDispatcher_h_
13			#define _PosixSignalDispatcher_h_
14
15			#include <stdexcept>
16
17			/*
18			* Forward declarations.
19			*/
20			class PosixSignalHandler ;
21
22			/**
23
24			@note The signal dispatcher will not interfere with any signals for which
25			there are no signal handlers attached. Similarly, if a signal handler
26			function is already attached to a signal that the dispatcher is asked to
27			administer, that signal handler will be called after all the attached
28			PosixSignalHandlers.
29
30			@todo Make this a singleton class.
31
32			*/
33			class PosixSignalDispatcher
34			{
35			public:
36			/**
37			* This is a singleton class and there is only one instance of this
38			* class per process. This instance can be obtained using the
39			* GetInstance() method.
40			*/
41			static PosixSignalDispatcher& Instance() ;
42
43			/**
44			* Exception thrown when AttachHandler() fails due to a runtime
45			* error.
46			*/
47			class CannotAttachHandler : public std::runtime_error
48			{
49			public:
50			CannotAttachHandler( const std::string& whatArg ) :
51			runtime_error(whatArg) { }
52			} ;
53
54			/**
55			* Exception thrown when DetachHandler() fails due to a runtime
56			* error.
57			*/
58			class CannotDetachHandler : public std::runtime_error
59			{
60			public:
61			CannotDetachHandler( const std::string& whatArg ) :
62			runtime_error(whatArg) { }
63			} ;
64
65			/**
66			* Attach a signal handler to the signal dispatcher. The signal
67			* handler's HandlePosixSignal() method will be called every time
68			* the specified signal is received. The signal handler should
69			* not be destroyed while it attached to the signal dispatcher.
70			* Otherwise, weird things are bound to happen (i.e. "undefined
71			* behavior" shall ensue). Make sure you call DetachHandler() from
72			* the destructor of the signal handler.
73			*
74			* If a PosixSignalHandler is attached to the same signal number
75			* multiple times, it will be called multiple times. Furthermore,
76			* it should also be detached as many times as it was attached
77			* before it is destroyed. Otherwise, undefined behavior may result.
78			*
79			* @param posixSignalNumber The signal number that will result in
80			* call to the HandlePosixSignal() method of the signal handler.
81			*
82			* @param signalHandler The signal handler to be invoked on receiving
83			* a posixSignalNumber signal.
84			*/
85			void AttachHandler( const int posixSignalNumber,
86			PosixSignalHandler& signalHandler )
87			throw( CannotAttachHandler ) ;
88
89			/**
90			* Detach the specified signal handler from the signal dispatcher.
91			* The signal handler will stop being called on receiving the
92			* corresponding POSIX signal. If the signal handler is not
93			* attached to the signal dispatcher when this method is called
94			* then this method has no effect.
95			*
96			* @param posixSignalNumber The signal number corresponding to
97			* the signal handler.
98			*
99			* @param signalHandler The signal handler to be detached.
100			*/
101			void DetachHandler( const int posixSignalNumber,
102			const PosixSignalHandler& signalHandler )
103			throw( CannotDetachHandler,
104			std::logic_error ) ;
105			private:
106			/**
107			* This is a singleton class and the only instances of this class
108			* can only be accessed using the Instance() method. This is
109			* enforced by making the default constructor a private member
110			* disalloweing construction of new instances of this class
111			*/
112			PosixSignalDispatcher() ;
113
114			/**
115			* This class cannot be subclassed. We enforce this by making
116			* the destructor a private member.
117			*/
118			~PosixSignalDispatcher() ;
119
120			/**
121			* Copying of an instance of this class is not allowed. We
122			* enforce this by making the copy constructor and the
123			* assignment operator private members.
124			*/
125			PosixSignalDispatcher( const PosixSignalDispatcher& otherInstance ) ;
126
127			/**
128			* Copying of an instance of this class is not allowed. We
129			* enforce this by making the copy constructor and the
130			* assignment operator private members.
131			*/
132			const PosixSignalDispatcher&
133			operator=( const PosixSignalDispatcher& otherInstance ) ;
134			} ;
135
136			#endif