libs/signal/signal.h

#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