QueuedEngineInterface => ServerInterfaceImpl.

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

10 files changed, 42 insertions, 42 deletions

diff --git a/src/server/Engine.cpp b/src/server/Engine.cpp
index a38e936f..3e5ee704 100644
--- a/src/server/Engine.cpp
+++ b/src/server/Engine.cpp
@@ -43,7 +43,7 @@
 #include "PatchImpl.hpp"
 #include "PostProcessor.hpp"
 #include "ProcessContext.hpp"
-#include "QueuedEngineInterface.hpp"
+#include "ServerInterfaceImpl.hpp"
 #include "ThreadManager.hpp"
 
 using namespace std;
diff --git a/src/server/HTTPEngineReceiver.cpp b/src/server/HTTPEngineReceiver.cpp
index 855cb486..15362a80 100644
--- a/src/server/HTTPEngineReceiver.cpp
+++ b/src/server/HTTPEngineReceiver.cpp
@@ -51,7 +51,7 @@ using namespace Serialisation;
 namespace Server {
 
 HTTPEngineReceiver::HTTPEngineReceiver(Engine& engine, uint16_t port)
-	: QueuedEngineInterface(engine)
+	: ServerInterfaceImpl(engine)
 	, _server(soup_server_new(SOUP_SERVER_PORT, port, NULL))
 {
 	_receive_thread = new ReceiveThread(*this);
@@ -216,7 +216,7 @@ HTTPEngineReceiver::message_callback(SoupServer*        server,
 	}
 }
 
-/** Override the semaphore driven _run method of QueuedEngineInterface
+/** Override the semaphore driven _run method of ServerInterfaceImpl
  * to wait on HTTP requests and process them immediately in this thread.
  */
 void
diff --git a/src/server/HTTPEngineReceiver.hpp b/src/server/HTTPEngineReceiver.hpp
index c261d0f1..f942ee96 100644
--- a/src/server/HTTPEngineReceiver.hpp
+++ b/src/server/HTTPEngineReceiver.hpp
@@ -22,7 +22,7 @@
 
 #include <string>
 
-#include "QueuedEngineInterface.hpp"
+#include "ServerInterfaceImpl.hpp"
 
 typedef struct _SoupServer SoupServer;
 typedef struct _SoupMessage SoupMessage;
@@ -31,7 +31,7 @@ typedef struct SoupClientContext SoupClientContext;
 namespace Ingen {
 namespace Server {
 
-class HTTPEngineReceiver : public QueuedEngineInterface
+class HTTPEngineReceiver : public ServerInterfaceImpl
 {
 public:
 	HTTPEngineReceiver(Engine& engine, uint16_t port);
diff --git a/src/server/OSCEngineReceiver.cpp b/src/server/OSCEngineReceiver.cpp
index 53dc6e4a..4a24989a 100644
--- a/src/server/OSCEngineReceiver.cpp
+++ b/src/server/OSCEngineReceiver.cpp
@@ -57,7 +57,7 @@ namespace Server {
  */
 
 OSCEngineReceiver::OSCEngineReceiver(Engine& engine, uint16_t port)
-	: QueuedEngineInterface(engine)
+	: ServerInterfaceImpl(engine)
 	, _server(NULL)
 {
 	_receive_thread = new ReceiveThread(*this);
@@ -139,7 +139,7 @@ OSCEngineReceiver::~OSCEngineReceiver()
 	}
 }
 
-/** Override the semaphore driven _run method of QueuedEngineInterface
+/** Override the semaphore driven _run method of ServerInterfaceImpl
  * to wait on OSC messages and prepare them right away in the same thread.
  */
 void
diff --git a/src/server/OSCEngineReceiver.hpp b/src/server/OSCEngineReceiver.hpp
index f032d009..4282b0a8 100644
--- a/src/server/OSCEngineReceiver.hpp
+++ b/src/server/OSCEngineReceiver.hpp
@@ -20,7 +20,7 @@
 
 #include <stdint.h>
 #include <lo/lo.h>
-#include "QueuedEngineInterface.hpp"
+#include "ServerInterfaceImpl.hpp"
 #include "Request.hpp"
 #include "ingen-config.h"
 
@@ -46,15 +46,15 @@ inline static int name##_cb(LO_HANDLER_ARGS, void* myself)\
 
 /** Receives OSC messages from liblo.
  *
- * This inherits from QueuedEngineInterface and calls it's own functions
+ * This inherits from ServerInterfaceImpl and calls it's own functions
  * via OSC.  It's not actually a directly callable ServerInterface (it's
  * callable via OSC...) so it should be implemented-as-a (privately inherit)
- * QueuedEngineInterface, but it needs to be public so it's an EventSource
+ * ServerInterfaceImpl, but it needs to be public so it's an EventSource
  * the Driver can use.  This probably should be fixed somehow..
  *
  * \ingroup engine
  */
-class OSCEngineReceiver : public QueuedEngineInterface
+class OSCEngineReceiver : public ServerInterfaceImpl
 {
 public:
 	OSCEngineReceiver(Engine& engine, uint16_t port);
diff --git a/src/server/QueuedEngineInterface.cpp b/src/server/ServerInterfaceImpl.cpp
index f941ef58..1109a388 100644
--- a/src/server/QueuedEngineInterface.cpp
+++ b/src/server/ServerInterfaceImpl.cpp
@@ -22,10 +22,10 @@
 #include "Driver.hpp"
 #include "Engine.hpp"
 #include "EventSource.hpp"
-#include "QueuedEngineInterface.hpp"
+#include "ServerInterfaceImpl.hpp"
 #include "events.hpp"
 
-#define LOG(s) s << "[QueuedEngineInterface] "
+#define LOG(s) s << "[ServerInterfaceImpl] "
 
 using namespace std;
 using namespace Raul;
@@ -33,7 +33,7 @@ using namespace Raul;
 namespace Ingen {
 namespace Server {
 
-QueuedEngineInterface::QueuedEngineInterface(Engine& engine)
+ServerInterfaceImpl::ServerInterfaceImpl(Engine& engine)
 	: EventSource()
 	, _request(new Request(this, NULL, 0))
 	, _engine(engine)
@@ -43,13 +43,13 @@ QueuedEngineInterface::QueuedEngineInterface(Engine& engine)
 }
 
 
-QueuedEngineInterface::~QueuedEngineInterface()
+ServerInterfaceImpl::~ServerInterfaceImpl()
 {
 	stop();
 }
 
 SampleCount
-QueuedEngineInterface::now() const
+ServerInterfaceImpl::now() const
 {
 	// Exactly one cycle latency (some could run ASAP if we get lucky, but not always, and a slight
 	// constant latency is far better than jittery lower (average) latency
@@ -60,14 +60,14 @@ QueuedEngineInterface::now() const
 }
 
 void
-QueuedEngineInterface::set_next_response_id(int32_t id)
+ServerInterfaceImpl::set_next_response_id(int32_t id)
 {
 	if (_request)
 		_request->set_id(id);
 }
 
 void
-QueuedEngineInterface::disable_responses()
+ServerInterfaceImpl::disable_responses()
 {
 	_request->set_client(NULL);
 	_request->set_id(0);
@@ -76,7 +76,7 @@ QueuedEngineInterface::disable_responses()
 /* *** ServerInterface implementation below here *** */
 
 void
-QueuedEngineInterface::register_client(ClientInterface* client)
+ServerInterfaceImpl::register_client(ClientInterface* client)
 {
 	push_queued(new Events::RegisterClient(_engine, _request, now(), client->uri(), client));
 	if (!_request) {
@@ -88,7 +88,7 @@ QueuedEngineInterface::register_client(ClientInterface* client)
 }
 
 void
-QueuedEngineInterface::unregister_client(const URI& uri)
+ServerInterfaceImpl::unregister_client(const URI& uri)
 {
 	push_queued(new Events::UnregisterClient(_engine, _request, now(), uri));
 	if (_request && _request->client() && _request->client()->uri() == uri) {
@@ -100,13 +100,13 @@ QueuedEngineInterface::unregister_client(const URI& uri)
 // Bundle commands
 
 void
-QueuedEngineInterface::bundle_begin()
+ServerInterfaceImpl::bundle_begin()
 {
 	_in_bundle = true;
 }
 
 void
-QueuedEngineInterface::bundle_end()
+ServerInterfaceImpl::bundle_end()
 {
 	_in_bundle = false;
 }
@@ -114,7 +114,7 @@ QueuedEngineInterface::bundle_end()
 // Object commands
 
 void
-QueuedEngineInterface::put(const URI&                  uri,
+ServerInterfaceImpl::put(const URI&                  uri,
                            const Resource::Properties& properties,
                            const Resource::Graph       ctx)
 {
@@ -122,7 +122,7 @@ QueuedEngineInterface::put(const URI&                  uri,
 }
 
 void
-QueuedEngineInterface::delta(const URI&                  uri,
+ServerInterfaceImpl::delta(const URI&                  uri,
                              const Resource::Properties& remove,
                              const Resource::Properties& add)
 {
@@ -130,14 +130,14 @@ QueuedEngineInterface::delta(const URI&                  uri,
 }
 
 void
-QueuedEngineInterface::move(const Path& old_path,
+ServerInterfaceImpl::move(const Path& old_path,
                             const Path& new_path)
 {
 	push_queued(new Events::Move(_engine, _request, now(), old_path, new_path));
 }
 
 void
-QueuedEngineInterface::del(const URI& uri)
+ServerInterfaceImpl::del(const URI& uri)
 {
 	if (uri == "ingen:engine") {
 		_request->respond_ok();
@@ -148,7 +148,7 @@ QueuedEngineInterface::del(const URI& uri)
 }
 
 void
-QueuedEngineInterface::connect(const Path& src_port_path,
+ServerInterfaceImpl::connect(const Path& src_port_path,
                                const Path& dst_port_path)
 {
 	push_queued(new Events::Connect(_engine, _request, now(), src_port_path, dst_port_path));
@@ -156,7 +156,7 @@ QueuedEngineInterface::connect(const Path& src_port_path,
 }
 
 void
-QueuedEngineInterface::disconnect(const URI& src,
+ServerInterfaceImpl::disconnect(const URI& src,
                                   const URI& dst)
 {
 	if (!Path::is_path(src) && !Path::is_path(dst)) {
@@ -169,14 +169,14 @@ QueuedEngineInterface::disconnect(const URI& src,
 }
 
 void
-QueuedEngineInterface::disconnect_all(const Path& patch_path,
+ServerInterfaceImpl::disconnect_all(const Path& patch_path,
                                       const Path& path)
 {
 	push_queued(new Events::DisconnectAll(_engine, _request, now(), patch_path, path));
 }
 
 void
-QueuedEngineInterface::set_property(const URI&  uri,
+ServerInterfaceImpl::set_property(const URI&  uri,
                                     const URI&  predicate,
                                     const Atom& value)
 {
@@ -202,13 +202,13 @@ QueuedEngineInterface::set_property(const URI&  uri,
 // Requests //
 
 void
-QueuedEngineInterface::ping()
+ServerInterfaceImpl::ping()
 {
 	push_queued(new Events::Ping(_engine, _request, now()));
 }
 
 void
-QueuedEngineInterface::get(const URI& uri)
+ServerInterfaceImpl::get(const URI& uri)
 {
 	push_queued(new Events::Get(_engine, _request, now(), uri));
 }
diff --git a/src/server/QueuedEngineInterface.hpp b/src/server/ServerInterfaceImpl.hpp
index f8aa3c24..6c65dcb9 100644
--- a/src/server/QueuedEngineInterface.hpp
+++ b/src/server/ServerInterfaceImpl.hpp
@@ -44,12 +44,12 @@ class Engine;
  * If you do not register a request, you have no way of knowing if your calls
  * are successful.
  */
-class QueuedEngineInterface : public EventSource,
+class ServerInterfaceImpl : public EventSource,
                               public ServerInterface
 {
 public:
-	QueuedEngineInterface(Engine& engine);
-	virtual ~QueuedEngineInterface();
+	ServerInterfaceImpl(Engine& engine);
+	virtual ~ServerInterfaceImpl();
 
 	Raul::URI uri() const { return "http://drobilla.net/ns/ingen#internal"; }
 
diff --git a/src/server/ingen_engine.cpp b/src/server/ingen_engine.cpp
index b7b28575..43d021e0 100644
--- a/src/server/ingen_engine.cpp
+++ b/src/server/ingen_engine.cpp
@@ -18,7 +18,7 @@
 #include "ingen/shared/Module.hpp"
 #include "ingen/shared/World.hpp"
 #include "Engine.hpp"
-#include "QueuedEngineInterface.hpp"
+#include "ServerInterfaceImpl.hpp"
 #include "util.hpp"
 
 using namespace Ingen;
@@ -28,8 +28,8 @@ struct IngenEngineModule : public Ingen::Shared::Module {
 		Server::set_denormal_flags();
 		SharedPtr<Server::Engine> engine(new Server::Engine(world));
 		world->set_local_engine(engine);
-		SharedPtr<Server::QueuedEngineInterface> interface(
-			new Server::QueuedEngineInterface(*engine.get()));
+		SharedPtr<Server::ServerInterfaceImpl> interface(
+			new Server::ServerInterfaceImpl(*engine.get()));
 		world->set_engine(interface);
 		engine->add_event_source(interface);
 		assert(world->local_engine() == engine);
diff --git a/src/server/ingen_lv2.cpp b/src/server/ingen_lv2.cpp
index 9554d6d5..a2513946 100644
--- a/src/server/ingen_lv2.cpp
+++ b/src/server/ingen_lv2.cpp
@@ -43,7 +43,7 @@
 #include "PatchImpl.hpp"
 #include "PostProcessor.hpp"
 #include "ProcessContext.hpp"
-#include "QueuedEngineInterface.hpp"
+#include "ServerInterfaceImpl.hpp"
 #include "ThreadManager.hpp"
 
 /** Record of a patch in this Ingen LV2 bundle */
@@ -285,8 +285,8 @@ ingen_instantiate(const LV2_Descriptor*    descriptor,
 	plugin->main = new MainThread(engine);
 	plugin->main->set_name("Main");
 
-	SharedPtr<Server::QueuedEngineInterface> interface(
-		new Server::QueuedEngineInterface(*engine.get()));
+	SharedPtr<Server::ServerInterfaceImpl> interface(
+		new Server::ServerInterfaceImpl(*engine.get()));
 
 	plugin->world->set_engine(interface);
 	engine->add_event_source(interface);
diff --git a/src/server/wscript b/src/server/wscript
index 92404c5c..0251d7e8 100644
--- a/src/server/wscript
+++ b/src/server/wscript
@@ -33,8 +33,8 @@ def build(bld):
             PostProcessor.cpp
             ProcessContext.cpp
             ProcessSlave.cpp
-            QueuedEngineInterface.cpp
             QueuedEvent.cpp
+            ServerInterfaceImpl.cpp
             events/Connect.cpp
             events/CreateNode.cpp
             events/CreatePatch.cpp