Use "tail" and "head" terminology instead of "src_port" and "dst_port".

Use the same types for connect() and disconnect() parameters.


git-svn-id: http://svn.drobilla.net/lad/trunk/ingen@4292 a436a847-0d15-0410-975c-d299462d15a1

15 files changed, 113 insertions, 113 deletions

diff --git a/src/server/ClientBroadcaster.hpp b/src/server/ClientBroadcaster.hpp
index 3e9b7d0f..c095b960 100644
--- a/src/server/ClientBroadcaster.hpp
+++ b/src/server/ClientBroadcaster.hpp
@@ -88,14 +88,14 @@ public:
 		BROADCAST(del, uri);
 	}
 
-	void connect(const Raul::Path& src_port_path,
-	             const Raul::Path& dst_port_path) {
-		BROADCAST(connect, src_port_path, dst_port_path);
+	void connect(const Raul::Path& tail,
+	             const Raul::Path& head) {
+		BROADCAST(connect, tail, head);
 	}
 
-	void disconnect(const Raul::URI& src,
-	                const Raul::URI& dst) {
-		BROADCAST(disconnect, src, dst);
+	void disconnect(const Raul::Path& tail,
+	                const Raul::Path& head) {
+		BROADCAST(disconnect, tail, head);
 	}
 
 	void disconnect_all(const Raul::Path& parent_patch_path,
diff --git a/src/server/ConnectionImpl.cpp b/src/server/ConnectionImpl.cpp
index b53f00fe..d233ab5d 100644
--- a/src/server/ConnectionImpl.cpp
+++ b/src/server/ConnectionImpl.cpp
@@ -44,40 +44,40 @@ namespace Server {
  * This handles both polyphonic and monophonic nodes, transparently to the
  * user (InputPort).
  */
-ConnectionImpl::ConnectionImpl(PortImpl* src_port, PortImpl* dst_port)
-	: _src_port(src_port)
-	, _dst_port(dst_port)
+ConnectionImpl::ConnectionImpl(PortImpl* tail, PortImpl* head)
+	: _tail(tail)
+	, _head(head)
 	, _queue(NULL)
 {
-	assert(src_port);
-	assert(dst_port);
-	assert(src_port != dst_port);
-	assert(src_port->path() != dst_port->path());
+	assert(tail);
+	assert(head);
+	assert(tail != head);
+	assert(tail->path() != head->path());
 
 	if (must_queue())
-		_queue = new Raul::RingBuffer(src_port->buffer_size() * 2);
+		_queue = new Raul::RingBuffer(tail->buffer_size() * 2);
 }
 
 void
 ConnectionImpl::dump() const
 {
-	Raul::debug << _src_port->path() << " -> " << _dst_port->path()
+	Raul::debug << _tail->path() << " -> " << _head->path()
 	            << (must_mix()   ? " (MIX) " : " (DIRECT) ")
 	            << (must_queue() ? " (QUEUE)" : " (NOQUEUE) ")
-	            << "POLY: " << _src_port->poly() << " => " << _dst_port->poly()
+	            << "POLY: " << _tail->poly() << " => " << _head->poly()
 	            << std::endl;
 }
 
 const Raul::Path&
-ConnectionImpl::src_port_path() const
+ConnectionImpl::tail_path() const
 {
-	return _src_port->path();
+	return _tail->path();
 }
 
 const Raul::Path&
-ConnectionImpl::dst_port_path() const
+ConnectionImpl::head_path() const
 {
-	return _dst_port->path();
+	return _head->path();
 }
 
 void
@@ -88,21 +88,21 @@ ConnectionImpl::get_sources(Context& context, uint32_t voice,
 		LV2_Atom obj;
 		_queue->peek(sizeof(LV2_Atom), &obj);
 		boost::intrusive_ptr<Buffer> buf = context.engine().buffer_factory()->get(
-				dst_port()->buffer_type(), sizeof(LV2_Atom) + obj.size);
+				head()->buffer_type(), sizeof(LV2_Atom) + obj.size);
 		void* data = buf->port_data(PortType::ATOM, context.offset());
 		_queue->read(sizeof(LV2_Atom) + obj.size, (LV2_Atom*)data);
 		srcs[num_srcs++] = buf;
 	} else if (must_mix()) {
 		// Mixing down voices: every src voice mixed into every dst voice
-		for (uint32_t v = 0; v < _src_port->poly(); ++v) {
+		for (uint32_t v = 0; v < _tail->poly(); ++v) {
 			assert(num_srcs < max_num_srcs);
-			srcs[num_srcs++] = _src_port->buffer(v).get();
+			srcs[num_srcs++] = _tail->buffer(v).get();
 		}
 	} else {
 		// Matching polyphony: each src voice mixed into corresponding dst voice
-		assert(_src_port->poly() == _dst_port->poly());
+		assert(_tail->poly() == _head->poly());
 		assert(num_srcs < max_num_srcs);
-		srcs[num_srcs++] = _src_port->buffer(voice).get();
+		srcs[num_srcs++] = _tail->buffer(voice).get();
 	}
 }
 
@@ -112,9 +112,9 @@ ConnectionImpl::queue(Context& context)
 	if (!must_queue())
 		return;
 
-	const Ingen::Shared::URIs& uris = _src_port->bufs().uris();
+	const Ingen::Shared::URIs& uris = _tail->bufs().uris();
 
-	boost::intrusive_ptr<Buffer> src_buf = _src_port->buffer(0);
+	boost::intrusive_ptr<Buffer> src_buf = _tail->buffer(0);
 	if (src_buf->atom()->type != uris.atom_Sequence) {
 		Raul::error << "Queued connection but source is not a Sequence" << std::endl;
 		return;
@@ -124,7 +124,7 @@ ConnectionImpl::queue(Context& context)
 	LV2_ATOM_SEQUENCE_FOREACH(seq, ev) {
 		_queue->write(sizeof(LV2_Atom) + ev->body.size, &ev->body);
 		context.engine().message_context()->run(
-			_dst_port->parent_node(), context.start() + ev->time.frames);
+			_head->parent_node(), context.start() + ev->time.frames);
 
 	}
 }
@@ -134,25 +134,25 @@ ConnectionImpl::buffer(uint32_t voice) const
 {
 	assert(!must_mix());
 	assert(!must_queue());
-	assert(_src_port->poly() == 1 || _src_port->poly() > voice);
-	if (_src_port->poly() == 1) {
-		return _src_port->buffer(0);
+	assert(_tail->poly() == 1 || _tail->poly() > voice);
+	if (_tail->poly() == 1) {
+		return _tail->buffer(0);
 	} else {
-		return _src_port->buffer(voice);
+		return _tail->buffer(voice);
 	}
 }
 
 bool
 ConnectionImpl::must_mix() const
 {
-	return _src_port->poly() > _dst_port->poly();
+	return _tail->poly() > _head->poly();
 }
 
 bool
 ConnectionImpl::must_queue() const
 {
-	return _src_port->parent_node()->context()
-		!= _dst_port->parent_node()->context();
+	return _tail->parent_node()->context()
+		!= _head->parent_node()->context();
 }
 
 bool
diff --git a/src/server/ConnectionImpl.hpp b/src/server/ConnectionImpl.hpp
index 3dc794db..a93674b6 100644
--- a/src/server/ConnectionImpl.hpp
+++ b/src/server/ConnectionImpl.hpp
@@ -60,13 +60,13 @@ class ConnectionImpl
 	boost::intrusive::link_mode<boost::intrusive::auto_unlink> >
 {
 public:
-	ConnectionImpl(PortImpl* src_port, PortImpl* dst_port);
+	ConnectionImpl(PortImpl* tail, PortImpl* head);
 
-	PortImpl* src_port() const { return _src_port; }
-	PortImpl* dst_port() const { return _dst_port; }
+	PortImpl* tail() const { return _tail; }
+	PortImpl* head() const { return _head; }
 
-	const Raul::Path& src_port_path() const;
-	const Raul::Path& dst_port_path() const;
+	const Raul::Path& tail_path() const;
+	const Raul::Path& head_path() const;
 
 	void queue(Context& context);
 
@@ -94,8 +94,8 @@ public:
 protected:
 	void dump() const;
 
-	PortImpl* const   _src_port;
-	PortImpl* const   _dst_port;
+	PortImpl* const   _tail;
+	PortImpl* const   _head;
 	Raul::RingBuffer* _queue;
 };
 
diff --git a/src/server/InputPort.cpp b/src/server/InputPort.cpp
index 30745161..fa76c9b0 100644
--- a/src/server/InputPort.cpp
+++ b/src/server/InputPort.cpp
@@ -136,13 +136,13 @@ InputPort::add_connection(ConnectionImpl* c)
  * will audibly take effect.
  */
 ConnectionImpl*
-InputPort::remove_connection(ProcessContext& context, const OutputPort* src_port)
+InputPort::remove_connection(ProcessContext& context, const OutputPort* tail)
 {
 	ThreadManager::assert_thread(THREAD_PROCESS);
 
 	ConnectionImpl* connection = NULL;
 	for (Connections::iterator i = _connections.begin(); i != _connections.end(); ++i) {
-		if (i->src_port() == src_port) {
+		if (i->tail() == tail) {
 			connection = &*i;
 			_connections.erase(i);
 			break;
@@ -192,7 +192,7 @@ InputPort::pre_process(Context& context)
 		uint32_t max_num_srcs = 0;
 		for (Connections::const_iterator c = _connections.begin();
 		     c != _connections.end(); ++c) {
-			max_num_srcs += c->src_port()->poly();
+			max_num_srcs += c->tail()->poly();
 		}
 
 		boost::intrusive_ptr<Buffer> srcs[max_num_srcs];
diff --git a/src/server/InputPort.hpp b/src/server/InputPort.hpp
index 89f3949a..5d7269da 100644
--- a/src/server/InputPort.hpp
+++ b/src/server/InputPort.hpp
@@ -69,7 +69,7 @@ public:
 
 	void            add_connection(ConnectionImpl* c);
 	ConnectionImpl* remove_connection(ProcessContext&   context,
-	                                  const OutputPort* src_port);
+	                                  const OutputPort* tail);
 
 	bool apply_poly(Raul::Maid& maid, uint32_t poly);
 
diff --git a/src/server/ObjectSender.cpp b/src/server/ObjectSender.cpp
index 96207ebc..4115f2e3 100644
--- a/src/server/ObjectSender.cpp
+++ b/src/server/ObjectSender.cpp
@@ -88,7 +88,7 @@ ObjectSender::send_patch(Interface* client, const PatchImpl* patch, bool recursi
 		// Send connections
 		for (PatchImpl::Connections::const_iterator j = patch->connections().begin();
 				j != patch->connections().end(); ++j)
-			client->connect(j->second->src_port_path(), j->second->dst_port_path());
+			client->connect(j->second->tail_path(), j->second->head_path());
 	}
 
 	if (bundle)
diff --git a/src/server/PatchImpl.cpp b/src/server/PatchImpl.cpp
index 3f8905f1..4fa13a40 100644
--- a/src/server/PatchImpl.cpp
+++ b/src/server/PatchImpl.cpp
@@ -300,17 +300,17 @@ void
 PatchImpl::add_connection(SharedPtr<ConnectionImpl> c)
 {
 	ThreadManager::assert_thread(THREAD_PRE_PROCESS);
-	_connections.insert(make_pair(make_pair(c->src_port(), c->dst_port()), c));
+	_connections.insert(make_pair(make_pair(c->tail(), c->head()), c));
 }
 
 /** Remove a connection.
  * Preprocessing thread only.
  */
 SharedPtr<ConnectionImpl>
-PatchImpl::remove_connection(const PortImpl* src_port, const PortImpl* dst_port)
+PatchImpl::remove_connection(const PortImpl* tail, const PortImpl* dst_port)
 {
 	ThreadManager::assert_thread(THREAD_PRE_PROCESS);
-	Connections::iterator i = _connections.find(make_pair(src_port, dst_port));
+	Connections::iterator i = _connections.find(make_pair(tail, dst_port));
 	if (i != _connections.end()) {
 		SharedPtr<ConnectionImpl> c = PtrCast<ConnectionImpl>(i->second);
 		_connections.erase(i);
@@ -322,10 +322,10 @@ PatchImpl::remove_connection(const PortImpl* src_port, const PortImpl* dst_port)
 }
 
 bool
-PatchImpl::has_connection(const PortImpl* src_port, const PortImpl* dst_port) const
+PatchImpl::has_connection(const PortImpl* tail, const PortImpl* dst_port) const
 {
 	ThreadManager::assert_thread(THREAD_PRE_PROCESS);
-	Connections::const_iterator i = _connections.find(make_pair(src_port, dst_port));
+	Connections::const_iterator i = _connections.find(make_pair(tail, dst_port));
 	return (i != _connections.end());
 }
 
@@ -474,8 +474,8 @@ PatchImpl::compile() const
 	for (Connections::const_iterator i = _connections.begin();
 	     i != _connections.end(); ++i) {
 		SharedPtr<ConnectionImpl> c = PtrCast<ConnectionImpl>(i->second);
-		if (c->src_port()->parent_node()->context() == Context::AUDIO &&
-		    c->dst_port()->parent_node()->context() == Context::MESSAGE) {
+		if (c->tail()->parent_node()->context() == Context::AUDIO &&
+		    c->head()->parent_node()->context() == Context::MESSAGE) {
 			compiled_patch->queued_connections.push_back(c.get());
 		}
 	}
diff --git a/src/server/PatchImpl.hpp b/src/server/PatchImpl.hpp
index 124d78a5..85b53351 100644
--- a/src/server/PatchImpl.hpp
+++ b/src/server/PatchImpl.hpp
@@ -132,10 +132,10 @@ public:
 
 	void add_connection(SharedPtr<ConnectionImpl> c);
 
-	SharedPtr<ConnectionImpl> remove_connection(const PortImpl* src_port,
-	                                            const PortImpl* dst_port);
+	SharedPtr<ConnectionImpl> remove_connection(const PortImpl* tail,
+	                                            const PortImpl* head);
 
-	bool has_connection(const PortImpl* src_port, const PortImpl* dst_port) const;
+	bool has_connection(const PortImpl* tail, const PortImpl* head) const;
 
 	CompiledPatch* compiled_patch()                  { return _compiled_patch; }
 	void           compiled_patch(CompiledPatch* cp) { _compiled_patch = cp; }
diff --git a/src/server/ServerInterfaceImpl.cpp b/src/server/ServerInterfaceImpl.cpp
index b2094d9c..3994e695 100644
--- a/src/server/ServerInterfaceImpl.cpp
+++ b/src/server/ServerInterfaceImpl.cpp
@@ -126,16 +126,16 @@ ServerInterfaceImpl::del(const URI& uri)
 }
 
 void
-ServerInterfaceImpl::connect(const Path& src_port_path,
-                             const Path& dst_port_path)
+ServerInterfaceImpl::connect(const Path& tail_path,
+                             const Path& head_path)
 {
-	push_queued(new Events::Connect(_engine, _request_client, _request_id, now(), src_port_path, dst_port_path));
+	push_queued(new Events::Connect(_engine, _request_client, _request_id, now(), tail_path, head_path));
 
 }
 
 void
-ServerInterfaceImpl::disconnect(const URI& src,
-                                const URI& dst)
+ServerInterfaceImpl::disconnect(const Path& src,
+                                const Path& dst)
 {
 	if (!Path::is_path(src) && !Path::is_path(dst)) {
 		std::cerr << "Bad disconnect request " << src << " => " << dst << std::endl;
diff --git a/src/server/ServerInterfaceImpl.hpp b/src/server/ServerInterfaceImpl.hpp
index be725cd8..56aea0a3 100644
--- a/src/server/ServerInterfaceImpl.hpp
+++ b/src/server/ServerInterfaceImpl.hpp
@@ -69,11 +69,11 @@ public:
 	virtual void move(const Raul::Path& old_path,
 	                  const Raul::Path& new_path);
 
-	virtual void connect(const Raul::Path& src_port_path,
-	                     const Raul::Path& dst_port_path);
+	virtual void connect(const Raul::Path& tail,
+	                     const Raul::Path& head);
 
-	virtual void disconnect(const Raul::URI& src,
-	                        const Raul::URI& dst);
+	virtual void disconnect(const Raul::Path& tail,
+	                        const Raul::Path& head);
 
 	virtual void set_property(const Raul::URI& subject_path,
 	                          const Raul::URI&  predicate,
diff --git a/src/server/events/Connect.cpp b/src/server/events/Connect.cpp
index f61a5cd1..6ad8d4f6 100644
--- a/src/server/events/Connect.cpp
+++ b/src/server/events/Connect.cpp
@@ -46,11 +46,11 @@ Connect::Connect(Engine&     engine,
                  Interface*  client,
                  int32_t     id,
                  SampleCount timestamp,
-                 const Path& src_port_path,
-                 const Path& dst_port_path)
+                 const Path& tail_path,
+                 const Path& head_path)
 	: Event(engine, client, id, timestamp)
-	, _src_port_path(src_port_path)
-	, _dst_port_path(dst_port_path)
+	, _tail_path(tail_path)
+	, _head_path(head_path)
 	, _patch(NULL)
 	, _src_output_port(NULL)
 	, _dst_input_port(NULL)
@@ -63,24 +63,24 @@ Connect::pre_process()
 {
 	Glib::RWLock::ReaderLock rlock(_engine.engine_store()->lock());
 
-	PortImpl* src_port = _engine.engine_store()->find_port(_src_port_path);
-	PortImpl* dst_port = _engine.engine_store()->find_port(_dst_port_path);
-	if (!src_port || !dst_port) {
+	PortImpl* tail = _engine.engine_store()->find_port(_tail_path);
+	PortImpl* head = _engine.engine_store()->find_port(_head_path);
+	if (!tail || !head) {
 		_status = PORT_NOT_FOUND;
 		Event::pre_process();
 		return;
 	}
 
-	_dst_input_port  = dynamic_cast<InputPort*>(dst_port);
-	_src_output_port = dynamic_cast<OutputPort*>(src_port);
+	_dst_input_port  = dynamic_cast<InputPort*>(head);
+	_src_output_port = dynamic_cast<OutputPort*>(tail);
 	if (!_dst_input_port || !_src_output_port) {
 		_status = DIRECTION_MISMATCH;
 		Event::pre_process();
 		return;
 	}
 
-	NodeImpl* const src_node = src_port->parent_node();
-	NodeImpl* const dst_node = dst_port->parent_node();
+	NodeImpl* const src_node = tail->parent_node();
+	NodeImpl* const dst_node = head->parent_node();
 	if (!src_node || !dst_node) {
 		_status = PARENT_NOT_FOUND;
 		Event::pre_process();
@@ -176,7 +176,7 @@ Connect::post_process()
 {
 	respond(_status);
 	if (!_status) {
-		_engine.broadcaster()->connect(_src_port_path, _dst_port_path);
+		_engine.broadcaster()->connect(_tail_path, _head_path);
 	}
 }
 
diff --git a/src/server/events/Connect.hpp b/src/server/events/Connect.hpp
index f4544272..d3c2bea6 100644
--- a/src/server/events/Connect.hpp
+++ b/src/server/events/Connect.hpp
@@ -52,16 +52,16 @@ public:
 	        Interface*        client,
 	        int32_t           id,
 	        SampleCount       timestamp,
-	        const Raul::Path& src_port_path,
-	        const Raul::Path& dst_port_path);
+	        const Raul::Path& tail,
+	        const Raul::Path& head);
 
 	void pre_process();
 	void execute(ProcessContext& context);
 	void post_process();
 
 private:
-	Raul::Path _src_port_path;
-	Raul::Path _dst_port_path;
+	Raul::Path _tail_path;
+	Raul::Path _head_path;
 
 	PatchImpl*  _patch;
 	OutputPort* _src_output_port;
diff --git a/src/server/events/Disconnect.cpp b/src/server/events/Disconnect.cpp
index ddf3bb1c..b6432d0b 100644
--- a/src/server/events/Disconnect.cpp
+++ b/src/server/events/Disconnect.cpp
@@ -45,14 +45,14 @@ Disconnect::Disconnect(Engine&           engine,
                        Interface*        client,
                        int32_t           id,
                        SampleCount       timestamp,
-                       const Raul::Path& src_port_path,
-                       const Raul::Path& dst_port_path)
+                       const Raul::Path& tail_path,
+                       const Raul::Path& head_path)
 	: Event(engine, client, id, timestamp)
-	, _src_port_path(src_port_path)
-	, _dst_port_path(dst_port_path)
+	, _tail_path(tail_path)
+	, _head_path(head_path)
 	, _patch(NULL)
-	, _src_port(NULL)
-	, _dst_port(NULL)
+	, _tail(NULL)
+	, _head(NULL)
 	, _impl(NULL)
 	, _compiled_patch(NULL)
 {
@@ -115,25 +115,25 @@ Disconnect::pre_process()
 {
 	Glib::RWLock::WriterLock lock(_engine.engine_store()->lock());
 
-	if (_src_port_path.parent().parent() != _dst_port_path.parent().parent()
-	    && _src_port_path.parent() != _dst_port_path.parent().parent()
-	    && _src_port_path.parent().parent() != _dst_port_path.parent()) {
+	if (_tail_path.parent().parent() != _head_path.parent().parent()
+	    && _tail_path.parent() != _head_path.parent().parent()
+	    && _tail_path.parent().parent() != _head_path.parent()) {
 		_status = PARENT_DIFFERS;
 		Event::pre_process();
 		return;
 	}
 
-	_src_port = _engine.engine_store()->find_port(_src_port_path);
-	_dst_port = _engine.engine_store()->find_port(_dst_port_path);
+	_tail = _engine.engine_store()->find_port(_tail_path);
+	_head = _engine.engine_store()->find_port(_head_path);
 
-	if (_src_port == NULL || _dst_port == NULL) {
+	if (_tail == NULL || _head == NULL) {
 		_status = PORT_NOT_FOUND;
 		Event::pre_process();
 		return;
 	}
 
-	NodeImpl* const src_node = _src_port->parent_node();
-	NodeImpl* const dst_node = _dst_port->parent_node();
+	NodeImpl* const src_node = _tail->parent_node();
+	NodeImpl* const dst_node = _head->parent_node();
 
 	// Connection to a patch port from inside the patch
 	if (src_node->parent_patch() != dst_node->parent_patch()) {
@@ -155,7 +155,7 @@ Disconnect::pre_process()
 
 	assert(_patch);
 
-	if (!_patch->has_connection(_src_port, _dst_port)) {
+	if (!_patch->has_connection(_tail, _head)) {
 		_status = NOT_FOUND;
 		Event::pre_process();
 		return;
@@ -169,8 +169,8 @@ Disconnect::pre_process()
 
 	_impl = new Impl(_engine,
 	                 _patch,
-	                 dynamic_cast<OutputPort*>(_src_port),
-	                 dynamic_cast<InputPort*>(_dst_port));
+	                 dynamic_cast<OutputPort*>(_tail),
+	                 dynamic_cast<InputPort*>(_head));
 
 	if (_patch->enabled())
 		_compiled_patch = _patch->compile();
@@ -228,7 +228,7 @@ Disconnect::post_process()
 {
 	respond(_status);
 	if (!_status) {
-		_engine.broadcaster()->disconnect(_src_port->path(), _dst_port->path());
+		_engine.broadcaster()->disconnect(_tail->path(), _head->path());
 	}
 
 	delete _impl;
diff --git a/src/server/events/Disconnect.hpp b/src/server/events/Disconnect.hpp
index 05ac2aa7..cf4e6f18 100644
--- a/src/server/events/Disconnect.hpp
+++ b/src/server/events/Disconnect.hpp
@@ -49,8 +49,8 @@ public:
 	           Interface*        client,
 	           int32_t           id,
 	           SampleCount       timestamp,
-	           const Raul::Path& src_port_path,
-	           const Raul::Path& dst_port_path);
+	           const Raul::Path& tail_path,
+	           const Raul::Path& head_path);
 
 	void pre_process();
 	void execute(ProcessContext& context);
@@ -65,7 +65,7 @@ public:
 
 		bool execute(ProcessContext& context, bool set_dst_buffers);
 
-		InputPort* dst_port() { return _dst_input_port; }
+		InputPort* head() { return _dst_input_port; }
 
 	private:
 		Engine&                   _engine;
@@ -77,12 +77,12 @@ public:
 	};
 
 private:
-	const Raul::Path _src_port_path;
-	const Raul::Path _dst_port_path;
+	const Raul::Path _tail_path;
+	const Raul::Path _head_path;
 
 	PatchImpl* _patch;
-	PortImpl*  _src_port;
-	PortImpl*  _dst_port;
+	PortImpl*  _tail;
+	PortImpl*  _head;
 
 	Impl*          _impl;
 	CompiledPatch* _compiled_patch;
diff --git a/src/server/events/DisconnectAll.cpp b/src/server/events/DisconnectAll.cpp
index 08c0a9dc..123b218b 100644
--- a/src/server/events/DisconnectAll.cpp
+++ b/src/server/events/DisconnectAll.cpp
@@ -125,13 +125,13 @@ DisconnectAll::pre_process()
 	     i != _parent->connections().end(); ++i) {
 		ConnectionImpl* const c = (ConnectionImpl*)i->second.get();
 		if (_node) {
-			if (c->src_port()->parent_node() == _node
-			    || c->dst_port()->parent_node() == _node) {
+			if (c->tail()->parent_node() == _node
+			    || c->head()->parent_node() == _node) {
 				to_remove.insert(c);
 			}
 		} else {
 			assert(_port);
-			if (c->src_port() == _port || c->dst_port() == _port) {
+			if (c->tail() == _port || c->head() == _port) {
 				to_remove.insert(c);
 			}
 		}
@@ -142,8 +142,8 @@ DisconnectAll::pre_process()
 	     i != to_remove.end(); ++i) {
 		_impls.push_back(new Disconnect::Impl(
 			                 _engine, _parent,
-			                 dynamic_cast<OutputPort*>((*i)->src_port()),
-			                 dynamic_cast<InputPort*>((*i)->dst_port())));
+			                 dynamic_cast<OutputPort*>((*i)->tail()),
+			                 dynamic_cast<InputPort*>((*i)->head())));
 	}
 
 	if (!_deleting && _parent->enabled())
@@ -160,7 +160,7 @@ DisconnectAll::execute(ProcessContext& context)
 	if (_status == SUCCESS) {
 		for (Impls::iterator i = _impls.begin(); i != _impls.end(); ++i) {
 			(*i)->execute(context,
-			              !_deleting || ((*i)->dst_port()->parent_node() != _node));
+			              !_deleting || ((*i)->head()->parent_node() != _node));
 		}
 	}