--- /dev/null
+
+#if !defined(INCLUDED_SIGNAL_H)
+#define INCLUDED_SIGNAL_H
+
+#include "isignal.h"
+#include "memory/allocator.h"
+#include "debugging/debugging.h"
+#include <iterator>
+
+namespace ListDetail
+{
+ struct ListNodeBase
+ {
+ ListNodeBase* next;
+ ListNodeBase* prev;
+ };
+
+ inline void list_initialise(ListNodeBase& self)
+ {
+ self.next = self.prev = &self;
+ }
+
+ inline void list_swap(ListNodeBase& self, ListNodeBase& other)
+ {
+ ListNodeBase tmp(self);
+ if(other.next == &other)
+ {
+ list_initialise(self);
+ }
+ else
+ {
+ self = other;
+ self.next->prev = self.prev->next = &self;
+ }
+ if(tmp.next == &self)
+ {
+ list_initialise(other);
+ }
+ else
+ {
+ other = tmp;
+ other.next->prev = other.prev->next = &other;
+ }
+ }
+
+ inline void node_link(ListNodeBase* node, ListNodeBase* next)
+ {
+ node->next = next;
+ node->prev = next->prev;
+ next->prev = node;
+ node->prev->next = node;
+ }
+ inline void node_unlink(ListNodeBase* node)
+ {
+ node->prev->next = node->next;
+ node->next->prev = node->prev;
+ }
+
+ template<typename Value>
+ struct ListNode : public ListNodeBase
+ {
+ Value value;
+
+ ListNode(const Value& value) : value(value)
+ {
+ }
+ ListNode* getNext() const
+ {
+ return static_cast<ListNode*>(next);
+ }
+ ListNode* getPrev() const
+ {
+ return static_cast<ListNode*>(prev);
+ }
+ };
+
+ template<typename Type>
+ class NonConstTraits
+ {
+ public:
+ typedef Type value_type;
+ typedef value_type* pointer;
+ typedef value_type& reference;
+
+ template<typename Other>
+ struct rebind
+ {
+ typedef NonConstTraits<Other> other;
+ };
+ };
+
+ template<typename Type>
+ class ConstTraits
+ {
+ public:
+ typedef Type value_type;
+ typedef const value_type* pointer;
+ typedef const value_type& reference;
+
+ template<typename Other>
+ struct rebind
+ {
+ typedef ConstTraits<Other> other;
+ };
+ };
+
+ template<typename Traits>
+ class ListIterator
+ {
+ public:
+ typedef std::bidirectional_iterator_tag iterator_category;
+ typedef std::ptrdiff_t difference_type;
+ typedef difference_type distance_type;
+ typedef typename Traits::value_type value_type;
+ typedef typename Traits::pointer pointer;
+ typedef typename Traits::reference reference;
+
+ private:
+ typedef ListNode<value_type> Node;
+ typedef typename Traits::template rebind<Node>::other NodeTraits;
+ typedef typename NodeTraits::pointer NodePointer;
+ typedef typename Traits::template rebind< Opaque<value_type> >::other OpaqueTraits;
+ typedef typename OpaqueTraits::pointer OpaquePointer;
+ NodePointer m_node;
+
+ void increment()
+ {
+ m_node = m_node->getNext();
+ }
+ void decrement()
+ {
+ m_node = m_node->getPrev();
+ }
+
+
+ public:
+ explicit ListIterator(NodePointer node) : m_node(node)
+ {
+ }
+ explicit ListIterator(OpaquePointer p) : m_node(reinterpret_cast<NodePointer>(p))
+ {
+ }
+
+ NodePointer node()
+ {
+ return m_node;
+ }
+ OpaquePointer opaque() const
+ {
+ return reinterpret_cast<OpaquePointer>(m_node);
+ }
+
+ bool operator==(const ListIterator& other) const
+ {
+ return m_node == other.m_node;
+ }
+ bool operator!=(const ListIterator& other) const
+ {
+ return !operator==(other);
+ }
+ ListIterator& operator++()
+ {
+ increment();
+ return *this;
+ }
+ ListIterator operator++(int)
+ {
+ ListIterator tmp = *this;
+ increment();
+ return tmp;
+ }
+ ListIterator& operator--()
+ {
+ decrement();
+ return *this;
+ }
+ ListIterator operator--(int)
+ {
+ ListIterator tmp = *this;
+ decrement();
+ return tmp;
+ }
+ reference operator*() const
+ {
+ return m_node->value;
+ }
+ pointer operator->() const
+ {
+ return &(operator*());
+ }
+ };
+}
+
+template<typename Value, typename Allocator = DefaultAllocator<Value> >
+class List : private Allocator
+{
+ typedef ListDetail::ListNode<Value> Node;
+ ListDetail::ListNodeBase list;
+ typedef typename Allocator::template rebind<Node>::other NodeAllocator;
+
+ Node* newNode(const Value& value)
+ {
+ return new (NodeAllocator(*this).allocate(1)) Node(value);
+ }
+ void deleteNode(Node* node)
+ {
+ node->~Node();
+ NodeAllocator(*this).deallocate(node, 1);
+ }
+public:
+ typedef Value value_type;
+ typedef ListDetail::ListIterator< ListDetail::NonConstTraits<Value> > iterator;
+ typedef ListDetail::ListIterator< ListDetail::ConstTraits<Value> > const_iterator;
+
+ List()
+ {
+ list_initialise(list);
+ }
+ explicit List(const Allocator& allocator) : Allocator(allocator)
+ {
+ list_initialise(list);
+ }
+ ~List()
+ {
+ for(; list.next != &list;)
+ {
+ Node* node = static_cast<Node*>(list.next);
+ list.next = list.next->next;
+ deleteNode(node);
+ }
+ }
+ iterator begin()
+ {
+ return iterator(static_cast<Node*>(list.next));
+ }
+ iterator end()
+ {
+ return iterator(static_cast<Node*>(&list));
+ }
+ const_iterator begin() const
+ {
+ return const_iterator(static_cast<const Node*>(list.next));
+ }
+ const_iterator end() const
+ {
+ return const_iterator(static_cast<const Node*>(&list));
+ }
+ void push_back(const Value& value)
+ {
+ insert(end(), value);
+ }
+ void pop_back(const Value& value)
+ {
+ erase(--end(), value);
+ }
+ void push_front(const Value& value)
+ {
+ insert(begin(), value);
+ }
+ void pop_front(const Value& value)
+ {
+ erase(begin(), value);
+ }
+ iterator insert(iterator pos, const Value& value)
+ {
+ Node* node = newNode(value);
+ node_link(node, pos.node());
+ return iterator(node);
+ }
+ iterator erase(iterator pos)
+ {
+ Node* node = pos.node();
+ Node* next = node->getNext();
+ node_unlink(node);
+ deleteNode(node);
+ return iterator(next);
+ }
+};
+
+template<typename Functor>
+class SignalBase
+{
+ typedef List<Functor> SignalList;
+ SignalList events;
+
+public:
+
+ typedef Functor handler_type;
+ typedef Handle< Opaque<Functor> > handler_id_type;
+ typedef typename SignalList::iterator iterator;
+ typedef typename SignalList::const_iterator const_iterator;
+ iterator begin()
+ {
+ return events.begin();
+ }
+ iterator end()
+ {
+ return events.end();
+ }
+ const_iterator begin() const
+ {
+ return events.begin();
+ }
+ const_iterator end() const
+ {
+ return events.end();
+ }
+ handler_id_type connectFirst(const Functor& event)
+ {
+ events.push_front(event);
+ return handler_id_type(begin().opaque());
+ }
+ handler_id_type connectLast(const Functor& event)
+ {
+ events.push_back(event);
+ return handler_id_type((--end()).opaque());
+ }
+ bool isConnected(handler_id_type id)
+ {
+ for(iterator i = begin(); i != end(); ++i)
+ {
+ if(id.get() == i.opaque())
+ {
+ return true;
+ }
+ }
+ return false;
+ }
+ handler_id_type connectBefore(handler_id_type id, const Functor& event)
+ {
+ ASSERT_MESSAGE(isConnected(id), "SignalBase::connectBefore: invalid id");
+ return events.insert(iterator(id.get()), event).opaque();
+ }
+ handler_id_type connectAfter(handler_id_type id, const Functor& event)
+ {
+ ASSERT_MESSAGE(isConnected(id), "SignalBase::connectAfter: invalid id");
+ return events.insert(++iterator(id.get()), event).opaque();
+ }
+ void disconnect(handler_id_type id)
+ {
+ ASSERT_MESSAGE(isConnected(id), "SignalBase::disconnect: invalid id");
+ events.erase(iterator(id.get()));
+ }
+};
+
+///\brief
+// It is safe to disconnect the signal handler currently being invoked.
+template<typename InputIterator, typename SignalHandlerInvoke>
+inline void invokeSignalHandlers(InputIterator first, InputIterator last, SignalHandlerInvoke invoke)
+{
+ while(first != last && invoke(*first++) != SIGNAL_STOP_EMISSION);
+}
+
+class Signal0 : public SignalBase<SignalHandler>
+{
+public:
+ void operator()() const
+ {
+ invokeSignalHandlers(begin(), end(), FunctorInvoke<handler_type>());
+ }
+};
+
+template<typename FirstArgument>
+class Signal1 : public SignalBase< SignalHandler1<FirstArgument> >
+{
+ typedef SignalBase< SignalHandler1<FirstArgument> > Base;
+public:
+ void operator()(FirstArgument a1) const
+ {
+ invokeSignalHandlers(Base::begin(), Base::end(), Functor1Invoke<typename Base::handler_type>(a1));
+ }
+};
+
+template<typename FirstArgument, typename SecondArgument>
+class Signal2 : public SignalBase< SignalHandler2<FirstArgument, SecondArgument> >
+{
+ typedef SignalBase< SignalHandler2<FirstArgument, SecondArgument> > Base;
+public:
+ void operator()(FirstArgument a1, SecondArgument a2) const
+ {
+ invokeSignalHandlers(Base::begin(), Base::end(), Functor2Invoke<typename Base::handler_type>(a1, a2));
+ }
+};
+
+template<typename FirstArgument, typename SecondArgument, typename ThirdArgument>
+class Signal3 : public SignalBase< SignalHandler3<FirstArgument, SecondArgument, ThirdArgument> >
+{
+ typedef SignalBase< SignalHandler3<FirstArgument, SecondArgument, ThirdArgument> > Base;
+public:
+ void operator()(FirstArgument a1, SecondArgument a2, ThirdArgument a3) const
+ {
+ invokeSignalHandlers(Base::begin(), Base::end(), Functor3Invoke<typename Base::handler_type>(a1, a2, a3));
+ }
+};
+
+#endif
projects / voretournament / voretournament.git / blobdiff