-#if !defined(INCLUDED_SIGNAL_H)
+#if !defined( INCLUDED_SIGNAL_H )
#define INCLUDED_SIGNAL_H
#include "isignal.h"
namespace ListDetail
{
- struct ListNodeBase
- {
- ListNodeBase* next;
- ListNodeBase* prev;
- };
+struct ListNodeBase
+{
+ ListNodeBase* next;
+ ListNodeBase* prev;
+};
- inline void list_initialise(ListNodeBase& self)
- {
- self.next = self.prev = &self;
- }
+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 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;
- }
+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;
+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);
- }
- };
+ 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 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 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 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 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;
+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;
+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();
- }
+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))
- {
- }
+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);
- }
+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*());
- }
- };
+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;
+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);
- }
+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;
+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);
- }
+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;
+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()));
- }
+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);
+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>());
- }
+void operator()() const {
+ invokeSignalHandlers( begin(), end(), FunctorInvoke<handler_type>() );
+}
};
template<typename FirstArgument>
class Signal1 : public SignalBase< SignalHandler1<FirstArgument> >
{
- typedef SignalBase< SignalHandler1<FirstArgument> > Base;
+typedef SignalBase< SignalHandler1<FirstArgument> > Base;
public:
- void operator()(FirstArgument a1) const
- {
- invokeSignalHandlers(Base::begin(), Base::end(), Functor1Invoke<typename Base::handler_type>(a1));
- }
+void operator()( FirstArgument a1 ) const {
+ invokeSignalHandlers( Base::begin(), Base::end(), FunctorInvoke<typename Base::handler_type>( a1 ) );
+}
};
template<typename FirstArgument, typename SecondArgument>
class Signal2 : public SignalBase< SignalHandler2<FirstArgument, SecondArgument> >
{
- typedef SignalBase< SignalHandler2<FirstArgument, SecondArgument> > Base;
+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));
- }
+void operator()( FirstArgument a1, SecondArgument a2 ) const {
+ invokeSignalHandlers( Base::begin(), Base::end(), FunctorInvoke<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;
+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));
- }
+void operator()( FirstArgument a1, SecondArgument a2, ThirdArgument a3 ) const {
+ invokeSignalHandlers( Base::begin(), Base::end(), FunctorInvoke<typename Base::handler_type>( a1, a2, a3 ) );
+}
};
#endif
projects / xonotic / netradiant.git / blobdiff