remove RSA's md4.c, replace by DP's
[xonotic/netradiant.git] / libs / signal / signal.h
1
2 #if !defined(INCLUDED_SIGNAL_H)
3 #define INCLUDED_SIGNAL_H
4
5 #include "isignal.h"
6 #include "memory/allocator.h"
7 #include "debugging/debugging.h"
8 #include <iterator>
9
10 namespace ListDetail
11 {
12   struct ListNodeBase
13   {
14     ListNodeBase* next;
15     ListNodeBase* prev;
16   };
17
18   inline void list_initialise(ListNodeBase& self)
19   {
20     self.next = self.prev = &self;
21   }
22
23   inline void list_swap(ListNodeBase& self, ListNodeBase& other)
24   {
25     ListNodeBase tmp(self);
26     if(other.next == &other)
27     {
28       list_initialise(self);
29     }
30     else
31     {
32       self = other;
33       self.next->prev = self.prev->next = &self;
34     }
35     if(tmp.next == &self)
36     {
37       list_initialise(other);
38     }
39     else
40     {
41       other = tmp;
42       other.next->prev = other.prev->next = &other;
43     }
44   }
45
46   inline void node_link(ListNodeBase* node, ListNodeBase* next)
47   {
48     node->next = next;
49     node->prev = next->prev;
50     next->prev = node;
51     node->prev->next = node;
52   }
53   inline void node_unlink(ListNodeBase* node)
54   {
55     node->prev->next = node->next;
56     node->next->prev = node->prev;
57   }
58
59   template<typename Value>
60   struct ListNode : public ListNodeBase
61   {
62     Value value;
63
64     ListNode(const Value& value) : value(value) 
65     {
66     }
67     ListNode* getNext() const
68     {
69       return static_cast<ListNode*>(next);
70     }
71     ListNode* getPrev() const
72     {
73       return static_cast<ListNode*>(prev);
74     }
75   };
76
77   template<typename Type>
78   class NonConstTraits
79   {
80   public:
81     typedef Type value_type;
82     typedef value_type* pointer;
83     typedef value_type& reference;
84
85     template<typename Other>
86     struct rebind
87     {
88       typedef NonConstTraits<Other> other;
89     };
90   };
91
92   template<typename Type>
93   class ConstTraits
94   {
95   public:
96     typedef Type value_type;
97     typedef const value_type* pointer;
98     typedef const value_type& reference;
99
100     template<typename Other>
101     struct rebind
102     {
103       typedef ConstTraits<Other> other;
104     };
105   };
106
107   template<typename Traits>
108   class ListIterator
109   {
110   public:
111     typedef std::bidirectional_iterator_tag iterator_category;
112     typedef std::ptrdiff_t difference_type;
113     typedef difference_type distance_type;
114     typedef typename Traits::value_type value_type;
115     typedef typename Traits::pointer pointer;
116     typedef typename Traits::reference reference;
117
118   private:
119     typedef ListNode<value_type> Node;
120     typedef typename Traits::template rebind<Node>::other NodeTraits;
121     typedef typename NodeTraits::pointer NodePointer;
122     typedef typename Traits::template rebind< Opaque<value_type> >::other OpaqueTraits;
123     typedef typename OpaqueTraits::pointer OpaquePointer;
124     NodePointer m_node;
125
126     void increment()
127     {
128       m_node = m_node->getNext();
129     }
130     void decrement()
131     {
132       m_node = m_node->getPrev();
133     }
134
135
136  public:
137    explicit ListIterator(NodePointer node) : m_node(node)
138     {
139     }
140     explicit ListIterator(OpaquePointer p) : m_node(reinterpret_cast<NodePointer>(p))
141     {
142     }
143
144     NodePointer node()
145     {
146       return m_node;
147     }
148     OpaquePointer opaque() const
149     {
150       return reinterpret_cast<OpaquePointer>(m_node);
151     }
152
153     bool operator==(const ListIterator& other) const
154     {
155       return m_node == other.m_node;
156     }
157     bool operator!=(const ListIterator& other) const
158     {
159       return !operator==(other);
160     }
161     ListIterator& operator++()
162     {
163       increment();
164       return *this;
165     }
166     ListIterator operator++(int)
167     {
168       ListIterator tmp = *this;
169       increment();
170       return tmp;
171     }
172     ListIterator& operator--()
173     {
174       decrement();
175       return *this;
176     }
177     ListIterator operator--(int)
178     {
179       ListIterator tmp = *this;
180       decrement();
181       return tmp;
182     }
183     reference operator*() const
184     {
185       return m_node->value;
186     }
187     pointer operator->() const
188     {
189       return &(operator*());
190     }
191   };
192 }
193
194 template<typename Value, typename Allocator = DefaultAllocator<Value> >
195 class List : private Allocator
196 {
197   typedef ListDetail::ListNode<Value> Node;
198   ListDetail::ListNodeBase list;
199   typedef typename Allocator::template rebind<Node>::other NodeAllocator;
200
201   Node* newNode(const Value& value)
202   {
203     return new (NodeAllocator(*this).allocate(1)) Node(value);
204   }
205   void deleteNode(Node* node)
206   {
207     node->~Node();
208     NodeAllocator(*this).deallocate(node, 1);
209   }
210 public:
211   typedef Value value_type;
212   typedef ListDetail::ListIterator< ListDetail::NonConstTraits<Value> > iterator;
213   typedef ListDetail::ListIterator< ListDetail::ConstTraits<Value> > const_iterator;
214
215   List()
216   {
217     list_initialise(list);
218   }
219   explicit List(const Allocator& allocator) : Allocator(allocator)
220   {
221     list_initialise(list);
222   }
223   ~List()
224   {
225     for(; list.next != &list;)
226     {
227       Node* node = static_cast<Node*>(list.next);
228       list.next = list.next->next;
229       deleteNode(node);
230     }
231   }
232   iterator begin()
233   {
234     return iterator(static_cast<Node*>(list.next));
235   }
236   iterator end()
237   {
238     return iterator(static_cast<Node*>(&list));
239   }
240   const_iterator begin() const
241   {
242     return const_iterator(static_cast<const Node*>(list.next));
243   }
244   const_iterator end() const
245   {
246     return const_iterator(static_cast<const Node*>(&list));
247   }
248   void push_back(const Value& value)
249   {
250     insert(end(), value);
251   }
252   void pop_back(const Value& value)
253   {
254     erase(--end(), value);
255   }
256   void push_front(const Value& value)
257   {
258     insert(begin(), value);
259   }
260   void pop_front(const Value& value)
261   {
262     erase(begin(), value);
263   }
264   iterator insert(iterator pos, const Value& value)
265   {
266     Node* node = newNode(value);
267     node_link(node, pos.node());
268     return iterator(node);
269   }
270   iterator erase(iterator pos)
271   {
272     Node* node = pos.node();
273     Node* next = node->getNext();
274     node_unlink(node);
275     deleteNode(node);
276     return iterator(next);
277   }
278 };
279
280 template<typename Functor>
281 class SignalBase
282 {
283   typedef List<Functor> SignalList;
284   SignalList events;
285
286 public:
287
288   typedef Functor handler_type;
289   typedef Handle< Opaque<Functor> > handler_id_type;
290   typedef typename SignalList::iterator iterator;
291   typedef typename SignalList::const_iterator const_iterator;
292   iterator begin()
293   {
294     return events.begin();
295   }
296   iterator end()
297   {
298     return events.end();
299   }
300   const_iterator begin() const
301   {
302     return events.begin();
303   }
304   const_iterator end() const
305   {
306     return events.end();
307   }
308   handler_id_type connectFirst(const Functor& event)
309   {
310     events.push_front(event);
311     return handler_id_type(begin().opaque());
312   }
313   handler_id_type connectLast(const Functor& event)
314   {
315     events.push_back(event);
316     return handler_id_type((--end()).opaque());
317   }
318   bool isConnected(handler_id_type id)
319   {
320     for(iterator i = begin(); i != end(); ++i)
321     {
322       if(id.get() == i.opaque())
323       {
324         return true;
325       }
326     }
327     return false;
328   }
329   handler_id_type connectBefore(handler_id_type id, const Functor& event)
330   {
331     ASSERT_MESSAGE(isConnected(id), "SignalBase::connectBefore: invalid id");
332     return events.insert(iterator(id.get()), event).opaque();
333   }
334   handler_id_type connectAfter(handler_id_type id, const Functor& event)
335   {
336     ASSERT_MESSAGE(isConnected(id), "SignalBase::connectAfter: invalid id");
337     return events.insert(++iterator(id.get()), event).opaque();
338   }
339   void disconnect(handler_id_type id)
340   {
341     ASSERT_MESSAGE(isConnected(id), "SignalBase::disconnect: invalid id");
342     events.erase(iterator(id.get()));
343   }
344 };
345
346 ///\brief
347 // It is safe to disconnect the signal handler currently being invoked.
348 template<typename InputIterator, typename SignalHandlerInvoke>
349 inline void invokeSignalHandlers(InputIterator first, InputIterator last, SignalHandlerInvoke invoke)
350 {
351   while(first != last && invoke(*first++) != SIGNAL_STOP_EMISSION);
352 }
353
354 class Signal0 : public SignalBase<SignalHandler>
355 {
356 public:
357   void operator()() const
358   {
359     invokeSignalHandlers(begin(), end(), FunctorInvoke<handler_type>());
360   }
361 };
362
363 template<typename FirstArgument>
364 class Signal1 : public SignalBase< SignalHandler1<FirstArgument> >
365 {
366   typedef SignalBase< SignalHandler1<FirstArgument> > Base;
367 public:
368   void operator()(FirstArgument a1) const
369   {
370     invokeSignalHandlers(Base::begin(), Base::end(), Functor1Invoke<typename Base::handler_type>(a1));
371   }
372 };
373
374 template<typename FirstArgument, typename SecondArgument>
375 class Signal2 : public SignalBase< SignalHandler2<FirstArgument, SecondArgument> >
376 {
377   typedef SignalBase< SignalHandler2<FirstArgument, SecondArgument> > Base;
378 public:
379   void operator()(FirstArgument a1, SecondArgument a2) const
380   {
381     invokeSignalHandlers(Base::begin(), Base::end(), Functor2Invoke<typename Base::handler_type>(a1, a2));
382   }
383 };
384
385 template<typename FirstArgument, typename SecondArgument, typename ThirdArgument>
386 class Signal3 : public SignalBase< SignalHandler3<FirstArgument, SecondArgument, ThirdArgument> >
387 {
388   typedef SignalBase< SignalHandler3<FirstArgument, SecondArgument, ThirdArgument> > Base;
389 public:
390   void operator()(FirstArgument a1, SecondArgument a2, ThirdArgument a3) const
391   {
392     invokeSignalHandlers(Base::begin(), Base::end(), Functor3Invoke<typename Base::handler_type>(a1, a2, a3));
393   }
394 };
395
396 #endif