signals 2.0

signal_base.cpp

@@ -0,0 +1,151 @@
+#include <cassert>
+#include "signal_base.h"
+
+signal_base::signal_base() : head(0), tail(0)
+{
+	// empty
+}
+
+signal_base::~signal_base()
+{
+	// clear the list
+	clear_list();
+}
+
+bool signal_base::bind(const slot_base& slot)
+{
+	// add it to our signal list
+	return add_to_list(slot);
+}
+
+bool signal_base::unbind(const slot_base& slot)
+{
+	// look for corresponding list_node in list
+	list_node* n = find_in_list(slot);
+
+	// see if we found a match
+	if ( !n )
+	{
+		return false; // no match found
+	}
+
+	// take it out of the linked list
+	remove_from_list(n);
+
+	// free it
+	delete n;
+
+	// found a match, success
+	return true;
+}
+
+void signal_base::clear_list()
+{
+	// start at head
+	list_node* cur = head;
+
+	// iterate
+	while ( cur )
+	{
+		// save off next so we can safely delete
+		list_node* next = cur->next;
+
+		// free
+		delete cur;
+
+		// advance
+		cur = next;
+	}
+
+	// reset head & tail
+	head = tail = 0;
+}
+
+signal_base::list_node* signal_base::find_in_list(const slot_base& slot) const
+{
+	// start search at head of list
+	list_node* cur  = head;
+
+	// search list for slot
+	while ( cur )
+	{
+		// see if this is a match
+		if ( cur->slot == slot )
+		{
+			// we have a match, return it
+			return cur;
+		}
+
+		// advance to next in list
+		cur = cur->next;
+	}
+
+	// no match
+	return 0;
+}
+
+bool signal_base::add_to_list(const slot_base& slot)
+{
+	// a sanity check
+	assert((head && tail) || (!head && !tail));
+
+	// make a new list_node to hold this slot in the list
+	list_node* n = new list_node;
+	if ( !n )
+	{
+		return false;
+	}
+
+	// initialize new list_node
+	n->slot = slot; // copy slot into list_node
+	n->prev = tail; // prev is tail because we'll put this list_node behind it (i.e. the new tail)
+	n->next = 0;    // next is 0 because we'll put this list_node on the tail
+
+	// add to tail
+	if ( tail )
+	{
+		// tail exists, just append
+		tail->next = n; // insert item after current tail
+		tail       = n; // now have a new tail
+	}
+	else
+	{
+		// list is currently empty, add this new list_node
+		head = tail = n; // now have a single list_node, which is also both the head and tail
+	}
+	
+	return true;
+}
+
+void signal_base::remove_from_list(list_node* n)
+{
+	// do a little sanity checking
+	assert((head && tail) || (!head && !tail));
+	assert(n->prev == 0 || n->prev->next == n);
+	assert(n->next == 0 || n->next->prev == n);
+
+	// if this is the head, set the new head
+	if ( n == head )
+	{
+		head = n->next;
+	}
+
+	// if this is the tail, set the new tail
+	if ( n == tail )
+	{
+		tail = n->prev;
+	}
+
+	// set list to skip over this list_node
+	if ( n->prev )
+	{
+		n->prev->next = n->next;
+	}
+	if ( n->next )
+	{
+		n->next->prev = n->prev;
+	}
+}
+
+
+