Mad sed-fu for consistent private member naming.

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

1 files changed, 74 insertions, 74 deletions

diff --git a/src/libs/engine/events/ConnectionEvent.cpp b/src/libs/engine/events/ConnectionEvent.cpp
index c54e440f..40e8a660 100644
--- a/src/libs/engine/events/ConnectionEvent.cpp
+++ b/src/libs/engine/events/ConnectionEvent.cpp
@@ -38,86 +38,86 @@ namespace Ingen {
 
 ConnectionEvent::ConnectionEvent(Engine& engine, SharedPtr<Responder> responder, SampleCount timestamp, const string& src_port_path, const string& dst_port_path)
 : QueuedEvent(engine, responder, timestamp),
-  m_src_port_path(src_port_path),
-  m_dst_port_path(dst_port_path),
-  m_patch(NULL),
-  m_src_port(NULL),
-  m_dst_port(NULL),
-  m_typed_event(NULL),
-  m_error(NO_ERROR)
+  _src_port_path(src_port_path),
+  _dst_port_path(dst_port_path),
+  _patch(NULL),
+  _src_port(NULL),
+  _dst_port(NULL),
+  _typed_event(NULL),
+  _error(NO_ERROR)
 {
 }
 
 
 ConnectionEvent::~ConnectionEvent()
 {
-	delete m_typed_event;
+	delete _typed_event;
 }
 
 
 void
 ConnectionEvent::pre_process()
 {
-	if (m_src_port_path.parent().parent() != m_dst_port_path.parent().parent()
-			&& m_src_port_path.parent() != m_dst_port_path.parent().parent()
-			&& m_src_port_path.parent().parent() != m_dst_port_path.parent()) {
-		m_error = PARENT_PATCH_DIFFERENT;
+	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()) {
+		_error = PARENT_PATCH_DIFFERENT;
 		QueuedEvent::pre_process();
 		return;
 	}
 	
-	/*m_patch = _engine.object_store()->find_patch(m_src_port_path.parent().parent());
+	/*_patch = _engine.object_store()->find_patch(_src_port_path.parent().parent());
 
-	if (m_patch == NULL) {
-		m_error = PORT_NOT_FOUND;
+	if (_patch == NULL) {
+		_error = PORT_NOT_FOUND;
 		QueuedEvent::pre_process();
 		return;
 	}*/
 	
-	m_src_port = _engine.object_store()->find_port(m_src_port_path);
-	m_dst_port = _engine.object_store()->find_port(m_dst_port_path);
+	_src_port = _engine.object_store()->find_port(_src_port_path);
+	_dst_port = _engine.object_store()->find_port(_dst_port_path);
 	
-	if (m_src_port == NULL || m_dst_port == NULL) {
-		m_error = PORT_NOT_FOUND;
+	if (_src_port == NULL || _dst_port == NULL) {
+		_error = PORT_NOT_FOUND;
 		QueuedEvent::pre_process();
 		return;
 	}
 
-	if (m_src_port->type() != m_dst_port->type() || m_src_port->buffer_size() != m_dst_port->buffer_size()) {
-		m_error = TYPE_MISMATCH;
+	if (_src_port->type() != _dst_port->type() || _src_port->buffer_size() != _dst_port->buffer_size()) {
+		_error = TYPE_MISMATCH;
 		QueuedEvent::pre_process();
 		return;
 	}
 	
 	/*if (port1->is_output() && port2->is_input()) {
-		m_src_port = port1;
-		m_dst_port = port2;
+		_src_port = port1;
+		_dst_port = port2;
 	} else if (port2->is_output() && port1->is_input()) {
-		m_src_port = port2;
-		m_dst_port = port1;
+		_src_port = port2;
+		_dst_port = port1;
 	} else {
-		m_error = TYPE_MISMATCH;
+		_error = TYPE_MISMATCH;
 		QueuedEvent::pre_process();
 		return;
 	}*/
 	
 	// Create the typed event to actually do the work
-	const DataType type = m_src_port->type();
+	const DataType type = _src_port->type();
 	if (type == DataType::FLOAT) {
-		m_typed_event = new TypedConnectionEvent<Sample>(_engine, _responder, _time,
-			dynamic_cast<OutputPort<Sample>*>(m_src_port), dynamic_cast<InputPort<Sample>*>(m_dst_port));
+		_typed_event = new TypedConnectionEvent<Sample>(_engine, _responder, _time,
+			dynamic_cast<OutputPort<Sample>*>(_src_port), dynamic_cast<InputPort<Sample>*>(_dst_port));
 	} else if (type == DataType::MIDI) {
-		m_typed_event = new TypedConnectionEvent<MidiMessage>(_engine, _responder, _time,
-			dynamic_cast<OutputPort<MidiMessage>*>(m_src_port), dynamic_cast<InputPort<MidiMessage>*>(m_dst_port));
+		_typed_event = new TypedConnectionEvent<MidiMessage>(_engine, _responder, _time,
+			dynamic_cast<OutputPort<MidiMessage>*>(_src_port), dynamic_cast<InputPort<MidiMessage>*>(_dst_port));
 	} else {
-		m_error = TYPE_MISMATCH;
+		_error = TYPE_MISMATCH;
 		QueuedEvent::pre_process();
 		return;
 	}
 
-	assert(m_typed_event);
-	m_typed_event->pre_process();
-	assert(m_typed_event->is_prepared());
+	assert(_typed_event);
+	_typed_event->pre_process();
+	assert(_typed_event->is_prepared());
 
 	QueuedEvent::pre_process();
 }
@@ -128,20 +128,20 @@ ConnectionEvent::execute(SampleCount nframes, FrameTime start, FrameTime end)
 {
 	QueuedEvent::execute(nframes, start, end);
 
-	if (m_error == NO_ERROR)
-		m_typed_event->execute(nframes, start, end);
+	if (_error == NO_ERROR)
+		_typed_event->execute(nframes, start, end);
 }
 
 
 void
 ConnectionEvent::post_process()
 {
-	if (m_error == NO_ERROR) {
-		m_typed_event->post_process();
+	if (_error == NO_ERROR) {
+		_typed_event->post_process();
 	} else {
 		// FIXME: better error messages
 		string msg = "Unable to make connection ";
-		msg.append(m_src_port_path + " -> " + m_dst_port_path);
+		msg.append(_src_port_path + " -> " + _dst_port_path);
 		_responder->respond_error(msg);
 	}
 }
@@ -154,13 +154,13 @@ ConnectionEvent::post_process()
 template <typename T>
 TypedConnectionEvent<T>::TypedConnectionEvent(Engine& engine, SharedPtr<Responder> responder, SampleCount timestamp, OutputPort<T>* src_port, InputPort<T>* dst_port)
 : QueuedEvent(engine, responder, timestamp),
-  m_src_port(src_port),
-  m_dst_port(dst_port),
-  m_patch(NULL),
-  m_process_order(NULL),
-  m_connection(NULL),
-  m_port_listnode(NULL),
-  m_succeeded(true)
+  _src_port(src_port),
+  _dst_port(dst_port),
+  _patch(NULL),
+  _process_order(NULL),
+  _connection(NULL),
+  _port_listnode(NULL),
+  _succeeded(true)
 {
 	assert(src_port != NULL);
 	assert(dst_port != NULL);
@@ -171,50 +171,50 @@ template <typename T>
 void
 TypedConnectionEvent<T>::pre_process()
 {	
-	if (m_dst_port->is_connected_to(m_src_port)) {
-		m_succeeded = false;
+	if (_dst_port->is_connected_to(_src_port)) {
+		_succeeded = false;
 		QueuedEvent::pre_process();
 		return;
 	}
 
-	Node* const src_node = m_src_port->parent_node();
-	Node* const dst_node = m_dst_port->parent_node();
+	Node* const src_node = _src_port->parent_node();
+	Node* const dst_node = _dst_port->parent_node();
 
 	// Connection to a patch port from inside the patch
 	if (src_node->parent_patch() != dst_node->parent_patch()) {
 
 		assert(src_node->parent() == dst_node || dst_node->parent() == src_node);
 		if (src_node->parent() == dst_node)
-			m_patch = dynamic_cast<Patch*>(dst_node);
+			_patch = dynamic_cast<Patch*>(dst_node);
 		else
-			m_patch = dynamic_cast<Patch*>(src_node);
+			_patch = dynamic_cast<Patch*>(src_node);
 	
 	// Connection from a patch input to a patch output (pass through)
 	} else if (src_node == dst_node && dynamic_cast<Patch*>(src_node)) {
-		m_patch = dynamic_cast<Patch*>(src_node);
+		_patch = dynamic_cast<Patch*>(src_node);
 	
 	// Normal connection between nodes with the same parent
 	} else {
-		m_patch = src_node->parent_patch();
+		_patch = src_node->parent_patch();
 	}
 
-	assert(m_patch);
+	assert(_patch);
 
 	if (src_node == NULL || dst_node == NULL) {
-		m_succeeded = false;
+		_succeeded = false;
 		QueuedEvent::pre_process();
 		return;
 	}
 	
-	if (m_patch != src_node && src_node->parent() != m_patch && dst_node->parent() != m_patch) {
-		m_succeeded = false;
+	if (_patch != src_node && src_node->parent() != _patch && dst_node->parent() != _patch) {
+		_succeeded = false;
 		QueuedEvent::pre_process();
 		return;
 	}
 
-	m_connection = new TypedConnection<T>(m_src_port, m_dst_port);
-	m_port_listnode = new ListNode<TypedConnection<T>*>(m_connection);
-	m_patch_listnode = new ListNode<Connection*>(m_connection);
+	_connection = new TypedConnection<T>(_src_port, _dst_port);
+	_port_listnode = new ListNode<TypedConnection<T>*>(_connection);
+	_patch_listnode = new ListNode<Connection*>(_connection);
 	
 	// Need to be careful about patch port connections here and adding a node's
 	// parent as a dependant/provider, or adding a patch as it's own provider...
@@ -223,10 +223,10 @@ TypedConnectionEvent<T>::pre_process()
 		src_node->dependants()->push_back(new ListNode<Node*>(dst_node));
 	}
 
-	if (m_patch->enabled())
-		m_process_order = m_patch->build_process_order();
+	if (_patch->enabled())
+		_process_order = _patch->build_process_order();
 
-	m_succeeded = true;
+	_succeeded = true;
 	QueuedEvent::pre_process();
 }
 
@@ -237,13 +237,13 @@ TypedConnectionEvent<T>::execute(SampleCount nframes, FrameTime start, FrameTime
 {
 	QueuedEvent::execute(nframes, start, end);
 
-	if (m_succeeded) {
+	if (_succeeded) {
 		// These must be inserted here, since they're actually used by the audio thread
-		m_dst_port->add_connection(m_port_listnode);
-		m_patch->add_connection(m_patch_listnode);
-		if (m_patch->process_order() != NULL)
-			_engine.maid()->push(m_patch->process_order());
-		m_patch->process_order(m_process_order);
+		_dst_port->add_connection(_port_listnode);
+		_patch->add_connection(_patch_listnode);
+		if (_patch->process_order() != NULL)
+			_engine.maid()->push(_patch->process_order());
+		_patch->process_order(_process_order);
 	}
 }
 
@@ -252,12 +252,12 @@ template <typename T>
 void
 TypedConnectionEvent<T>::post_process()
 {
-	if (m_succeeded) {
-		assert(m_connection != NULL);
+	if (_succeeded) {
+		assert(_connection != NULL);
 	
 		_responder->respond_ok();
 	
-		_engine.broadcaster()->send_connection(m_connection);
+		_engine.broadcaster()->send_connection(_connection);
 	} else {
 		_responder->respond_error("Unable to make connection.");
 	}