signal.h

Go to the documentation of this file.

#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()));
    }
};

// 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