remove RSA's md4.c, replace by DP's
[xonotic/netradiant.git] / libs / signal / isignal.h
1
2 #if !defined(INCLUDED_ISIGNAL_H)
3 #define INCLUDED_ISIGNAL_H
4
5 #include "generic/callback.h"
6 #include "signal/signalfwd.h"
7
8 class SignalHandlerResult
9 {
10   bool value;
11 public:
12   explicit SignalHandlerResult(bool value) : value(value)
13   {
14   }
15   bool operator==(SignalHandlerResult other) const
16   {
17     return value == other.value;
18   }
19   bool operator!=(SignalHandlerResult other) const
20   {
21     return !operator==(other);
22   }
23 };
24
25 const SignalHandlerResult SIGNAL_CONTINUE_EMISSION = SignalHandlerResult(false);
26 const SignalHandlerResult SIGNAL_STOP_EMISSION = SignalHandlerResult(true);
27
28 template<typename Caller> 
29 class SignalHandlerCaller1
30 {
31 public:
32   typedef typename Caller::first_argument_type first_argument_type;
33   typedef SignalHandlerResult result_type;
34   static result_type call(first_argument_type a1)
35   {
36     Caller::call(a1);
37     return SIGNAL_CONTINUE_EMISSION;
38   }
39 };
40
41 template<typename Caller> 
42 class SignalHandlerCaller2
43 {
44 public:
45   typedef typename Caller::first_argument_type first_argument_type;
46   typedef typename Caller::second_argument_type second_argument_type;
47   typedef SignalHandlerResult result_type;
48   static result_type call(first_argument_type a1, second_argument_type a2)
49   {
50     Caller::call(a1, a2);
51     return SIGNAL_CONTINUE_EMISSION;
52   }
53 };
54
55 template<typename Caller> 
56 class SignalHandlerCaller3
57 {
58 public:
59   typedef typename Caller::first_argument_type first_argument_type;
60   typedef typename Caller::second_argument_type second_argument_type;
61   typedef typename Caller::third_argument_type third_argument_type;
62   typedef SignalHandlerResult result_type;
63   static result_type call(first_argument_type a1, second_argument_type a2, third_argument_type a3)
64   {
65     Caller::call(a1, a2, a3);
66     return SIGNAL_CONTINUE_EMISSION;
67   }
68 };
69
70 template<typename Caller> 
71 class SignalHandlerCaller4
72 {
73 public:
74   typedef typename Caller::first_argument_type first_argument_type;
75   typedef typename Caller::second_argument_type second_argument_type;
76   typedef typename Caller::third_argument_type third_argument_type;
77   typedef typename Caller::fourth_argument_type fourth_argument_type;
78   typedef SignalHandlerResult result_type;
79   static result_type call(first_argument_type a1, second_argument_type a2, third_argument_type a3, fourth_argument_type a4)
80   {
81     Caller::call(a1, a2, a3, a4);
82     return SIGNAL_CONTINUE_EMISSION;
83   }
84 };
85
86 class SignalHandler : public Callback0<SignalHandlerResult>
87 {
88 public:
89   template<typename Caller>
90   SignalHandler(const BindFirstOpaque<Caller>& caller)
91     : Callback0<SignalHandlerResult>(BindFirstOpaque<typename TypeEqual<
92       SignalHandlerResult,
93       Caller,
94       SignalHandlerCaller1<Caller>,
95       typename Caller::result_type
96     >::type>(caller.getBound()))
97   {
98   }
99 };
100
101 template<typename Caller>
102 inline SignalHandler makeSignalHandler(const BindFirstOpaque<Caller>& caller)
103 {
104   return SignalHandler(caller);
105 }
106 template<typename Caller>
107 inline SignalHandler makeSignalHandler(const Caller& caller, typename Caller::first_argument_type callee)
108 {
109   return SignalHandler(BindFirstOpaque<Caller>(callee));
110 }
111
112
113 template<typename FirstArgument>
114 class SignalHandler1 : public Callback1<FirstArgument, SignalHandlerResult>
115 {
116 public:
117   template<typename Caller>
118   SignalHandler1(const BindFirstOpaque1<Caller>& caller)
119     : Callback1<FirstArgument, SignalHandlerResult>(BindFirstOpaque1<typename TypeEqual<
120       SignalHandlerResult,
121       Caller,
122       SignalHandlerCaller2<Caller>,
123       typename Caller::result_type
124     >::type>(caller.getBound()))
125   {
126   }
127 };
128
129 template<typename Caller>
130 inline SignalHandler1<typename Caller::second_argument_type> makeSignalHandler1(const BindFirstOpaque1<Caller>& caller)
131 {
132   return SignalHandler1<typename Caller::second_argument_type>(caller);
133 }
134 template<typename Caller>
135 inline SignalHandler1<typename Caller::second_argument_type> makeSignalHandler1(const Caller& caller, typename Caller::first_argument_type callee)
136 {
137   return SignalHandler1<typename Caller::second_argument_type>(BindFirstOpaque1<Caller>(callee));
138 }
139
140
141 template<typename FirstArgument, typename SecondArgument>
142 class SignalHandler2 : public Callback2<FirstArgument, SecondArgument, SignalHandlerResult>
143 {
144 public:
145   template<typename Caller>
146   SignalHandler2(const BindFirstOpaque2<Caller>& caller)
147     : Callback2<FirstArgument, SecondArgument, SignalHandlerResult>(BindFirstOpaque2<typename TypeEqual<
148       SignalHandlerResult,
149       Caller,
150       SignalHandlerCaller3<Caller>,
151       typename Caller::result_type
152     >::type>(caller.getBound()))
153   {
154   }
155 };
156
157 template<typename Caller>
158 inline SignalHandler2<
159   typename Caller::second_argument_type,
160   typename Caller::third_argument_type
161 > makeSignalHandler2(const BindFirstOpaque2<Caller>& caller)
162 {
163   return SignalHandler2<
164     typename Caller::second_argument_type,
165     typename Caller::third_argument_type
166   >(caller);
167 }
168 template<typename Caller>
169 inline SignalHandler2<
170   typename Caller::second_argument_type,
171   typename Caller::third_argument_type
172 > makeSignalHandler2(const Caller& caller, typename Caller::first_argument_type callee)
173 {
174   return SignalHandler2<
175     typename Caller::second_argument_type,
176     typename Caller::third_argument_type
177   >(BindFirstOpaque2<Caller>(callee));
178 }
179
180
181 template<typename FirstArgument, typename SecondArgument, typename ThirdArgument>
182 class SignalHandler3 : public Callback3<FirstArgument, SecondArgument, ThirdArgument, SignalHandlerResult>
183 {
184 public:
185   template<typename Caller>
186   SignalHandler3(const BindFirstOpaque3<Caller>& caller)
187     : Callback3<FirstArgument, SecondArgument, ThirdArgument, SignalHandlerResult>(BindFirstOpaque3<typename TypeEqual<
188       SignalHandlerResult,
189       Caller,
190       SignalHandlerCaller4<Caller>,
191       typename Caller::result_type
192     >::type>(caller.getBound()))
193   {
194   }
195 };
196
197 template<typename Caller>
198 inline SignalHandler3<
199   typename Caller::second_argument_type,
200   typename Caller::third_argument_type,
201   typename Caller::fourth_argument_type
202 > makeSignalHandler3(const BindFirstOpaque3<Caller>& caller)
203 {
204   return SignalHandler3<
205     typename Caller::second_argument_type,
206     typename Caller::third_argument_type,
207     typename Caller::fourth_argument_type
208   >(caller);
209 }
210 template<typename Caller>
211 inline SignalHandler3<
212   typename Caller::second_argument_type,
213   typename Caller::third_argument_type,
214   typename Caller::fourth_argument_type
215 > makeSignalHandler3(const Caller& caller, typename Caller::first_argument_type callee)
216 {
217   return SignalHandler3<
218     typename Caller::second_argument_type,
219     typename Caller::third_argument_type,
220     typename Caller::fourth_argument_type
221   >(BindFirstOpaque3<Caller>(callee));
222 }
223
224 #endif