Merge lp:~michihenning/unity-scopes-api/valgrind-suppressions into lp:unity-scopes-api

[Michi Henning]

Added valgrind suppressions for various bogus possible leak reports.

Added valgrind suppressions for various bogus possible leak reports.

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2013-07-04 00:39:02 +0000
+++ CMakeLists.txt	2013-08-05 06:40:36 +0000
@@ -15,26 +15,6 @@
 
 string(TOLOWER "${CMAKE_BUILD_TYPE}" cmake_build_type_lower) # Build types should always be lowercase but sometimes they are not.
 
-include(EnableCoverageReport)
-#####################################################################
-# Enable code coverage calculation with gcov/gcovr/lcov
-# Usage:
-#  * Switch build type to coverage (use ccmake or cmake-gui)
-#  * Invoke make, make test, make coverage (or ninja if you use that backend)
-#  * Find html report in subdir coveragereport
-#  * Find xml report suitable for jenkins in coverage.xml
-#####################################################################
-if(cmake_build_type_lower MATCHES coverage)
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --coverage")
-  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} --coverage")
-  set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} --coverage")
-  set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} --coverage")
-
-  # We add -g when building with coverage so valgrind reports line numbers.
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g" )
-  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g" )
-endif()
-
 # Static C++ checks
 
 find_program(CPPCHECK_COMMAND NAMES cppcheck)
@@ -66,6 +46,16 @@
     message(WARNING "Cannot find valgrind: valgrind target will not be available")
 endif()
 
+# TODO: For now, we need to use Ice 3.5 built from source until the Debian package becomes available.
+# The tarball is available here: http://zeroc.com/download/Ice/3.5/Ice-3.5.0.tar.gz
+# To build Ice, go to <source_root>/cpp, and do "make; make test; sudo make install".
+# The default config is fine. If you want to install somewhere else, edit the cpp/config/Make.rules file.
+set(IceRoot /usr)
+if (NOT EXISTS ${IceRoot}/include/Ice/Ice.h)
+    message(FATAL_ERROR "Cannot find Ice development files. You need to build Ice 3.5 from source and install it, and set IceRoot in CMakeLists.txt accordingly. Then set LD_LIBRARY_PATH to include the Ice lib64 directory, set PATH to include the Ice bin directory, and try again.")
+endif()
+
+set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -L${IceRoot}/lib64")
 
 include(FindPkgConfig)
 find_package(Boost 1.49.0 COMPONENTS regex REQUIRED)
@@ -73,12 +63,17 @@
 set(OTHER_INCLUDE_DIRS ${OTHER_INCLUDE_DIRS} ${UNITY_API_INCLUDE_DIRS})
 set(OTHER_LIBS ${OTHER_LIBS} ${UNITY_API_LDFLAGS})
 
+# UNIX Domain Socket transport plug-in for Ice.
+pkg_check_modules(IceUDS libIceUDS REQUIRED)
+
 # Standard install paths
 include(GNUInstallDirs)
 
 include_directories(
     ${CMAKE_SOURCE_DIR}/include
     ${CMAKE_BINARY_DIR}/include
+    ${CMAKE_BINARY_DIR}
+    ${IceRoot}/include
     ${OTHER_INCLUDE_DIRS}
 )
 
@@ -87,7 +82,13 @@
 # Exported functions and classes are prefixed by a UNITY_API macro,
 # which explicitly exports a symbol if UNITY_DLL_EXPORTS is defined.
 add_definitions(-DUNITY_DLL_EXPORTS)
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden")
+
+# TODO: static linking of the tests doesn't work because the tests won't pull in virtual methods in a
+# base class from a static library without an unresolved dependency. But, without static linking, we can't
+# do whitebox tests because of the visibility=hidden compile flags. For now, we link dynamically and
+# with visbility=default.
+#set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=default")   # HACK
 
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -fno-permissive -pedantic -Wall -Wextra")
 
@@ -105,7 +106,6 @@
 set(UNITY_SCOPES_MAJOR 0)
 set(UNITY_SCOPES_MINOR 1)
 set(UNITY_SCOPES_MICRO 0)
-set(UNITY_SCOPES_VERSION "${UNITY_SCOPES_MAJOR}.${UNITY_SCOPES_MINOR}.${UNITY_SCOPES_MICRO}")
 
 # Scopes library
 set(UNITY_SCOPES_LIB unity-scopes)
@@ -117,7 +117,10 @@
 set(OTHER_LIBS
     ${OTHER_LIBS}
     unity-api
+    Ice
+    IceUtil
     dl
+    pthread
 )
 
 # All the libraries we need to link a normal executable that uses Unity scopes
@@ -125,7 +128,14 @@
 
 # All the libraries we need to link a gtest executable. (We link the tests against a static version
 # so we can do whitebox testing on internal classes.
-set(TESTLIBS ${UNITY_SCOPES_STATIC_LIB} ${OTHER_LIBS})
+
+# TODO: HACK: static linking of the tests doesn't work because the tests won't pull in virtual methods in a
+# base class from a static library without an unresolved dependency. But, without static linking, we can't
+# do whitebox tests because of the visibility=hidden compile flags. For now, we link dynamically and
+# with visbility=default.
+
+# set(TESTLIBS ${UNITY_SCOPES_STATIC_LIB} ${OTHER_LIBS})
+set(TESTLIBS ${UNITY_SCOPES_LIB} ${OTHER_LIBS}) # HACK
 
 # Library install prefix
 set(LIB_INSTALL_PREFIX lib/${CMAKE_LIBRARY_ARCHITECTURE})
@@ -136,10 +146,91 @@
 include(CTest)
 enable_testing()
 
-# add subdirectories to build
+# Add subdirectories.
 add_subdirectory(include)
 add_subdirectory(src)
 add_subdirectory(test)
+add_subdirectory(slice)
+add_subdirectory(demo)
+
+# Custom rules to compile Slice files
+foreach(file ${SLICE_FILES})
+
+    string(REPLACE "${CMAKE_SOURCE_DIR}" "${CMAKE_BINARY_DIR}" build_dir ${file})
+    get_filename_component(build_dir ${build_dir} PATH)
+
+    get_filename_component(slice_file ${file} NAME)
+    string(REPLACE ".ice" ".cpp" src_file ${slice_file})
+    string(REPLACE ".ice" ".h" hdr_file ${slice_file})
+
+    set(src_file ${build_dir}/${src_file})
+    set(hdr_file ${build_dir}/${hdr_file})
+
+    string(REPLACE "${CMAKE_BINARY_DIR}/" "" relative_build_dir ${build_dir})
+
+    add_custom_command(OUTPUT ${src_file} ${hdr_file}
+                       DEPENDS ${file}
+                       COMMAND slice2cpp --output-dir=${build_dir} --include-dir ${relative_build_dir} ${file})
+
+    set(SLICE_HDRS ${SLICE_HDRS} ${hdr_file})
+    set(SLICE_SRC ${SLICE_SRC} ${src_file})
+endforeach()
+
+# Set up coverage testing
+include(EnableCoverageReport)
+#####################################################################
+# Enable code coverage calculation with gcov/gcovr/lcov
+# Usage:
+#  * Switch build type to coverage (use ccmake or cmake-gui)
+#  * Invoke make, make test, make coverage (or ninja if you use that backend)
+#  * Find html report in subdir coveragereport
+#  * Find xml report suitable for jenkins in coverage.xml
+#####################################################################
+if(cmake_build_type_lower MATCHES coverage)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --coverage")
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} --coverage")
+    set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} --coverage")
+    set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} --coverage")
+    set(CMAKE_STATIC_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} --coverage")
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} --coverage")
+
+    # We add -g when building with coverage so valgrind reports line numbers.
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g" )
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g" )
+endif()
+
+# Pseudo-library of object files. We need a dynamic version of the library for normal clients,
+# and a static version for the whitebox tests, so we can write unit tests for classes in the internal namespaces
+# (because, for the .so, non-public APIs are compiled with -fvisibility=hidden).
+# Everything is compiled with -fPIC, so the same object files are suitable for either library.
+# Here, we create an object library that then is used to link the static and dynamic
+# libraries, without having to compile each source file twice with different compile flags.
+
+set(UNITY_SCOPES_LIB_OBJ ${UNITY_SCOPES_LIB}-obj)
+add_library(${UNITY_SCOPES_LIB_OBJ} OBJECT ${UNITY_SCOPES_LIB_SRC} ${SLICE_SRC})
+set_target_properties(${UNITY_SCOPES_LIB_OBJ} PROPERTIES COMPILE_FLAGS "-fPIC")
+
+# Use the object files to make the shared library.
+set(UNITY_SCOPES_SOVERSION 0)
+add_library(${UNITY_SCOPES_LIB} SHARED $<TARGET_OBJECTS:${UNITY_SCOPES_LIB_OBJ}>)
+set_target_properties(${UNITY_SCOPES_LIB} PROPERTIES
+    VERSION "${UNITY_SCOPES_MAJOR}.${UNITY_SCOPES_MINOR}"
+    SOVERSION ${UNITY_SCOPES_SOVERSION}
+)
+
+# Use the object files to make the static library.
+add_library(${UNITY_SCOPES_STATIC_LIB} STATIC $<TARGET_OBJECTS:${UNITY_SCOPES_LIB_OBJ}>)
+set_target_properties(${UNITY_SCOPES_STATIC_LIB} PROPERTIES OUTPUT_NAME ${UNITY_SCOPES_LIB})
+
+# Only the dynamic library gets installed.
+install(TARGETS ${UNITY_SCOPES_LIB} LIBRARY DESTINATION ${LIB_INSTALL_PREFIX})
+
+set_target_properties(${UNITY_SCOPES_LIB} PROPERTIES
+    VERSION "${UNITY_SCOPES_MAJOR}.${UNITY_SCOPES_MINOR}"
+    SOVERSION ${UNITY_SCOPES_SOVERSION}
+)
+
+# Enable coverage testing
 
 if (cmake_build_type_lower MATCHES coverage)
   ENABLE_COVERAGE_REPORT(TARGETS ${UNITY_SCOPES_LIB} FILTER /usr/include ${CMAKE_SOURCE_DIR}/test/* ${CMAKE_BINARY_DIR}/*)

=== added directory 'demo'
=== added file 'demo/CMakeLists.txt'
--- demo/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ demo/CMakeLists.txt	2013-08-05 06:40:36 +0000
@@ -0,0 +1,18 @@
+add_library(scope-A MODULE scope-A.cpp)
+add_library(scope-B MODULE scope-B.cpp)
+add_library(scope-C MODULE scope-C.cpp)
+add_library(scope-D MODULE scope-D.cpp)
+
+add_executable(scoperunner-A scoperunner-A.cpp)
+target_link_libraries(scoperunner-A ${UNITY_SCOPES_LIB} ${OTHER_LIBS})
+
+add_executable(scoperunner-BC scoperunner-BC.cpp)
+target_link_libraries(scoperunner-BC ${UNITY_SCOPES_LIB} ${OTHER_LIBS})
+
+add_executable(scoperunner-D scoperunner-D.cpp)
+target_link_libraries(scoperunner-D ${UNITY_SCOPES_LIB} ${OTHER_LIBS})
+
+add_executable(client client.cpp)
+target_link_libraries(client ${UNITY_SCOPES_LIB} ${OTHER_LIBS})
+
+configure_file(Ice.Config.in ${CMAKE_CURRENT_BINARY_DIR}/Ice.Config)

=== added file 'demo/Ice.Config.in'
--- demo/Ice.Config.in	1970-01-01 00:00:00 +0000
+++ demo/Ice.Config.in	2013-08-05 06:40:36 +0000
@@ -0,0 +1,9 @@
+Ice.Plugin.IceUDS.cpp.IceUDS=@IceUDS_LIBDIR@/IceUDS,1.0:create_Ice_UDS
+scope-A.Endpoints=uds -f /tmp/scope-A
+scope-B.Endpoints=uds -f /tmp/scope-B
+scope-C.Endpoints=uds -f /tmp/scope-C
+scope-D.Endpoints=uds -f /tmp/scope-D
+
+Ice.Trace.Network=3
+#Ice.Trace.Protocol=1
+Ice.Warn.UnusedProperties=1

=== added file 'demo/client.cpp'
--- demo/client.cpp	1970-01-01 00:00:00 +0000
+++ demo/client.cpp	2013-08-05 06:40:36 +0000
@@ -0,0 +1,106 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#include <unity/api/scopes/RegistryProxy.h>
+#include <unity/api/scopes/Runtime.h>
+#include <unity/api/scopes/ReplyProxy.h>
+#include <unity/UnityExceptions.h>
+
+#include <condition_variable>
+#include <iostream>
+#include <mutex>
+
+using namespace std;
+using namespace unity::api::scopes;
+
+class Reply : public ReplyBase
+{
+public:
+    virtual void send(string const& result)
+    {
+        cout << "received result: " << result << endl;
+    }
+
+    virtual void finished()
+    {
+        cout << "query complete" << endl;
+        {
+            unique_lock<decltype(mutex_)> lock(mutex_);
+            query_complete_ = true;
+        }
+        condvar_.notify_one();
+    }
+
+    void wait_until_finished()
+    {
+        unique_lock<decltype(mutex_)> lock(mutex_);
+        condvar_.wait(lock, [this] { return this->query_complete_; });
+    }
+
+    Reply() :
+        query_complete_(false)
+    {
+    }
+
+private:
+    bool query_complete_;
+    mutex mutex_;
+    condition_variable condvar_;
+};
+
+int main(int argc, char* argv[])
+{
+    if (argc != 3)
+    {
+        cerr << "usage: ./client <scope-letter> query" << endl;
+        cerr << "For example: ./client B iron" << endl;
+        return 1;
+    }
+
+    string scope_name = string("scope-") + argv[1];
+    string search_string = argv[2];
+
+    try
+    {
+        Runtime::UPtr rt = Runtime::create("");
+
+        RegistryProxy::SPtr r = rt->registry();
+        if (!r)
+        {
+            cerr << "could not get proxy for registry" << endl;
+            return 1;
+        }
+        ScopeProxy::SPtr s = r->find(scope_name);
+        if (!s)
+        {
+            cerr << "no such scope: " << scope_name << endl;
+            return 1;
+        }
+        shared_ptr<Reply> reply(new Reply);
+        s->query(search_string, reply);     // Asynchronous, returns without waiting for query to be received by target.
+        reply->wait_until_finished();
+    }
+
+    catch (unity::Exception const& e)
+    {
+        cerr << e.to_string() << endl;
+        return 1;
+    }
+
+    return 0;
+}

=== added file 'demo/scope-A.cpp'
--- demo/scope-A.cpp	1970-01-01 00:00:00 +0000
+++ demo/scope-A.cpp	2013-08-05 06:40:36 +0000
@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#include <unity/api/scopes/ScopeBase.h>
+
+#include <iostream>
+
+#define EXPORT __attribute__ ((visibility ("default")))
+
+using namespace std;
+using namespace unity::api::scopes;
+
+// Example scope A: replies synchronously to a query. (Replies are returned before returning from the query() method.)
+
+class MyScope : public ScopeBase
+{
+public:
+    virtual int start(RegistryProxy::SPtr const&) override
+    {
+        return VERSION;
+    }
+    virtual void stop() override {}
+    virtual void run() override {}
+    virtual void query(string const& q, ReplyProxy::SPtr const& reply) override
+    {
+        cout << "scope-A: received query string \"" << q << "\"" << endl;
+
+        reply->send("scope-A: result 1 for query \"" + q + "\"");
+        reply->finished();  // Optional
+
+        cout << "scope-A: query \"" << q << "\" complete" << endl;
+    }
+};
+
+extern "C"
+{
+
+    EXPORT
+    unity::api::scopes::ScopeBase*
+    // cppcheck-suppress unusedFunction
+    UNITY_API_SCOPE_CREATE_FUNCTION()
+    {
+        return new MyScope;
+    }
+
+    EXPORT
+    void
+    // cppcheck-suppress unusedFunction
+    UNITY_API_SCOPE_DESTROY_FUNCTION(unity::api::scopes::ScopeBase* scope_base)
+    {
+        delete scope_base;
+    }
+
+}

=== added file 'demo/scope-B.cpp'
--- demo/scope-B.cpp	1970-01-01 00:00:00 +0000
+++ demo/scope-B.cpp	2013-08-05 06:40:36 +0000
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#include <unity/api/scopes/ScopeBase.h>
+#include <unity/UnityExceptions.h>
+
+#include <iostream>
+
+#define EXPORT __attribute__ ((visibility ("default")))
+
+using namespace std;
+using namespace unity::api::scopes;
+
+// Example scope B: aggregates from scope C and D.
+
+// A Reply instance remembers the query string and the reply object that was passed
+// from upstream. Results from the child scopes are sent to that upstream reply object.
+
+class Reply : public ReplyBase
+{
+public:
+    virtual void send(string const& result) override
+    {
+        cout << "received result from " << scope_name_ << ": " << result << endl;
+        upstream_->send(result);
+    }
+
+    virtual void finished() override
+    {
+        cout << "query to " << scope_name_ << " complete" << endl;
+    }
+
+    Reply(string const& scope_name, ReplyProxy::SPtr const& upstream) :
+        scope_name_(scope_name),
+        upstream_(upstream)
+    {
+    }
+
+private:
+    string scope_name_;
+    ReplyProxy::SPtr upstream_;
+};
+
+// MyScope agregates from C and D.
+
+class MyScope : public ScopeBase
+{
+public:
+    virtual int start(RegistryProxy::SPtr const& registry) override
+    {
+        // Lock up scopes C and D in the registry and remember their proxies.
+        scope_c_ = registry->find("scope-C");
+        if (!scope_c_)
+        {
+            throw unity::ResourceException("Cannot locate scope-C in registry");
+        }
+        scope_d_ = registry->find("scope-D");
+        if (!scope_d_)
+        {
+            throw unity::ResourceException("Cannot locate scope-D in registry");
+        }
+        return VERSION;
+    }
+
+    virtual void stop() override {}
+    virtual void run() override {}
+
+    virtual void query(string const& q, ReplyProxy::SPtr const& reply) override
+    {
+        cout << "scope-B: received query string \"" << q << "\"" << endl;
+        cout << "scope-B: forwarding query to scope-C and scope-D" << endl;
+
+        shared_ptr<Reply> r;
+
+        // Make a Reply instance and forward the query to C. C will deliver its
+        // results to that Reply instance.
+        r.reset(new Reply("scope-C", reply));
+        scope_c_->query(q, r);
+
+        // Do the same thing for D.
+        r.reset(new Reply("scope-D", reply));
+        scope_d_->query(q, r);
+
+        // We are done. As the replies trickle in, the two reply instance (kept alive by our run time)
+        // forward the results upstream.
+        cout << "scope-B: query \"" << q << "\" complete" << endl;
+    }
+
+private:
+    ScopeProxy::SPtr scope_c_;
+    ScopeProxy::SPtr scope_d_;
+};
+
+extern "C"
+{
+
+    EXPORT
+    unity::api::scopes::ScopeBase*
+    // cppcheck-suppress unusedFunction
+    UNITY_API_SCOPE_CREATE_FUNCTION()
+    {
+        return new MyScope;
+    }
+
+    EXPORT
+    void
+    // cppcheck-suppress unusedFunction
+    UNITY_API_SCOPE_DESTROY_FUNCTION(unity::api::scopes::ScopeBase* scope_base)
+    {
+        delete scope_base;
+    }
+
+}

=== added file 'demo/scope-C.cpp'
--- demo/scope-C.cpp	1970-01-01 00:00:00 +0000
+++ demo/scope-C.cpp	2013-08-05 06:40:36 +0000
@@ -0,0 +1,104 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#include <unity/api/scopes/ScopeBase.h>
+
+#include <condition_variable>
+#include <iostream>
+#include <list>
+#include <mutex>
+
+#define EXPORT __attribute__ ((visibility ("default")))
+
+using namespace std;
+using namespace unity::api::scopes;
+
+// Example scope C: replies asynchronously to a query from a worker thread.
+
+class MyScope : public ScopeBase
+{
+public:
+    virtual int start(RegistryProxy::SPtr const&) override
+    {
+        return VERSION;
+    }
+
+    virtual void stop() override {}
+
+    virtual void run() override
+    {
+        // Worker thread: gets queries from the queue and processes them.
+        for (;;)
+        {
+            std::unique_lock<std::mutex> lock(mutex_);
+            condvar_.wait(lock, [this] { return !queries_.empty(); });  // Wait until we have a query
+
+            auto qd = queries_.front();
+            queries_.pop_front();
+            qd.reply_proxy->send("scope-C: result 1 for query \"" + qd.query + "\"");
+            qd.reply_proxy->send("scope-C: result 2 for query \"" + qd.query + "\"");
+            qd.reply_proxy->send("scope-C: result 3 for query \"" + qd.query + "\"");
+            qd.reply_proxy->finished();
+
+            cout << "scope-C: query \"" << qd.query << "\" complete" << endl;
+        }
+    }
+
+    virtual void query(string const& q, ReplyProxy::SPtr const& reply) override
+    {
+        cout << "scope-C: received query string \"" << q << "\"" << endl;
+        {
+            // Add query to queue
+            std::lock_guard<std::mutex> lock(mutex_);
+            QueryData qd = { q, reply };
+            queries_.push_back(qd);
+        }
+        condvar_.notify_one();  // Wake up worker thread.
+    }
+
+private:
+    struct QueryData
+    {
+        std::string query;
+        ReplyProxy::SPtr reply_proxy;
+    };
+    std::list<QueryData> queries_;
+    std::mutex mutex_;
+    std::condition_variable condvar_;
+};
+
+extern "C"
+{
+
+    EXPORT
+    unity::api::scopes::ScopeBase*
+    // cppcheck-suppress unusedFunction
+    UNITY_API_SCOPE_CREATE_FUNCTION()
+    {
+        return new MyScope;
+    }
+
+    EXPORT
+    void
+    // cppcheck-suppress unusedFunction
+    UNITY_API_SCOPE_DESTROY_FUNCTION(unity::api::scopes::ScopeBase* scope_base)
+    {
+        delete scope_base;
+    }
+
+}

=== added file 'demo/scope-D.cpp'
--- demo/scope-D.cpp	1970-01-01 00:00:00 +0000
+++ demo/scope-D.cpp	2013-08-05 06:40:36 +0000
@@ -0,0 +1,103 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#include <unity/api/scopes/ScopeBase.h>
+
+#include <condition_variable>
+#include <iostream>
+#include <list>
+#include <mutex>
+
+#define EXPORT __attribute__ ((visibility ("default")))
+
+using namespace std;
+using namespace unity::api::scopes;
+
+// Example scope D: replies asynchronously to a query. (Replies are returned after returning from the query() method.)
+// Same as scope C, but does not make the call to finished() to show that this happens automatically when
+// the reply proxy goes out of scope.
+
+class MyScope : public ScopeBase
+{
+public:
+    virtual int start(RegistryProxy::SPtr const&) override
+    {
+        return VERSION;
+    }
+    virtual void stop() override {}
+    virtual void run() override
+    {
+        for (;;)
+        {
+            std::unique_lock<std::mutex> lock(mutex_);
+            condvar_.wait(lock, [this] { return !queries_.empty(); });
+            auto qd = queries_.front();
+            queries_.pop_front();
+            qd.reply_proxy->send("scope-D: result 1 for query \"" + qd.query + "\"");
+            qd.reply_proxy->send("scope-D: result 2 for query \"" + qd.query + "\"");
+            qd.reply_proxy->send("scope-D: result 3 for query \"" + qd.query + "\"");
+            qd.reply_proxy->send("scope-D: result 4 for query \"" + qd.query + "\"");
+            // qd.reply_proxy->finished();
+            // Call to finished() commented out here, just to show that it happens automatically.
+
+            cout << "scope-D: query \"" << qd.query << "\" complete" << endl;
+        }
+    }
+
+    virtual void query(string const& q, ReplyProxy::SPtr const& reply) override
+    {
+        cout << "scope-D: received query string \"" << q << "\"" << endl;
+        {
+            std::lock_guard<std::mutex> lock(mutex_);
+            QueryData qd = { q, reply };
+            queries_.push_back(qd);
+        }
+        condvar_.notify_one();
+    }
+
+private:
+    struct QueryData
+    {
+        std::string query;
+        ReplyProxy::SPtr reply_proxy;
+    };
+    std::list<QueryData> queries_;
+    std::mutex mutex_;
+    std::condition_variable condvar_;
+};
+
+extern "C"
+{
+
+    EXPORT
+    unity::api::scopes::ScopeBase*
+    // cppcheck-suppress unusedFunction
+    UNITY_API_SCOPE_CREATE_FUNCTION()
+    {
+        return new MyScope;
+    }
+
+    EXPORT
+    void
+    // cppcheck-suppress unusedFunction
+    UNITY_API_SCOPE_DESTROY_FUNCTION(unity::api::scopes::ScopeBase* scope_base)
+    {
+        delete scope_base;
+    }
+
+}

=== added file 'demo/scoperunner-A.cpp'
--- demo/scoperunner-A.cpp	1970-01-01 00:00:00 +0000
+++ demo/scoperunner-A.cpp	2013-08-05 06:40:36 +0000
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#include <unity/api/scopes/internal/RuntimeImpl.h>
+#include <unity/api/scopes/internal/ScopeLoader.h>
+#include <unity/api/scopes/internal/ScopeObject.h>
+#include <unity/UnityExceptions.h>
+
+#include <iostream>
+
+using namespace std;
+using namespace unity::api::scopes;
+using namespace unity::api::scopes::internal;
+
+int
+main(int, char**)
+{
+    // TODO: the hard-wired strings here need to be read from config.
+
+    string scope_name = string("scope-A");
+
+    try
+    {
+        RuntimeImpl::UPtr rt = RuntimeImpl::create(scope_name);
+        MiddlewareBase::SPtr mw = rt->factory()->create(scope_name, "Ice", "Ice.Config");
+        // TODO: Need to call start on mw?
+        ScopeLoader::SPtr loader = ScopeLoader::load(scope_name, "lib" + scope_name + ".so", rt->registry());
+        loader->start();
+        ScopeObject::SPtr scope(new ScopeObject(loader->scope_base()));
+        mw->add_scope_object(scope_name, scope);
+        // Call run here?
+        mw->wait_for_shutdown();
+    }
+
+    catch (unity::Exception const& e)
+    {
+        cerr << e.to_string() << endl;
+        return 1;
+    }
+
+    return 0;
+}

=== added file 'demo/scoperunner-BC.cpp'
--- demo/scoperunner-BC.cpp	1970-01-01 00:00:00 +0000
+++ demo/scoperunner-BC.cpp	2013-08-05 06:40:36 +0000
@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#include <unity/api/scopes/internal/RuntimeImpl.h>
+#include <unity/api/scopes/internal/ScopeLoader.h>
+#include <unity/api/scopes/internal/ScopeObject.h>
+#include <unity/UnityExceptions.h>
+
+#include <iostream>
+
+using namespace std;
+using namespace unity::api::scopes;
+using namespace unity::api::scopes::internal;
+
+int
+main(int, char**)
+{
+    // TODO: the hard-wired strings here need to be read from config.
+
+    string scope_nameB = string("scope-B");
+    string scope_nameC = string("scope-C");
+
+    try
+    {
+        RuntimeImpl::UPtr rtB = RuntimeImpl::create(scope_nameB);
+        MiddlewareBase::SPtr mwB = rtB->factory()->create(scope_nameB, "Ice", "Ice.Config");
+        ScopeLoader::SPtr loaderB = ScopeLoader::load(scope_nameB, "lib" + scope_nameB + ".so", rtB->registry());
+        loaderB->start();
+        ScopeObject::SPtr scopeB(new ScopeObject(loaderB->scope_base()));
+        mwB->add_scope_object(scope_nameB, scopeB);
+
+        RuntimeImpl::UPtr rtC = RuntimeImpl::create(scope_nameC);
+        MiddlewareBase::SPtr mwC = rtC->factory()->create(scope_nameC, "Ice", "Ice.Config");
+        ScopeLoader::SPtr loaderC = ScopeLoader::load(scope_nameC, "lib" + scope_nameC + ".so", rtC->registry());
+        loaderC->start();
+        ScopeObject::SPtr scopeC(new ScopeObject(loaderC->scope_base()));
+        mwC->add_scope_object(scope_nameC, scopeC);
+
+        mwB->wait_for_shutdown();
+        mwC->wait_for_shutdown();
+    }
+
+    catch (unity::Exception const& e)
+    {
+        cerr << e.to_string() << endl;
+        return 1;
+    }
+
+    return 0;
+}

=== added file 'demo/scoperunner-D.cpp'
--- demo/scoperunner-D.cpp	1970-01-01 00:00:00 +0000
+++ demo/scoperunner-D.cpp	2013-08-05 06:40:36 +0000
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#include <unity/api/scopes/internal/RuntimeImpl.h>
+#include <unity/api/scopes/internal/ScopeLoader.h>
+#include <unity/api/scopes/internal/ScopeObject.h>
+#include <unity/UnityExceptions.h>
+
+#include <iostream>
+
+using namespace std;
+using namespace unity::api::scopes;
+using namespace unity::api::scopes::internal;
+
+int
+main(int, char**)
+{
+    // TODO: the hard-wired strings here need to be read from config.
+
+    string scope_name = string("scope-D");
+
+    try
+    {
+        RuntimeImpl::UPtr rt = RuntimeImpl::create(scope_name);
+        MiddlewareBase::SPtr mw = rt->factory()->create(scope_name, "Ice", "Ice.Config");
+        // TODO: Need to call start on mw?
+        ScopeLoader::SPtr loader = ScopeLoader::load(scope_name, "lib" + scope_name + ".so", rt->registry());
+        loader->start();
+        ScopeObject::SPtr scope(new ScopeObject(loader->scope_base()));
+        mw->add_scope_object(scope_name, scope);
+        // Call run here?
+        mw->wait_for_shutdown();
+    }
+
+    catch (unity::Exception const& e)
+    {
+        cerr << e.to_string() << endl;
+        return 1;
+    }
+
+    return 0;
+}

=== modified file 'include/unity/CMakeLists.txt'
--- include/unity/CMakeLists.txt	2013-05-29 04:57:50 +0000
+++ include/unity/CMakeLists.txt	2013-08-05 06:40:36 +0000
@@ -1,8 +1,7 @@
 add_subdirectory(api)
 
 file(GLOB headers "${CMAKE_CURRENT_SOURCE_DIR}/*.h")
-file(GLOB internal_headers "${CMAKE_CURRENT_SOURCE_DIR}/internal/*.h")
 
 install(FILES ${headers} DESTINATION ${HDR_INSTALL_DIR}/unity)
 
-set(UNITY_SCOPES_LIB_HDRS ${UNITY_SCOPES_LIB_HDRS} ${headers} ${internal_headers} PARENT_SCOPE)
+set(UNITY_SCOPES_LIB_HDRS ${UNITY_SCOPES_LIB_HDRS} ${headers} PARENT_SCOPE)

=== modified file 'include/unity/api/CMakeLists.txt'
--- include/unity/api/CMakeLists.txt	2013-05-29 04:57:50 +0000
+++ include/unity/api/CMakeLists.txt	2013-08-05 06:40:36 +0000
@@ -1,8 +1,7 @@
 add_subdirectory(scopes)
 
 file(GLOB headers "${CMAKE_CURRENT_SOURCE_DIR}/*.h")
-file(GLOB internal_headers "${CMAKE_CURRENT_SOURCE_DIR}/internal/*.h")
 
-set(UNITY_SCOPES_LIB_HDRS ${UNITY_SCOPES_LIB_HDRS} ${headers} ${internal_headers} PARENT_SCOPE)
+set(UNITY_SCOPES_LIB_HDRS ${UNITY_SCOPES_LIB_HDRS} ${headers} PARENT_SCOPE)
 
 install(FILES ${headers} DESTINATION ${HDR_INSTALL_DIR}/unity/api/scopes)

=== added directory 'include/unity/api/internal'
=== removed directory 'include/unity/api/internal'
=== modified file 'include/unity/api/scopes/CMakeLists.txt'
--- include/unity/api/scopes/CMakeLists.txt	2013-05-29 04:57:50 +0000
+++ include/unity/api/scopes/CMakeLists.txt	2013-08-05 06:40:36 +0000
@@ -1,5 +1,6 @@
+add_subdirectory(internal)
+
 file(GLOB headers "${CMAKE_CURRENT_SOURCE_DIR}/*.h")
-file(GLOB internal_headers "${CMAKE_CURRENT_SOURCE_DIR}/internal/*.h")
 
 #
 # Generated headers
@@ -9,4 +10,4 @@
 
 install(FILES ${headers} DESTINATION ${HDR_INSTALL_DIR}/unity/scopes)
 
-set(UNITY_SCOPES_LIB_HDRS ${UNITY_SCOPES_LIB_HDRS} ${headers} ${internal_headers} PARENT_SCOPE)
+set(UNITY_SCOPES_LIB_HDRS ${UNITY_SCOPES_LIB_HDRS} ${headers} PARENT_SCOPE)

=== added file 'include/unity/api/scopes/ObjectProxy.h'
--- include/unity/api/scopes/ObjectProxy.h	1970-01-01 00:00:00 +0000
+++ include/unity/api/scopes/ObjectProxy.h	2013-08-05 06:40:36 +0000
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#ifndef UNITY_API_SCOPES_OBJECTPROXY_H
+#define UNITY_API_SCOPES_OBJECTPROXY_H
+
+#include <unity/SymbolExport.h>
+#include <unity/util/DefinesPtrs.h>
+
+namespace unity
+{
+
+namespace api
+{
+
+namespace scopes
+{
+
+/**
+\brief Common base class for all proxies.
+*/
+
+class UNITY_API ObjectProxy
+{
+public:
+    /// @cond
+    UNITY_DEFINES_PTRS(ObjectProxy);
+    /// @endcond
+
+    virtual ~ObjectProxy() noexcept;
+
+protected:
+    ObjectProxy();
+};
+
+} // namespace scopes
+
+} // namespace api
+
+} // namespace unity
+
+#endif

=== added file 'include/unity/api/scopes/RegistryProxy.h'
--- include/unity/api/scopes/RegistryProxy.h	1970-01-01 00:00:00 +0000
+++ include/unity/api/scopes/RegistryProxy.h	2013-08-05 06:40:36 +0000
@@ -0,0 +1,83 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the Lesser GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * Lesser GNU General Public License for more details.
+ *
+ * You should have received a copy of the Lesser GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#ifndef UNITY_API_SCOPES_REGISTRYPROXY_H
+#define UNITY_API_SCOPES_REGISTRYPROXY_H
+
+#include <unity/api/scopes/ScopeProxy.h>
+
+#include <map>
+
+namespace unity
+{
+
+namespace api
+{
+
+namespace scopes
+{
+
+namespace internal
+{
+class RegistryProxyImpl;
+}
+
+/**
+\brief Map for scope name and proxy pairs.
+*/
+typedef std::map<std::string, ScopeProxy::SPtr> ScopeMap;
+
+/**
+\brief RegistryProxy provides access to the available scopes.
+You can obtain a proxy to the registry by calling Runtime::registry().
+*/
+
+class UNITY_API RegistryProxy : public ObjectProxy
+{
+public:
+    /// @cond
+    UNITY_DEFINES_PTRS(RegistryProxy);
+
+    virtual ~RegistryProxy() noexcept;
+    /// @endcond
+
+    /**
+    \brief Returns a ScopeProxy for the scope with the given name.
+    @return If no scope with the given name exists, the returned `shared_ptr` stores a `nullptr`.
+    */
+    ScopeProxy::SPtr find(std::string const& scope_name) const;
+
+    /**
+    \brief Returns a map containing the name/proxy pairs for all available scopes.
+    */
+    ScopeMap list() const;
+
+private:
+    RegistryProxy(internal::RegistryProxyImpl* impl);          // Only instantiable by RegistryProxyImpl
+    friend class internal::RegistryProxyImpl;
+
+    std::shared_ptr<internal::RegistryProxyImpl> p;
+};
+
+} // namespace scopes
+
+} // namespace api
+
+} // namespace unity
+
+#endif

=== added file 'include/unity/api/scopes/ReplyBase.h'
--- include/unity/api/scopes/ReplyBase.h	1970-01-01 00:00:00 +0000
+++ include/unity/api/scopes/ReplyBase.h	2013-08-05 06:40:36 +0000
@@ -0,0 +1,76 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the Lesser GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * Lesser GNU General Public License for more details.
+ *
+ * You should have received a copy of the Lesser GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#ifndef UNITY_API_SCOPES_REPLYBASE_H
+#define UNITY_API_SCOPES_REPLYBASE_H
+
+#include <unity/SymbolExport.h>
+#include <unity/util/DefinesPtrs.h>
+#include <unity/util/NonCopyable.h>
+
+#include <string>
+
+namespace unity
+{
+
+namespace api
+{
+
+namespace scopes
+{
+
+/**
+\brief Abstract base class to receive the results of a query.
+The scope application code must instantiate a class derived from ReplyBase and pass that instance as
+a parameter to the ScopeProxy::query() method. Once a query is sent, the scopes run time repeatedly
+invokes the send() method, once for each result returned by the query. Once a query is complete,
+the finished() method is called once, to inform the caller that the query is complete.
+*/
+
+class UNITY_API ReplyBase : private util::NonCopyable
+{
+public:
+    /// @cond
+    UNITY_DEFINES_PTRS(ReplyBase);
+
+    virtual ~ReplyBase() noexcept;
+    /// @endcond
+
+    /**
+    \brief Called once by the scopes run time for each result that is returned by a query().
+    */
+    virtual void send(std::string const& result) = 0;
+
+    /**
+    \brief Called once by the scopes run time after the final result for a query() was sent.
+    */
+    virtual void finished() = 0;
+
+protected:
+    /// @cond
+    ReplyBase();
+    /// @endcond
+};
+
+} // namespace scopes
+
+} // namespace api
+
+} // namespace unity
+
+#endif

=== added file 'include/unity/api/scopes/ReplyProxy.h'
--- include/unity/api/scopes/ReplyProxy.h	1970-01-01 00:00:00 +0000
+++ include/unity/api/scopes/ReplyProxy.h	2013-08-05 06:40:36 +0000
@@ -0,0 +1,86 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the Lesser GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * Lesser GNU General Public License for more details.
+ *
+ * You should have received a copy of the Lesser GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#ifndef UNITY_API_SCOPES_REPLYPROXY_H
+#define UNITY_API_SCOPES_REPLYPROXY_H
+
+#include <unity/api/scopes/ObjectProxy.h>
+
+namespace unity
+{
+
+namespace api
+{
+
+namespace scopes
+{
+
+namespace internal
+{
+class ReplyProxyImpl;
+}
+
+/**
+\brief ReplyProxy allows the results of a query to be sent to the source of the query.
+*/
+
+class UNITY_API ReplyProxy : public ObjectProxy
+{
+public:
+    /// @cond
+    UNITY_DEFINES_PTRS(ReplyProxy);
+    /// @endcond
+
+    /**
+    \brief Sends a single result to the source of a query.
+    Any calls to send() after finished() was called are ignored.
+    */
+    virtual void send(std::string const& result);
+
+    /**
+    \brief Informs the source of a query that the query results are complete.
+    Calling finished() informs the source of a query that the final result for the query
+    was sent, that is, that the query is complete.
+    The scope application code is responsible for calling finished() once it has sent the
+    final result for a query.
+    Multiple calls to finished() are ignored.
+    The destructor implicitly calls finished() if a ReplyProxy goes out of scope without
+    a prior call to finished().
+    */
+    virtual void finished();
+
+    /**
+    \brief Destroys a ReplyProxy.
+    If a ReplyProxy goes out of scope without a prior call to finished(), the destructor implicitly calls finished().
+    */
+    virtual ~ReplyProxy() noexcept;
+
+private:
+    ReplyProxy(internal::ReplyProxyImpl* impl);         // Only instantiable by ReplyProxyImpl
+    friend class internal::ReplyProxyImpl;
+
+    std::shared_ptr<internal::ReplyProxyImpl> p;
+};
+
+} // namespace scopes
+
+} // namespace api
+
+} // namespace unity
+
+#endif

=== added file 'include/unity/api/scopes/Runtime.h'
--- include/unity/api/scopes/Runtime.h	1970-01-01 00:00:00 +0000
+++ include/unity/api/scopes/Runtime.h	2013-08-05 06:40:36 +0000
@@ -0,0 +1,100 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the Lesser GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * Lesser GNU General Public License for more details.
+ *
+ * You should have received a copy of the Lesser GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#ifndef UNITY_API_SCOPES_RUNTIME_H
+#define UNITY_API_SCOPES_RUNTIME_H
+
+#include <unity/api/scopes/RegistryProxy.h>
+
+namespace unity
+{
+
+namespace api
+{
+
+namespace scopes
+{
+
+namespace internal
+{
+class RuntimeImpl;
+}
+
+/**
+\brief The main object to access the scopes run time.
+All interactions with the scopes run time require a Runtime object to be instantiated first. The Runtime instance
+controls the overall life cycle; once a Runtime instance goes out of scope, the application must not make further
+calls on any instance obtained via the destroyed Runtime.
+
+The application must instantiate a Runtime object only after `main()` is entered, and it must destroy the instance
+before leaving `main()`; failure to do so result in undefined behavior.
+*/
+
+class UNITY_API Runtime : private util::NonCopyable
+{
+public:
+    /// @cond
+    UNITY_DEFINES_PTRS(Runtime);
+    /// @endcond
+
+    /**
+    \brief The default configuration file (relative to the current directory) if none is passed to create().
+    */
+    static constexpr char const* DFLT_CONFIGFILE = "Scopes.ini";
+
+    /**
+    \brief Instantiates the scopes run time for the scope with the given name and (optional) configuration file.
+    The life time of the run time is under control of the caller. Letting the returned `unique_ptr` go out
+    of scope shuts down the run time.
+    */
+    static UPtr create(std::string const& scope_name, std::string const& configfile = DFLT_CONFIGFILE);
+
+    /**
+    \brief Shuts down the run time, reclaiming all associated resources.
+    Calling destroy() is optional; the destructor implicitly calls destroy() if it was not called explicitly.
+    However, no exceptions are thrown by the destructor. If you want to log or handle any exceptions during
+    shutdown, call destroy() explicitly before letting the `unique_ptr` returned by create() go out of scope.
+    */
+    void destroy();
+
+    /**
+    \brief Returns a proxy to the Registry object.
+    The returned proxy allows application code to interact with the registry, which provides access to the available
+    scopes.
+    */
+    RegistryProxy::SPtr registry() const;
+
+    /**
+    \brief Destroys a Runtime instance.
+    The destructor implicitly calls destroy() if the application code does not explicitly destroy the instance.
+    */
+    ~Runtime() noexcept;
+
+private:
+    Runtime(std::string const& scope_name, std::string const& configfile); // Instantiation only via create()
+
+    std::unique_ptr<internal::RuntimeImpl> p;
+};
+
+} // namespace scopes
+
+} // namespace api
+
+} // namespace unity
+
+#endif

=== modified file 'include/unity/api/scopes/ScopeBase.h'
--- include/unity/api/scopes/ScopeBase.h	2013-07-04 00:39:02 +0000
+++ include/unity/api/scopes/ScopeBase.h	2013-08-05 06:40:36 +0000
@@ -21,9 +21,12 @@
 
 #include <unity/SymbolExport.h>
 #include <unity/util/NonCopyable.h>
+#include <unity/api/scopes/RegistryProxy.h>
+#include <unity/api/scopes/ReplyProxy.h>
 #include <unity/api/scopes/Version.h>
 
 #include <memory>
+#include <iostream> // TODO:REMOVE THIS
 
 /**
 \brief Expands to the identifier of the scope create function. @hideinitializer
@@ -81,8 +84,9 @@
     MyScope();
     virtual ~MyScope();
 
-    virtual void start();
+    virtual int start();
     virtual void stop();
+    virtual void run();
 };
 ~~~
 
@@ -115,22 +119,33 @@
 
 After the Unity run time has obtained a pointer to the class instance from the create function, it calls start(),
 which allows the scope to intialize itself. Once start() returns, incoming query requests are dispatched to the scope.
-When the scope should complete its activities, the run time calls stop(). The calls to start() and
-stop() are made by the same thread.
+When the scope should complete its activities, the run time calls stop(). The calls to the create function, start(),
+stop(), and the destroy function) are made by the same thread. The call to run() is made by a _different_ thread.
 */
 
 class UNITY_API ScopeBase : private util::NonCopyable
 {
 public:
     /// @cond
-    virtual ~ScopeBase() {}
+    virtual ~ScopeBase();
     /// @endcond
 
     /**
+    \brief This value must be returned from the start() method.
+    */
+    static constexpr int VERSION = UNITY_SCOPES_VERSION_MAJOR;
+
+    /**
     \brief Called by the Unity run time after initialize() completes.
-    If start() throws an exception, stop() will _not_ be called (but finalize() _will_ be called).
+    If start() throws an exception, stop() will _not_ be called.
+
+    The call to start() is made by the same thread that calls the create function.
+
+    \return Any return value other than SCOPES_MAJOR_VERSION will cause the Unity run time
+    to refuse to load the scope. The return value is used to ensure that the shared library
+    containing the scope is ABI compatible with the Unity scopes run time.
     */
-    virtual void start() = 0;
+    virtual int start(RegistryProxy::SPtr const& registry) = 0;
 
     /**
     \brief Called by the Unity run time when the scope should shut down.
@@ -138,20 +153,30 @@
     deallocate any caches and close network connections.
 
     Exceptions from stop() are ignored.
+
+    The call to stop() is made by the same thread that calls the create function and start().
     */
     virtual void stop() = 0;
 
     /**
+    \brief Called by the Unity run time to hand a thread of control to the scope.
+    run() passes a thread of control to the scope to do with as it sees fit, for example, to run an event loop.
+
+    If run() throws an exception, stop() _will_ be called.
+
+    The call to run() is made by a separate thread (not the thread that calls the create function and start()).
+    */
+    virtual void run() = 0;
+
+    /**
     \brief Called by the Unity run time when scope should process a query.
-    The passed functor can be used to push the results, either synchronously, while query() is still running,
-    or asynchronously, after query() has returned.
-    */
-    virtual void query(std::string const& q, std::function<void(std::string const&)> callback) = 0;
+    TODO: complete documentation.
 
-    /**
-    \brief This method returns the version information for the scopes API that the scope was compiled with.
+    Calls to query() are made by an arbitrary thread. If the scope is configured to run single-threaded, all calls
+    to query() are made by the same thread. If the scope is configured to run multi-threaded, each call to query()
+    is made by an arbitrary thread, and several calls to query() may be made concurrently.
     */
-    void compiled_version(int& v_major, int& v_minor, int& v_micro) noexcept;
+    virtual void query(std::string const& q, ReplyProxy::SPtr const& reply) = 0;
 
     /**
     \brief This method returns the version information for the scopes API that the scope was linked with.
@@ -160,21 +185,10 @@
 
 protected:
     /// @cond
-    ScopeBase() = default;
+    ScopeBase();
     /// @endcond
 };
 
-// We inline this function so we are guaranteed to be returned the version of the scopes library that the derived
-// class was compiled with.
-
-inline
-void ScopeBase::compiled_version(int& v_major, int& v_minor, int& v_micro) noexcept
-{
-    v_major = UNITY_SCOPES_VERSION_MAJOR;
-    v_minor = UNITY_SCOPES_VERSION_MINOR;
-    v_micro = UNITY_SCOPES_VERSION_MICRO;
-}
-
 } // namespace scopes
 
 } // namespace api

=== modified file 'include/unity/api/scopes/ScopeExceptions.h'
--- include/unity/api/scopes/ScopeExceptions.h	2013-06-18 09:02:02 +0000
+++ include/unity/api/scopes/ScopeExceptions.h	2013-08-05 06:40:36 +0000
@@ -64,6 +64,40 @@
     virtual std::exception_ptr self() const override;
 };
 
+namespace internal
+{
+class ConfigExceptionImpl;
+}
+
+/**
+\brief Exception to indicate that something went wrong with the contents of configuration files.
+*/
+
+class UNITY_API ConfigException : public unity::Exception
+{
+public:
+    /**
+    \brief Constructs the exception.
+    \param reason Further details about the cause of the exception.
+    */
+    explicit ConfigException(std::string const& reason);
+    //! @cond
+    ConfigException(ConfigException const&);
+    ConfigException& operator=(ConfigException const&);
+    virtual ~ConfigException() noexcept;
+    //! @endcond
+
+    /**
+    \brief Returns the fully-qualified name of the exception.
+    */
+    virtual char const* what() const noexcept override;
+
+    /**
+    \brief Returns a <code>std::exception_ptr</code> to <code>this</code>.
+    */
+    virtual std::exception_ptr self() const override;
+};
+
 } // namespace scopes
 
 } // namespace api

=== added file 'include/unity/api/scopes/ScopeProxy.h'
--- include/unity/api/scopes/ScopeProxy.h	1970-01-01 00:00:00 +0000
+++ include/unity/api/scopes/ScopeProxy.h	2013-08-05 06:40:36 +0000
@@ -0,0 +1,80 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the Lesser GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * Lesser GNU General Public License for more details.
+ *
+ * You should have received a copy of the Lesser GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#ifndef UNITY_API_SCOPES_SCOPEPROXY_H
+#define UNITY_API_SCOPES_SCOPEPROXY_H
+
+#include <unity/api/scopes/ObjectProxy.h>
+#include <unity/api/scopes/ReplyBase.h>
+
+#include <string>
+
+namespace unity
+{
+
+namespace api
+{
+
+namespace scopes
+{
+
+namespace internal
+{
+class ScopeProxyImpl;
+}
+
+/**
+\brief Allows queries to be sent to a scope and results for the query to be retrieved.
+*/
+
+class UNITY_API ScopeProxy : public ObjectProxy
+{
+public:
+    /// @cond
+    UNITY_DEFINES_PTRS(ScopeProxy);
+    /// @endcond
+
+    /**
+    \brief Initiates a query.
+    The query() method expects an instance derived from ReplyBase, which it uses to return
+    the results for the query. query() is an asynchronous method, that is, it returns immediately;
+    results for the query typically will arrive only after the query() method completes (but may
+    also arrive while the query() method is still running.
+    */
+    void query(std::string const& q, ReplyBase::SPtr const& reply);
+
+    /**
+    \brief Destroys a ScopeProxy.
+    Destroying a ScopeProxy has no effect on any query that might still be in progress.
+    */
+    virtual ~ScopeProxy() noexcept;
+
+private:
+    ScopeProxy(internal::ScopeProxyImpl* impl);          // Only instantiable by ScopeProxyImpl
+    friend class internal::ScopeProxyImpl;
+
+    std::shared_ptr<internal::ScopeProxyImpl> p;
+};
+
+} // namespace scopes
+
+} // namespace api
+
+} // namespace unity
+
+#endif

=== modified file 'include/unity/api/scopes/Version.h.in'
--- include/unity/api/scopes/Version.h.in	2013-06-27 08:38:02 +0000
+++ include/unity/api/scopes/Version.h.in	2013-08-05 06:40:36 +0000
@@ -25,11 +25,24 @@
 #ifndef UNITY_API_SCOPES_VERSION_H
 #define UNITY_API_SCOPES_VERSION_H
 
-#define UNITY_SCOPES_VERSION_MAJOR @UNITY_SCOPES_MAJOR@
-#define UNITY_SCOPES_VERSION_MINOR @UNITY_SCOPES_MINOR@
-#define UNITY_SCOPES_VERSION_MICRO @UNITY_SCOPES_MICRO@
-
-#define UNITY_SCOPES_VERSION_STRING "@UNITY_SCOPES_VERSION@"
+#ifndef UNITY_SCOPES_VERSION_MAJOR
+#    define UNITY_SCOPES_VERSION_MAJOR @UNITY_SCOPES_MAJOR@
+#endif
+
+#ifndef UNITY_SCOPES_VERSION_MINOR
+#    define UNITY_SCOPES_VERSION_MINOR @UNITY_SCOPES_MINOR@
+#endif
+
+#ifndef UNITY_SCOPES_VERSION_MICRO
+#    define UNITY_SCOPES_VERSION_MICRO @UNITY_SCOPES_MICRO@
+#endif
+
+#define UNITY_SCOPES_VERSION_STR(s) #s
+#define UNITY_SCOPES_VERSION_XSTR(s) UNITY_SCOPES_VERSION_STR(s)
+
+#define UNITY_SCOPES_VERSION_STRING UNITY_SCOPES_VERSION_XSTR(UNITY_SCOPES_VERSION_MAJOR) "." \
+                                    UNITY_SCOPES_VERSION_XSTR(UNITY_SCOPES_VERSION_MINOR) "." \
+                                    UNITY_SCOPES_VERSION_XSTR(UNITY_SCOPES_VERSION_MICRO)
 
 /**
 \brief Top-level namespace for all things Unity-related.
@@ -54,12 +67,14 @@
 Version information is represented as
 <i>&lt;<code>major</code>&gt;</i>.<i>&lt;<code>minor</code>&gt;</i>.<i>&lt;<code>micro</code>&gt;</i>.
 
-Releases that differ in the major or minor version number are binary incompatible.
+Releases that differ in the major version number are binary incompatible.
 
-Releases of the library that differ only in the micro version number are binary compatible with older releases,
+Releases of the library that differ in the minor or micro version number are binary compatible with older releases,
 so client code does not need to be recompiled to use the newer library version.
 
 Changes in the micro version number indicate bug fixes.
+
+Changes in the minor version number indicate feature additions that are binary compatible.
 */
 
 /**
@@ -101,7 +116,7 @@
 /// @cond
 UNITY_API
 /// @endcond
-const char* str();    // Returns "major.minor.micro"
+const char* version_string();    // Returns "major.minor.micro"
 
 /// }@
 

=== added file 'include/unity/api/scopes/internal/AbstractObject.h'
--- include/unity/api/scopes/internal/AbstractObject.h	1970-01-01 00:00:00 +0000
+++ include/unity/api/scopes/internal/AbstractObject.h	2013-08-05 06:40:36 +0000
@@ -0,0 +1,56 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#ifndef UNITY_API_SCOPES_INTERNAL_ABSTRACTOBJECT_H
+#define UNITY_API_SCOPES_INTERNAL_ABSTRACTOBJECT_H
+
+#include <unity/util/DefinesPtrs.h>
+#include <unity/util/NonCopyable.h>
+
+namespace unity
+{
+
+namespace api
+{
+
+namespace scopes
+{
+
+namespace internal
+{
+
+class AbstractObject : private util::NonCopyable
+{
+public:
+    UNITY_DEFINES_PTRS(AbstractObject);
+
+    virtual ~AbstractObject() noexcept;
+
+protected:
+    AbstractObject();
+};
+
+} // namespace internal
+
+} // namespace scopes
+
+} // namespace api
+
+} // namespace unity
+
+#endif

=== added file 'include/unity/api/scopes/internal/CMakeLists.txt'
--- include/unity/api/scopes/internal/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ include/unity/api/scopes/internal/CMakeLists.txt	2013-08-05 06:40:36 +0000
@@ -0,0 +1,5 @@
+add_subdirectory(ice_middleware)
+
+file(GLOB headers "${CMAKE_CURRENT_SOURCE_DIR}/*.h")
+
+set(UNITY_SCOPES_LIB_HDRS ${UNITY_SCOPES_LIB_HDRS} ${headers} PARENT_SCOPE)

=== added file 'include/unity/api/scopes/internal/ConfigBase.h'
--- include/unity/api/scopes/internal/ConfigBase.h	1970-01-01 00:00:00 +0000
+++ include/unity/api/scopes/internal/ConfigBase.h	2013-08-05 06:40:36 +0000
@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#ifndef UNITY_API_SCOPES_INTERNAL_CONFIGBASE_H
+#define UNITY_API_SCOPES_INTERNAL_CONFIGBASE_H
+
+#include <unity/util/IniParser.h>
+
+namespace unity
+{
+
+namespace util
+{
+class IniParser;
+}
+
+namespace api
+{
+
+namespace scopes
+{
+
+namespace internal
+{
+
+class ConfigBase
+{
+public:
+    ConfigBase(std::string const& configfile);
+    virtual ~ConfigBase() noexcept;
+
+    unity::util::IniParser::SPtr parser() const noexcept;
+
+    virtual std::string get_string(std::string const& group, std::string const& key) const;
+    virtual std::string get_optional_string(std::string const& group, std::string const& key) const;
+    virtual std::string get_middleware(std::string const& group, std::string const& key) const;
+
+    virtual void throw_ex(::std::string const& reason) const;
+
+private:
+    unity::util::IniParser::SPtr parser_;
+    std::string configfile_;
+};
+
+} // namespace internal
+
+} // namespace scopes
+
+} // namespace api
+
+} // namespace unity
+
+#endif

=== modified file 'include/unity/api/scopes/internal/DynamicLoader.h'
--- include/unity/api/scopes/internal/DynamicLoader.h	2013-07-04 00:39:02 +0000
+++ include/unity/api/scopes/internal/DynamicLoader.h	2013-08-05 06:40:36 +0000
@@ -22,6 +22,8 @@
 #include <unity/util/DefinesPtrs.h>
 #include <unity/util/NonCopyable.h>
 
+#include <map>
+#include <mutex>
 #include <string>
 
 namespace unity
@@ -71,11 +73,19 @@
 //  int_func(5);
 //
 
-class UNITY_API DynamicLoader : public unity::util::DefinesPtrs<DynamicLoader>, private util::NonCopyable
+class UNITY_API DynamicLoader : private util::NonCopyable
 {
 public:
-    enum class Binding { lazy, now };
-    enum class Unload { automatic, noclose };
+    UNITY_DEFINES_PTRS(DynamicLoader);
+
+    enum class Binding
+    {
+        lazy, now
+    };
+    enum class Unload
+    {
+        automatic, noclose
+    };
 
     static UPtr create(std::string const& path, Binding b = Binding::lazy, Unload ul = Unload::automatic);
 
@@ -94,6 +104,10 @@
     std::string path_;
     void* handle_;
     Unload unload_;
+
+    typedef std::map<std::string, void*> LibraryHandles;
+    static LibraryHandles handles_;                        // Handles of libraries that will not be unloaded
+    static std::mutex mutex_;                              // Protects m_handle_map
 };
 
 } // namespace internal

=== added file 'include/unity/api/scopes/internal/MWObject.h'
--- include/unity/api/scopes/internal/MWObject.h	1970-01-01 00:00:00 +0000
+++ include/unity/api/scopes/internal/MWObject.h	2013-08-05 06:40:36 +0000
@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#ifndef UNITY_API_REPLYS_INTERNAL_MWOBJECT_H
+#define UNITY_API_REPLYS_INTERNAL_MWOBJECT_H
+
+#include <unity/util/DefinesPtrs.h>
+
+namespace unity
+{
+
+namespace api
+{
+
+namespace scopes
+{
+
+namespace internal
+{
+
+class MiddlewareBase;
+
+// Base class for the MW<something>Object hierarchy. We store the pointer to the middleware here,
+// which is needed to, for example, registry callback objects (such as a Reply object) with the middleware.
+
+class MWObject
+{
+public:
+    UNITY_DEFINES_PTRS(MWObject);
+
+    virtual ~MWObject() noexcept;
+
+    MiddlewareBase* mw_base() const noexcept;
+
+protected:
+    MWObject(MiddlewareBase* mw_base);
+
+private:
+    MiddlewareBase* mw_base_;
+};
+
+} // namespace internal
+
+} // namespace scopes
+
+} // namespace api
+
+} // namespace unity
+
+#endif

=== added file 'include/unity/api/scopes/internal/MWObjectProxy.h'
--- include/unity/api/scopes/internal/MWObjectProxy.h	1970-01-01 00:00:00 +0000
+++ include/unity/api/scopes/internal/MWObjectProxy.h	2013-08-05 06:40:36 +0000
@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the Lesser GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * Lesser GNU General Public License for more details.
+ *
+ * You should have received a copy of the Lesser GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#ifndef UNITY_API_SCOPES_INTERNAL_MWOBJECTPROXY_H
+#define UNITY_API_SCOPES_INTERNAL_MWOBJECTPROXY_H
+
+#include <unity/util/DefinesPtrs.h>
+
+namespace unity
+{
+
+namespace api
+{
+
+namespace scopes
+{
+
+namespace internal
+{
+
+class MiddlewareBase;
+
+// Base class for all MW<something>Proxy types. Its job is to make the abstract middleware pointer
+// available to all proxies, so it is possible to, for example, instantiate and add a new server-side
+// object to the middleware (as is needed for callback objects).
+
+class MWObjectProxy
+{
+public:
+    UNITY_DEFINES_PTRS(MWObjectProxy);
+
+    MiddlewareBase* mw_base() const noexcept;
+
+    virtual ~MWObjectProxy() noexcept;
+
+protected:
+    MWObjectProxy(MiddlewareBase* mw_base);
+
+private:
+    MiddlewareBase* mw_base_;
+};
+
+} // namespace internal
+
+} // namespace scopes
+
+} // namespace api
+
+} // namespace unity
+
+#endif

=== added file 'include/unity/api/scopes/internal/MWRegistryProxy.h'
--- include/unity/api/scopes/internal/MWRegistryProxy.h	1970-01-01 00:00:00 +0000
+++ include/unity/api/scopes/internal/MWRegistryProxy.h	2013-08-05 06:40:36 +0000
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the Lesser GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * Lesser GNU General Public License for more details.
+ *
+ * You should have received a copy of the Lesser GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#ifndef UNITY_API_SCOPES_INTERNAL_MWREGISTRYPROXY_H
+#define UNITY_API_SCOPES_INTERNAL_MWREGISTRYPROXY_H
+
+#include <unity/api/scopes/internal/MWObjectProxy.h>
+#include <unity/api/scopes/RegistryProxy.h>
+#include <unity/api/scopes/ScopeProxy.h>
+
+namespace unity
+{
+
+namespace api
+{
+
+namespace scopes
+{
+
+namespace internal
+{
+
+class MWRegistryProxy : public MWObjectProxy
+{
+public:
+    UNITY_DEFINES_PTRS(MWRegistryProxy);
+
+    // Remote operation implementation
+    virtual ScopeProxy::SPtr find(std::string const& scope_name) = 0;
+    virtual ScopeMap list() = 0;
+
+    virtual ~MWRegistryProxy() noexcept;
+
+protected:
+    MWRegistryProxy(MiddlewareBase* mw_base);
+};
+
+} // namespace internal
+
+} // namespace scopes
+
+} // namespace api
+
+} // namespace unity
+
+#endif

=== added file 'include/unity/api/scopes/internal/MWReplyProxy.h'
--- include/unity/api/scopes/internal/MWReplyProxy.h	1970-01-01 00:00:00 +0000
+++ include/unity/api/scopes/internal/MWReplyProxy.h	2013-08-05 06:40:36 +0000
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the Lesser GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * Lesser GNU General Public License for more details.
+ *
+ * You should have received a copy of the Lesser GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#ifndef UNITY_API_SCOPES_INTERNAL_MWREPLYPROXY_H
+#define UNITY_API_SCOPES_INTERNAL_MWREPLYPROXY_H
+
+#include <unity/api/scopes/internal/MWObjectProxy.h>
+#include <unity/api/scopes/ReplyProxy.h>
+
+namespace unity
+{
+
+namespace api
+{
+
+namespace scopes
+{
+
+namespace internal
+{
+
+class MWReplyProxy : public MWObjectProxy
+{
+public:
+    UNITY_DEFINES_PTRS(MWReplyProxy);
+
+    virtual ~MWReplyProxy() noexcept;
+
+    virtual void send(std::string const& result) = 0;
+    virtual void finished() = 0;
+
+protected:
+    MWReplyProxy(MiddlewareBase* mw_base);
+};
+
+} // namespace internal
+
+} // namespace scopes
+
+} // namespace api
+
+} // namespace unity
+
+#endif

=== added file 'include/unity/api/scopes/internal/MWScopeProxy.h'
--- include/unity/api/scopes/internal/MWScopeProxy.h	1970-01-01 00:00:00 +0000
+++ include/unity/api/scopes/internal/MWScopeProxy.h	2013-08-05 06:40:36 +0000
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the Lesser GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * Lesser GNU General Public License for more details.
+ *
+ * You should have received a copy of the Lesser GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#ifndef UNITY_API_SCOPES_INTERNAL_MWSCOPEPROXY_H
+#define UNITY_API_SCOPES_INTERNAL_MWSCOPEPROXY_H
+
+#include <unity/api/scopes/internal/MWReplyProxy.h>
+
+namespace unity
+{
+
+namespace api
+{
+
+namespace scopes
+{
+
+namespace internal
+{
+
+class MWScopeProxy : public MWObjectProxy
+{
+public:
+    UNITY_DEFINES_PTRS(MWScopeProxy);
+
+    virtual ~MWScopeProxy() noexcept;
+
+    virtual void query(std::string const& q, MWReplyProxy::SPtr const& reply) = 0;
+
+protected:
+    MWScopeProxy(MiddlewareBase* mw_base);
+};
+
+} // namespace internal
+
+} // namespace scopes
+
+} // namespace api
+
+} // namespace unity
+
+#endif

=== modified file 'include/unity/api/scopes/internal/MiddlewareBase.h'
--- include/unity/api/scopes/internal/MiddlewareBase.h	2013-06-18 09:02:02 +0000
+++ include/unity/api/scopes/internal/MiddlewareBase.h	2013-08-05 06:40:36 +0000
@@ -19,8 +19,10 @@
 #ifndef UNITY_API_SCOPES_INTERNAL_MIDDLEWAREBASE_H
 #define UNITY_API_SCOPES_INTERNAL_MIDDLEWAREBASE_H
 
-#include <unity/util/DefinesPtrs.h>
-#include <unity/util/NonCopyable.h>
+#include <unity/api/scopes/internal/MWRegistryProxy.h>
+#include <unity/api/scopes/internal/RegistryObject.h>
+#include <unity/api/scopes/internal/ReplyObject.h>
+#include <unity/api/scopes/internal/ScopeObject.h>
 
 namespace unity
 {
@@ -31,21 +33,35 @@
 namespace scopes
 {
 
+class ScopeBase;
+
 namespace internal
 {
 
 // Abstract base class for our middleware transport. Any control functions we need can be added here
 // as pure virtual functions. This is used by the remainder of the code to do things to the middleware
-// without knowing which middleware it actually is (strategy pattern).
+// without knowing which middleware it actually is.
 
-class MiddlewareBase : public util::DefinesPtrs<MiddlewareBase>, private util::NonCopyable
+class MiddlewareBase : private util::NonCopyable
 {
 public:
+    UNITY_DEFINES_PTRS(MiddlewareBase);
+
     MiddlewareBase();
     virtual ~MiddlewareBase() noexcept;
 
-    virtual void start(std::string const& scope_name) = 0;
+    virtual void start() = 0;
     virtual void stop() = 0;
+    virtual void wait_for_shutdown() = 0;
+
+    virtual MWRegistryProxy::SPtr create_registry_proxy(std::string const& identity, std::string const& endpoint) = 0;
+    virtual MWScopeProxy::SPtr create_scope_proxy(std::string const& identity, std::string const& endpoint) = 0;
+
+    virtual MWRegistryProxy::SPtr add_registry_object(std::string const& identity, RegistryObject::SPtr const& registry) = 0;
+    virtual MWScopeProxy::SPtr add_scope_object(std::string const& identity, ScopeObject::SPtr const& scope) = 0;
+    virtual MWReplyProxy::SPtr add_reply_object(ReplyObject::SPtr const& reply) = 0;
+
+    virtual void remove_object(std::string const& identity) = 0;
 };
 
 } // namespace internal

=== added file 'include/unity/api/scopes/internal/MiddlewareFactory.h'
--- include/unity/api/scopes/internal/MiddlewareFactory.h	1970-01-01 00:00:00 +0000
+++ include/unity/api/scopes/internal/MiddlewareFactory.h	2013-08-05 06:40:36 +0000
@@ -0,0 +1,100 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#ifndef UNITY_API_SCOPES_INTERNAL_MIDDLEWAREFACTORY_H
+#define UNITY_API_SCOPES_INTERNAL_MIDDLEWAREFACTORY_H
+
+#include <unity/api/scopes/internal/MiddlewareBase.h>
+
+namespace unity
+{
+
+namespace api
+{
+
+namespace scopes
+{
+
+namespace internal
+{
+
+// Factory to make middleware instances available.
+//
+// The lookup functions for the client-side use lazy initialization. The middleware
+// instance is created when caller first asks for it, and the same single instance
+// is always returned thereafter. The client-side middleware(s) are shut down when the factory
+// is destroyed.
+//
+// The create functions for the server-side pass ownership to the caller.
+//
+// This class is thread-safe.
+
+class MiddlewareFactory final : private util::NonCopyable
+{
+public:
+    UNITY_DEFINES_PTRS(MiddlewareFactory);
+
+    MiddlewareFactory(std::string const& configfile);
+    ~MiddlewareFactory() noexcept;
+
+    // Returns the middleware with the given name and kind. If that middleware hasn't been created yet,
+    // it is created first.
+    MiddlewareBase::SPtr create(std::string const& server_name,
+                                std::string const& kind,
+                                std::string const& configfile) const;
+
+    // Find the middleware with the given name and kind. Returns nullptr if that middleware doesn't exist.
+    MiddlewareBase::SPtr find(std::string const& server_name, std::string const& kind) const;
+
+private:
+    MiddlewareBase::SPtr find_unlocked(std::string const& server_name, std::string const& kind) const;
+
+    enum Kind { Kind_Ice, Kind_REST };
+    static Kind to_kind(::std::string const& kind);
+
+    struct MiddlewareData
+    {
+        std::string server_name;
+        std::string kind;
+
+        struct Compare
+        {
+            bool operator()(MiddlewareData const& lhs, MiddlewareData const& rhs) const
+            {
+                if (lhs.server_name < rhs.server_name)
+                {
+                    return true;
+                }
+                return lhs.kind < rhs.kind;
+            }
+        };
+    };
+
+    mutable std::map<MiddlewareData, MiddlewareBase::SPtr, MiddlewareData::Compare> mw_map_;
+    mutable std::mutex mutex_;
+};
+
+} // namespace internal
+
+} // namespace scopes
+
+} // namespace api
+
+} // namespace unity
+
+#endif

=== added file 'include/unity/api/scopes/internal/MiddlewareFactoryConfig.h'
--- include/unity/api/scopes/internal/MiddlewareFactoryConfig.h	1970-01-01 00:00:00 +0000
+++ include/unity/api/scopes/internal/MiddlewareFactoryConfig.h	2013-08-05 06:40:36 +0000
@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#ifndef UNITY_API_SCOPES_INTERNAL_MIDDLEWAREFACTORYCONFIG_H
+#define UNITY_API_SCOPES_INTERNAL_MIDDLEWAREFACTORYCONFIG_H
+
+#include <unity/api/scopes/internal/ConfigBase.h>
+
+namespace unity
+{
+
+namespace api
+{
+
+namespace scopes
+{
+
+namespace internal
+{
+
+class MiddlewareFactoryConfig : public ConfigBase
+{
+public:
+    static const char* MIDDLEWARE_FACTORY_CONFIG_GROUP;
+
+    MiddlewareFactoryConfig(std::string const& configfile);
+    ~MiddlewareFactoryConfig() noexcept;
+
+    std::string ice_configfile() const;
+    std::string rest_configfile() const;
+
+private:
+    std::string ice_configfile_;
+    std::string rest_configfile_;
+};
+
+} // namespace internal
+
+} // namespace scopes
+
+} // namespace api
+
+} // namespace unity
+
+#endif

=== added file 'include/unity/api/scopes/internal/ObjectProxyImpl.h'
--- include/unity/api/scopes/internal/ObjectProxyImpl.h	1970-01-01 00:00:00 +0000
+++ include/unity/api/scopes/internal/ObjectProxyImpl.h	2013-08-05 06:40:36 +0000
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#ifndef UNITY_INTERNAL_OBJECTPROXYIMPL_H
+#define UNITY_INTERNAL_OBJECTPROXYIMPL_H
+
+#include <unity/api/scopes/internal/MWObjectProxy.h>
+#include <unity/api/scopes/ObjectProxy.h>
+
+namespace unity
+{
+
+namespace api
+{
+
+namespace scopes
+{
+
+namespace internal
+{
+
+class ObjectProxyImpl final
+{
+public:
+    ObjectProxyImpl(MWObjectProxy::SPtr const& mw_proxy);
+    ~ObjectProxyImpl() noexcept;
+
+    static ObjectProxy::SPtr create(MWObjectProxy::SPtr const& mw_proxy);
+
+private:
+    MWObjectProxy::SPtr mw_proxy_;
+};
+
+} // namespace internal
+
+} // namespace scopes
+
+} // namespace api
+
+} // namespace unity
+
+#endif

=== added file 'include/unity/api/scopes/internal/RegistryConfig.h'
--- include/unity/api/scopes/internal/RegistryConfig.h	1970-01-01 00:00:00 +0000
+++ include/unity/api/scopes/internal/RegistryConfig.h	2013-08-05 06:40:36 +0000
@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#ifndef UNITY_API_SCOPES_INTERNAL_REGISTRYCONFIG_H
+#define UNITY_API_SCOPES_INTERNAL_REGISTRYCONFIG_H
+
+#include <unity/api/scopes/internal/ConfigBase.h>
+
+namespace unity
+{
+
+namespace api
+{
+
+namespace scopes
+{
+
+namespace internal
+{
+
+class RegistryConfig : public ConfigBase
+{
+public:
+    static constexpr char const* REGISTRY_CONFIG_GROUP = "Registry";
+
+    RegistryConfig(std::string const& identity, std::string const& configfile);
+    ~RegistryConfig() noexcept;
+
+    std::string identity() const;
+    std::string mw_kind() const;
+    std::string endpoint() const;
+    std::string mw_configfile() const;
+
+private:
+    std::string identity_;
+    std::string mw_kind_;
+    std::string endpoint_;
+    std::string mw_configfile_;
+};
+
+} // namespace internal
+
+} // namespace scopes
+
+} // namespace api
+
+} // namespace unity
+
+#endif

=== added file 'include/unity/api/scopes/internal/RegistryObject.h'
--- include/unity/api/scopes/internal/RegistryObject.h	1970-01-01 00:00:00 +0000
+++ include/unity/api/scopes/internal/RegistryObject.h	2013-08-05 06:40:36 +0000
@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#ifndef UNITY_API_SCOPES_INTERNAL_REGISTRYOBJECT_H
+#define UNITY_API_SCOPES_INTERNAL_REGISTRYOBJECT_H
+
+#include <unity/api/scopes/internal/AbstractObject.h>
+#include <unity/api/scopes/internal/MWScopeProxy.h>
+
+#include <map>
+#include <mutex>
+
+namespace unity
+{
+
+namespace api
+{
+
+namespace scopes
+{
+
+namespace internal
+{
+
+class RegistryObject final : public AbstractObject
+{
+public:
+    UNITY_DEFINES_PTRS(RegistryObject);
+
+    RegistryObject();
+    virtual ~RegistryObject() noexcept;
+
+    // Remote operation implementations
+    MWScopeProxy::SPtr find(std::string const& scope_name);
+
+    typedef std::map<std::string, MWScopeProxy::SPtr> MWScopeMap;
+    MWScopeMap list();
+
+    // Local operations to modify the map
+    void add(std::string const& scope_name, MWScopeProxy::SPtr const& scope);
+    void remove(std::string const& scope_name);
+
+private:
+    mutable MWScopeMap scopes_;
+    mutable std::mutex mutex_;
+};
+
+} // namespace internal
+
+} // namespace scopes
+
+} // namespace api
+
+} // namespace unity
+
+#endif

=== added file 'include/unity/api/scopes/internal/RegistryProxyImpl.h'
--- include/unity/api/scopes/internal/RegistryProxyImpl.h	1970-01-01 00:00:00 +0000
+++ include/unity/api/scopes/internal/RegistryProxyImpl.h	2013-08-05 06:40:36 +0000
@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#ifndef UNITY_INTERNAL_REGISTRYPROXYIMPL_H
+#define UNITY_INTERNAL_REGISTRYPROXYIMPL_H
+
+#include <unity/api/scopes/internal/MWRegistryProxy.h>
+#include <unity/api/scopes/RegistryProxy.h>
+
+#include <atomic>
+
+namespace unity
+{
+
+namespace api
+{
+
+namespace scopes
+{
+
+namespace internal
+{
+
+class RuntimeImpl;
+
+class RegistryProxyImpl final
+{
+public:
+    UNITY_DEFINES_PTRS(RegistryProxyImpl);
+
+    RegistryProxyImpl(MWRegistryProxy::SPtr const& mw_proxy);
+    ~RegistryProxyImpl() noexcept;
+
+    ScopeProxy::SPtr find(std::string const& scope_name);
+    ScopeMap list();
+
+    static RegistryProxy::SPtr create(MWRegistryProxy::SPtr const& mw_proxy);
+
+private:
+    MWRegistryProxy::SPtr mw_proxy_;
+};
+
+} // namespace internal
+
+} // namespace scopes
+
+} // namespace api
+
+} // namespace unity
+
+#endif

=== added file 'include/unity/api/scopes/internal/ReplyObject.h'
--- include/unity/api/scopes/internal/ReplyObject.h	1970-01-01 00:00:00 +0000
+++ include/unity/api/scopes/internal/ReplyObject.h	2013-08-05 06:40:36 +0000
@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#ifndef UNITY_API_REPLYS_INTERNAL_REPLYOBJECT_H
+#define UNITY_API_REPLYS_INTERNAL_REPLYOBJECT_H
+
+#include <unity/api/scopes/internal/AbstractObject.h>
+#include <unity/api/scopes/ReplyBase.h>
+
+#include <atomic>
+
+namespace unity
+{
+
+namespace api
+{
+
+namespace scopes
+{
+
+namespace internal
+{
+
+// A ReplyObject sits in between the incoming requests from the middleware layer and the
+// ReplyBase-derived implementation provided by the scope.
+// This allows us to intercept all replies.
+
+class ReplyObject final : public AbstractObject
+{
+public:
+    UNITY_DEFINES_PTRS(ReplyObject);
+
+    ReplyObject(ReplyBase::SPtr const& reply_base);
+    virtual ~ReplyObject() noexcept;
+
+    // Remote operation implementations
+    void send(std::string const& result);
+    void finished();
+
+private:
+    ReplyBase::SPtr reply_base_;
+    std::atomic_bool finished_;
+};
+
+} // namespace internal
+
+} // namespace scopes
+
+} // namespace api
+
+} // namespace unity
+
+#endif

=== added file 'include/unity/api/scopes/internal/ReplyProxyImpl.h'
--- include/unity/api/scopes/internal/ReplyProxyImpl.h	1970-01-01 00:00:00 +0000
+++ include/unity/api/scopes/internal/ReplyProxyImpl.h	2013-08-05 06:40:36 +0000
@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#ifndef UNITY_INTERNAL_REPLYPROXYIMPL_H
+#define UNITY_INTERNAL_REPLYPROXYIMPL_H
+
+#include <unity/api/scopes/internal/MWReplyProxy.h>
+
+#include <atomic>
+
+namespace unity
+{
+
+namespace api
+{
+
+namespace scopes
+{
+
+namespace internal
+{
+
+// Proxy used by a scope to push results for a query.
+// To indicate that it has sent the last result, the scope must call finished().
+// Subsequent calls to finished() are ignored.
+// Calls to send() after finished() was called are ignored.
+// If the proxy goes out of scope before finished was called, it implicitly calls finished().
+
+class ReplyProxyImpl final
+{
+public:
+    ReplyProxyImpl(MWReplyProxy::SPtr const& mw_proxy);
+    ~ReplyProxyImpl() noexcept;
+
+    void send(std::string const& result);
+    void finished();
+
+    static ReplyProxy::SPtr create(MWReplyProxy::SPtr const& mw_proxy);
+
+private:
+    MWReplyProxy::SPtr mw_proxy_;
+    std::atomic_bool finished_;
+};
+
+} // namespace internal
+
+} // namespace scopes
+
+} // namespace api
+
+} // namespace unity
+
+#endif

=== added file 'include/unity/api/scopes/internal/RuntimeConfig.h'
--- include/unity/api/scopes/internal/RuntimeConfig.h	1970-01-01 00:00:00 +0000
+++ include/unity/api/scopes/internal/RuntimeConfig.h	2013-08-05 06:40:36 +0000
@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#ifndef UNITY_API_SCOPES_INTERNAL_RUNTIMECONFIG_H
+#define UNITY_API_SCOPES_INTERNAL_RUNTIMECONFIG_H
+
+#include <unity/api/scopes/internal/ConfigBase.h>
+#include <unity/api/scopes/Runtime.h>
+
+namespace unity
+{
+
+namespace api
+{
+
+namespace scopes
+{
+
+namespace internal
+{
+
+class RuntimeConfig : public ConfigBase
+{
+public:
+    static const char* RUNTIME_CONFIG_GROUP;
+
+    RuntimeConfig(std::string const& configfile = Runtime::DFLT_CONFIGFILE);
+    ~RuntimeConfig() noexcept;
+
+    std::string registry_identity() const;
+    std::string registry_configfile() const;
+    std::string default_middleware() const;
+    std::string factory_configfile() const;
+
+private:
+    std::string registry_identity_;
+    std::string registry_configfile_;
+    std::string default_middleware_;
+    std::string factory_configfile_;
+};
+
+} // namespace internal
+
+} // namespace scopes
+
+} // namespace api
+
+} // namespace unity
+
+#endif

=== added file 'include/unity/api/scopes/internal/RuntimeImpl.h'
--- include/unity/api/scopes/internal/RuntimeImpl.h	1970-01-01 00:00:00 +0000
+++ include/unity/api/scopes/internal/RuntimeImpl.h	2013-08-05 06:40:36 +0000
@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#ifndef UNITY_API_SCOPES_INTERNAL_RUNTIMEIMPL_H
+#define UNITY_API_SCOPES_INTERNAL_RUNTIMEIMPL_H
+
+#include <unity/api/scopes/internal/MiddlewareBase.h>
+#include <unity/api/scopes/internal/MiddlewareFactory.h>
+#include <unity/api/scopes/Runtime.h>
+
+#include <atomic>
+
+namespace unity
+{
+
+namespace api
+{
+
+namespace scopes
+{
+
+namespace internal
+{
+
+class RuntimeImpl final : private util::NonCopyable
+{
+public:
+    UNITY_DEFINES_PTRS(RuntimeImpl);
+
+    static UPtr create(std::string const& scope_name, std::string const& configfile = Runtime::DFLT_CONFIGFILE);
+    void destroy();
+
+    MiddlewareFactory const* factory() const;
+    RegistryProxy::SPtr registry() const;
+    std::string registry_configfile() const;
+
+    ~RuntimeImpl() noexcept;
+
+private:
+    RuntimeImpl(std::string const& scope_name, std::string const& configfile);
+
+    std::atomic_bool destroyed_;
+    MiddlewareFactory::UPtr middleware_factory_;
+    MiddlewareBase::SPtr middleware_;
+    mutable RegistryProxy::SPtr registry_;
+    mutable std::string registry_configfile_;
+};
+
+} // namespace internal
+
+} // namespace scopes
+
+} // namespace api
+
+} // namespace unity
+
+#endif

=== added file 'include/unity/api/scopes/internal/ScopeExceptionsImpl.h'
--- include/unity/api/scopes/internal/ScopeExceptionsImpl.h	1970-01-01 00:00:00 +0000
+++ include/unity/api/scopes/internal/ScopeExceptionsImpl.h	2013-08-05 06:40:36 +0000
@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#ifndef UNITY_INTERNAL_SCOPEEXCEPTIONSIMPL_H
+#define UNITY_INTERNAL_SCOPEEXCEPTIONSIMPL_H
+
+#include <unity/Exception.h>
+
+#include <string>
+#include <exception>
+
+namespace unity
+{
+
+class Exception;
+
+namespace api
+{
+
+namespace scopes
+{
+
+namespace internal
+{
+
+class MiddlewareExceptionImpl : public Exception
+{
+public:
+    MiddlewareExceptionImpl(std::string const& reason);
+
+    virtual char const* what() const noexcept override;
+};
+
+class ConfigExceptionImpl : public Exception
+{
+public:
+    ConfigExceptionImpl(std::string const& reason);
+
+    virtual char const* what() const noexcept override;
+};
+
+} // namespace internal
+
+} // namespace scopes
+
+} // namespace api
+
+} // namespace unity
+
+#endif

=== modified file 'include/unity/api/scopes/internal/ScopeLoader.h'
--- include/unity/api/scopes/internal/ScopeLoader.h	2013-07-02 21:36:00 +0000
+++ include/unity/api/scopes/internal/ScopeLoader.h	2013-08-05 06:40:36 +0000
@@ -21,7 +21,6 @@
 
 #include <unity/api/scopes/ScopeBase.h>
 #include <unity/api/scopes/internal/DynamicLoader.h>
-#include <unity/api/scopes/internal/MiddlewareBase.h>
 
 #include <thread>
 #include <condition_variable>
@@ -38,37 +37,78 @@
 namespace internal
 {
 
-class ScopeLoader final : public unity::util::DefinesPtrs<ScopeLoader>
+// ScopeLoader loads the .so for a scope and TODO: complete this and updated comments below.
+
+class UNITY_API ScopeLoader final : public util::NonCopyable
 {
 public:
-    static UPtr load(std::string const& scope_name, std::string const& path, MiddlewareBase::SPtr& middleware);
-    void unload() noexcept;
-
+    UNITY_DEFINES_PTRS(ScopeLoader);
+
+    // Creates a ScopeLoader for a scope with the given name and library. We pass in the registry proxy
+    // so we can pass it to the scope's start method.
+    static UPtr load(std::string const& scope_name, std::string const& libpath, RegistryProxy::SPtr const& registry);
+
+    // unload() explicitly finalizes the scope. This is called by the destructor too, but calling it explicity
+    // allows the caller to receive any exceptions that may have been produced by the scope thread.
+    void unload();
+
+    // These methods start or stop a scope. They are asynchronous, that is, they don't wait until the scope is
+    // started or stopped; instead they just instruct the scope to do what it is told without waiting.
     void start();
     void stop();
 
+    // Returns the scope name
     std::string name() const noexcept;
+
+    // Returns the library path for the scope
     std::string libpath() const noexcept;
 
+    // Returns the actual implementation provided by the scope.
+    unity::api::scopes::ScopeBase* scope_base() const;
+
     ~ScopeLoader() noexcept;
 
 private:
-    ScopeLoader(std::string const& name, std::string const& path, MiddlewareBase::SPtr& middleware);
+    ScopeLoader(std::string const& name, std::string const& path, RegistryProxy::SPtr const& registry);
     void run_scope(unity::api::scopes::CreateFunction create_func, unity::api::scopes::DestroyFunction destroy_func);
     void handle_thread_exception();
 
+    void run_application(unity::api::scopes::ScopeBase* scope);
+    void notify_app_thread_started();
+
     std::string scope_name_;
+    unity::api::scopes::ScopeBase* scope_base_;
     unity::api::scopes::internal::DynamicLoader::UPtr dyn_loader_;
-    unity::api::scopes::internal::MiddlewareBase::SPtr middleware_;
+    unity::api::scopes::RegistryProxy::SPtr registry_;
+    std::exception_ptr exception_;
+
     std::thread scope_thread_;
 
-    enum class ScopeState { Created, Stopped, Started, Finished, Failed };
+    enum class ScopeState
+    {
+        Created, Stopped, Started, Finished, Failed
+    };
     ScopeState scope_state_;
     std::condition_variable state_changed_;
-    enum class ScopeCmd { None, Start, Stop, Finish };
-    ScopeCmd scope_cmd_;
+    mutable std::mutex state_mutex_;
+
+    enum class ScopeCmd
+    {
+        None, Start, Stop, Finish
+    };
+    ScopeCmd cmd_;
     std::condition_variable cmd_changed_;
-    std::mutex mutex_;
+    std::mutex cmd_mutex_;
+
+    std::thread run_thread_;
+
+    enum class AppState
+    {
+        Created, Started, Stopped
+    };
+    AppState run_thread_state_;
+    std::condition_variable run_thread_changed_;
+    std::mutex run_thread_mutex_;
 };
 
 } // namespace internal

=== added file 'include/unity/api/scopes/internal/ScopeLoader.h.bak'
--- include/unity/api/scopes/internal/ScopeLoader.h.bak	1970-01-01 00:00:00 +0000
+++ include/unity/api/scopes/internal/ScopeLoader.h.bak	2013-08-05 06:40:36 +0000
@@ -0,0 +1,96 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#ifndef UNITY_API_SCOPES_INTERNAL_SCOPELOADER_H
+#define UNITY_API_SCOPES_INTERNAL_SCOPELOADER_H
+
+#include <unity/api/scopes/ScopeBase.h>
+#include <unity/api/scopes/internal/DynamicLoader.h>
+#include <unity/api/scopes/internal/MiddlewareBase.h>
+
+#include <thread>
+#include <condition_variable>
+
+namespace unity
+{
+
+namespace api
+{
+
+namespace scopes
+{
+
+namespace internal
+{
+
+// ScopeLoader loads the .so for a scope and initializes the middleware that is used to communicate with
+// the scope.
+
+class ScopeLoader final
+{
+public:
+    UNITY_DEFINES_PTRS(ScopeLoader);
+
+    static UPtr load(std::string const& scope_name, std::string const& libpath, MiddlewareBase::SPtr& middleware);
+    void unload();
+
+    void start();
+    void stop();
+
+    std::string name() const noexcept;
+    std::string libpath() const noexcept;
+
+    ~ScopeLoader() noexcept;
+
+private:
+    ScopeLoader(std::string const& name, std::string const& path, MiddlewareBase::SPtr& middleware);
+    void run_scope(unity::api::scopes::CreateFunction create_func, unity::api::scopes::DestroyFunction destroy_func);
+    void handle_thread_exception();
+
+    void run_application(MiddlewareBase* middleware, unity::api::scopes::ScopeBase* scope);
+    void notify_app_thread_started();
+    void notify_app_thread_stopped();
+
+    std::string m_scope_name;
+    unity::api::scopes::internal::DynamicLoader::UPtr m_dyn_loader;
+    unity::api::scopes::internal::MiddlewareBase::SPtr m_middleware;
+    std::thread m_scope_thread;
+    std::thread m_application_thread;
+
+    enum class ScopeState { Created, Stopped, Started, Finished, Failed };
+    ScopeState m_scope_state;
+    std::condition_variable m_state_changed;
+    enum class ScopeCmd { None, Start, Stop, Finish };
+    ScopeCmd m_scope_cmd;
+    std::condition_variable m_cmd_changed;
+    std::mutex m_mutex;
+
+    bool m_app_thread_running;
+    std::condition_variable m_app_thread_changed;
+    std::mutex m_app_thread_mutex;
+};
+
+} // namespace internal
+
+} // namespace scopes
+
+} // namespace api
+
+} // namespace unity
+
+#endif

=== added file 'include/unity/api/scopes/internal/ScopeObject.h'
--- include/unity/api/scopes/internal/ScopeObject.h	1970-01-01 00:00:00 +0000
+++ include/unity/api/scopes/internal/ScopeObject.h	2013-08-05 06:40:36 +0000
@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#ifndef UNITY_API_SCOPES_INTERNAL_SCOPEOBJECT_H
+#define UNITY_API_SCOPES_INTERNAL_SCOPEOBJECT_H
+
+#include <unity/api/scopes/internal/AbstractObject.h>
+#include <unity/api/scopes/ReplyProxy.h>
+
+namespace unity
+{
+
+namespace api
+{
+
+namespace scopes
+{
+
+class ScopeBase;
+
+namespace internal
+{
+
+// A ScopeObject sits in between the incoming requests from the middleware layer and the
+// ScopeBase-derived implementation provided by the scope. It forwards incoming
+// queries to the actual scope. This allows us to intercept all queries for a scope.
+
+class ScopeObject final : public AbstractObject
+{
+public:
+    UNITY_DEFINES_PTRS(ScopeObject);
+
+    ScopeObject(ScopeBase* scope_base_);
+    virtual ~ScopeObject() noexcept;
+
+    // Remote operation implementations
+    void query(std::string const& q, ReplyProxy::SPtr const& reply);
+
+private:
+    ScopeBase* scope_base_;
+};
+
+} // namespace internal
+
+} // namespace scopes
+
+} // namespace api
+
+} // namespace unity
+
+#endif

=== added file 'include/unity/api/scopes/internal/ScopeProxyImpl.h'
--- include/unity/api/scopes/internal/ScopeProxyImpl.h	1970-01-01 00:00:00 +0000
+++ include/unity/api/scopes/internal/ScopeProxyImpl.h	2013-08-05 06:40:36 +0000
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#ifndef UNITY_INTERNAL_SCOPEPROXYIMPL_H
+#define UNITY_INTERNAL_SCOPEPROXYIMPL_H
+
+#include <unity/api/scopes/internal/MWScopeProxy.h>
+#include <unity/api/scopes/ScopeProxy.h>
+
+namespace unity
+{
+
+namespace api
+{
+
+namespace scopes
+{
+
+namespace internal
+{
+
+class RuntimeImpl;
+
+class ScopeProxyImpl final
+{
+public:
+    ScopeProxyImpl(MWScopeProxy::SPtr const& mw_proxy);
+    ~ScopeProxyImpl() noexcept;
+
+    void query(std::string const& q, ReplyBase::SPtr const& reply) const;
+
+    static ScopeProxy::SPtr create(MWScopeProxy::SPtr const& mw_proxy);
+
+private:
+    MWScopeProxy::SPtr mw_proxy_;
+};
+
+} // namespace internal
+
+} // namespace scopes
+
+} // namespace api
+
+} // namespace unity
+
+#endif

=== added directory 'include/unity/api/scopes/internal/ice_middleware'
=== added file 'include/unity/api/scopes/internal/ice_middleware/CMakeLists.txt'
--- include/unity/api/scopes/internal/ice_middleware/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ include/unity/api/scopes/internal/ice_middleware/CMakeLists.txt	2013-08-05 06:40:36 +0000
@@ -0,0 +1,3 @@
+file(GLOB headers "${CMAKE_CURRENT_SOURCE_DIR}/*.h")
+
+set(UNITY_SCOPES_LIB_HDRS ${UNITY_SCOPES_LIB_HDRS} ${headers} PARENT_SCOPE)

=== added file 'include/unity/api/scopes/internal/ice_middleware/IceMiddleware.h'
--- include/unity/api/scopes/internal/ice_middleware/IceMiddleware.h	1970-01-01 00:00:00 +0000
+++ include/unity/api/scopes/internal/ice_middleware/IceMiddleware.h	2013-08-05 06:40:36 +0000
@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#ifndef UNITY_API_SCOPES_INTERNAL_ICEMIDDLEWARE_ICEMIDDLEWARE_H
+#define UNITY_API_SCOPES_INTERNAL_ICEMIDDLEWARE_ICEMIDDLEWARE_H
+
+#include <unity/api/scopes/internal/ice_middleware/IceObjectProxy.h>
+#include <unity/api/scopes/internal/ice_middleware/IceReplyProxy.h>
+#include <unity/api/scopes/internal/MiddlewareBase.h>
+
+#include <Ice/CommunicatorF.h>
+#include <Ice/ObjectAdapterF.h>
+
+namespace unity
+{
+
+namespace api
+{
+
+namespace scopes
+{
+
+class ScopeBase;
+
+namespace internal
+{
+
+namespace ice_middleware
+{
+
+class IceMiddleware : public MiddlewareBase
+{
+public:
+    IceMiddleware(std::string const& server_name, std::string const& configfile);
+    virtual ~IceMiddleware() noexcept;
+
+    virtual void start() override;
+    virtual void stop() override;
+    virtual void wait_for_shutdown() override;
+
+    virtual MWRegistryProxy::SPtr create_registry_proxy(std::string const& identity, std::string const& endpoint) override;
+    virtual MWScopeProxy::SPtr create_scope_proxy(std::string const& identity, std::string const& endpoint) override;
+
+    virtual MWRegistryProxy::SPtr add_registry_object(std::string const& identity, RegistryObject::SPtr const& registry) override;
+    virtual MWScopeProxy::SPtr add_scope_object(std::string const& identity, ScopeObject::SPtr const& scope) override;
+    virtual MWReplyProxy::SPtr add_reply_object(ReplyObject::SPtr const& reply) override;
+
+    virtual void remove_object(std::string const& identity);
+
+private:
+    Ice::ObjectPrx safe_add(Ice::ObjectPtr const& obj, std::string const& identity = "");
+
+    std::string server_name_;
+    std::string configfile_;
+    Ice::CommunicatorPtr ic_;
+    Ice::ObjectAdapterPtr adapter_;
+    std::mutex mutex_;              // Protects adapter_
+};
+
+} // namespace ice_middleware
+
+} // namespace internal
+
+} // namespace scopes
+
+} // namespace api
+
+} // namespace unity
+
+#endif

=== added file 'include/unity/api/scopes/internal/ice_middleware/IceObjectProxy.h'
--- include/unity/api/scopes/internal/ice_middleware/IceObjectProxy.h	1970-01-01 00:00:00 +0000
+++ include/unity/api/scopes/internal/ice_middleware/IceObjectProxy.h	2013-08-05 06:40:36 +0000
@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the Lesser GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * Lesser GNU General Public License for more details.
+ *
+ * You should have received a copy of the Lesser GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#ifndef UNITY_API_SCOPES_INTERNAL_ICEMIDDLEWARE_ICEOBJECTPROXY_H
+#define UNITY_API_SCOPES_INTERNAL_ICEMIDDLEWARE_ICEOBJECTPROXY_H
+
+#include <unity/api/scopes/internal/MWObjectProxy.h>
+
+#include <Ice/Proxy.h>
+
+namespace unity
+{
+
+namespace api
+{
+
+namespace scopes
+{
+
+namespace internal
+{
+
+namespace ice_middleware
+{
+
+// An Ice proxy that points at some Ice object, but without a specific type.
+
+class IceObjectProxy : public MWObjectProxy
+{
+public:
+    UNITY_DEFINES_PTRS(IceObjectProxy);
+
+    IceObjectProxy(MiddlewareBase* mw_base, Ice::ObjectPrx const& p) noexcept;
+    ~IceObjectProxy() noexcept;
+
+    Ice::ObjectPrx proxy() const noexcept;
+
+private:
+    Ice::ObjectPrx proxy_;
+};
+
+} // namespace ice_middleware
+
+} // namespace internal
+
+} // namespace scopes
+
+} // namespace api
+
+} // namespace unity
+
+#endif

=== added file 'include/unity/api/scopes/internal/ice_middleware/IceRegistryProxy.h'
--- include/unity/api/scopes/internal/ice_middleware/IceRegistryProxy.h	1970-01-01 00:00:00 +0000
+++ include/unity/api/scopes/internal/ice_middleware/IceRegistryProxy.h	2013-08-05 06:40:36 +0000
@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the Lesser GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * Lesser GNU General Public License for more details.
+ *
+ * You should have received a copy of the Lesser GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#ifndef UNITY_API_SCOPES_INTERNAL_ICEMIDDLEWARE_ICEREGISTRYPROXY_H
+#define UNITY_API_SCOPES_INTERNAL_ICEMIDDLEWARE_ICEREGISTRYPROXY_H
+
+#include <slice/unity/api/scopes/internal/ice_middleware/Registry.h>
+#include <unity/api/scopes/internal/MWRegistryProxy.h>
+
+namespace unity
+{
+
+namespace api
+{
+
+namespace scopes
+{
+
+namespace internal
+{
+
+namespace ice_middleware
+{
+
+// Client-side registry proxy for Ice. The implementation forwards the invocations via Ice,
+// and translates the parameters and return value between the Ice types and the public types.
+
+class IceRegistryProxy : public MWRegistryProxy
+{
+public:
+    UNITY_DEFINES_PTRS(IceRegistryProxy);
+
+    IceRegistryProxy(MiddlewareBase* mw_base, Ice::ObjectPrx const& p) noexcept;
+    ~IceRegistryProxy() noexcept;
+
+    // Remote operations.
+    virtual ScopeProxy::SPtr find(std::string const& scope_name) override;
+    virtual ScopeMap list() override;
+
+private:
+    middleware::RegistryPrx proxy_; // Ice proxy for the registry
+};
+
+} // namespace ice_middleware
+
+} // namespace internal
+
+} // namespace scopes
+
+} // namespace api
+
+} // namespace unity
+
+#endif

=== added file 'include/unity/api/scopes/internal/ice_middleware/IceReplyProxy.h'
--- include/unity/api/scopes/internal/ice_middleware/IceReplyProxy.h	1970-01-01 00:00:00 +0000
+++ include/unity/api/scopes/internal/ice_middleware/IceReplyProxy.h	2013-08-05 06:40:36 +0000
@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the Lesser GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * Lesser GNU General Public License for more details.
+ *
+ * You should have received a copy of the Lesser GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#ifndef UNITY_API_SCOPES_INTERNAL_ICEMIDDLEWARE_ICEREPLYPROXY_H
+#define UNITY_API_SCOPES_INTERNAL_ICEMIDDLEWARE_ICEREPLYPROXY_H
+
+#include <slice/unity/api/scopes/internal/ice_middleware/Reply.h>
+#include <unity/api/scopes/internal/MWReplyProxy.h>
+
+namespace unity
+{
+
+namespace api
+{
+
+namespace scopes
+{
+
+namespace internal
+{
+
+namespace ice_middleware
+{
+
+class IceReplyProxy : public MWReplyProxy
+{
+public:
+    UNITY_DEFINES_PTRS(IceReplyProxy);
+
+    IceReplyProxy(MiddlewareBase* mw_base, Ice::ObjectPrx const& p) noexcept;
+    ~IceReplyProxy() noexcept;
+
+    virtual void send(std::string const& result) override;
+    virtual void finished() override;
+
+    middleware::ReplyPrx proxy() const noexcept;
+
+private:
+    middleware::ReplyPrx proxy_;
+};
+
+} // namespace ice_middleware
+
+} // namespace internal
+
+} // namespace scopes
+
+} // namespace api
+
+} // namespace unity
+
+#endif

=== added file 'include/unity/api/scopes/internal/ice_middleware/IceScopeProxy.h'
--- include/unity/api/scopes/internal/ice_middleware/IceScopeProxy.h	1970-01-01 00:00:00 +0000
+++ include/unity/api/scopes/internal/ice_middleware/IceScopeProxy.h	2013-08-05 06:40:36 +0000
@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the Lesser GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * Lesser GNU General Public License for more details.
+ *
+ * You should have received a copy of the Lesser GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#ifndef UNITY_API_SCOPES_INTERNAL_ICEMIDDLEWARE_ICESCOPEPROXY_H
+#define UNITY_API_SCOPES_INTERNAL_ICEMIDDLEWARE_ICESCOPEPROXY_H
+
+#include <slice/unity/api/scopes/internal/ice_middleware/Scope.h>
+#include <unity/api/scopes/internal/MWScopeProxy.h>
+
+namespace unity
+{
+
+namespace api
+{
+
+namespace scopes
+{
+
+namespace internal
+{
+
+namespace ice_middleware
+{
+
+class IceScopeProxy : public MWScopeProxy
+{
+public:
+    UNITY_DEFINES_PTRS(IceScopeProxy);
+
+    IceScopeProxy(MiddlewareBase* mw_base, Ice::ObjectPrx const& p) noexcept;
+    ~IceScopeProxy() noexcept;
+
+    void query(std::string const& q, MWReplyProxy::SPtr const& reply) override;
+
+    middleware::ScopePrx proxy() const noexcept;
+
+private:
+    middleware::ScopePrx proxy_;
+};
+
+} // namespace ice_middleware
+
+} // namespace internal
+
+} // namespace scopes
+
+} // namespace api
+
+} // namespace unity
+
+#endif

=== added file 'include/unity/api/scopes/internal/ice_middleware/RegistryI.h'
--- include/unity/api/scopes/internal/ice_middleware/RegistryI.h	1970-01-01 00:00:00 +0000
+++ include/unity/api/scopes/internal/ice_middleware/RegistryI.h	2013-08-05 06:40:36 +0000
@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#ifndef UNITY_API_SCOPES_INTERNAL_ICEMIDDLEWARE_REGISTRYI_H
+#define UNITY_API_SCOPES_INTERNAL_ICEMIDDLEWARE_REGISTRYI_H
+
+#include <slice/unity/api/scopes/internal/ice_middleware/Registry.h>
+#include <unity/api/scopes/internal/RegistryObject.h>
+
+namespace unity
+{
+
+namespace api
+{
+
+namespace scopes
+{
+
+namespace internal
+{
+
+namespace ice_middleware
+{
+
+// Server-side implementation of a Registry object, which maps scope names to scope proxies.
+// It provides remote lookup and listing of the map contents, and local methods to manipulate the map.
+//
+// This class is thread-safe: differnt threads can concurrently update the map while lookup operations
+// are in progress.
+
+class RegistryI : public middleware::Registry
+{
+public:
+    RegistryI(RegistryObject::SPtr const& ro);
+    virtual ~RegistryI() noexcept;
+
+    // Slice operations
+    virtual middleware::ScopePrx find(std::string const& name, Ice::Current const&) override;
+    virtual middleware::ScopeDict list(Ice::Current const&) override;
+
+private:
+    RegistryObject::SPtr ro_;
+};
+
+typedef IceUtil::Handle<RegistryI> RegistryIPtr;
+
+} // namespace ice_middleware
+
+} // namespace internal
+
+} // namespace scopes
+
+} // namespace api
+
+} // namespace unity
+
+#endif

=== added file 'include/unity/api/scopes/internal/ice_middleware/ReplyI.h'
--- include/unity/api/scopes/internal/ice_middleware/ReplyI.h	1970-01-01 00:00:00 +0000
+++ include/unity/api/scopes/internal/ice_middleware/ReplyI.h	2013-08-05 06:40:36 +0000
@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#ifndef UNITY_API_SCOPES_INTERNAL_ICEMIDDLEWARE_REPLYI_H
+#define UNITY_API_SCOPES_INTERNAL_ICEMIDDLEWARE_REPLYI_H
+
+#include <slice/unity/api/scopes/internal/ice_middleware/Reply.h>
+#include <unity/api/scopes/internal/ReplyObject.h>
+
+namespace unity
+{
+
+namespace api
+{
+
+namespace scopes
+{
+
+class ScopeBase;
+
+namespace internal
+{
+
+namespace ice_middleware
+{
+
+class ReplyI : public middleware::Reply
+{
+public:
+    ReplyI(ReplyObject::SPtr const& ro);
+
+    virtual void send(std::string const& result, Ice::Current const&) override;
+    virtual void finished(Ice::Current const&) override;
+
+private:
+    ReplyObject::SPtr ro_;
+    std::atomic_bool finished_;
+};
+
+typedef IceUtil::Handle<ReplyI> ReplyIPtr;
+
+} // namespace ice_middleware
+
+} // namespace internal
+
+} // namespace scopes
+
+} // namespace api
+
+} // namespace unity
+
+#endif

=== added file 'include/unity/api/scopes/internal/ice_middleware/RethrowException.h'
--- include/unity/api/scopes/internal/ice_middleware/RethrowException.h	1970-01-01 00:00:00 +0000
+++ include/unity/api/scopes/internal/ice_middleware/RethrowException.h	2013-08-05 06:40:36 +0000
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#ifndef UNITY_API_SCOPES_INTERNAL_ICEMIDDLEWARE_RETHROWEXCEPTION_H
+#define UNITY_API_SCOPES_INTERNAL_ICEMIDDLEWARE_RETHROWEXCEPTION_H
+
+#include <Ice/Exception.h>
+
+namespace unity
+{
+
+namespace api
+{
+
+namespace scopes
+{
+
+class ScopeBase;
+
+namespace internal
+{
+
+namespace ice_middleware
+{
+
+// Convert an Ice exception to a unity::MiddlewareException and throw it.
+
+void rethrow_ice_ex(Ice::Exception const& e);
+
+} // namespace ice_middleware
+
+} // namespace internal
+
+} // namespace scopes
+
+} // namespace api
+
+} // namespace unity
+
+#endif

=== added file 'include/unity/api/scopes/internal/ice_middleware/ScopeI.h'
--- include/unity/api/scopes/internal/ice_middleware/ScopeI.h	1970-01-01 00:00:00 +0000
+++ include/unity/api/scopes/internal/ice_middleware/ScopeI.h	2013-08-05 06:40:36 +0000
@@ -0,0 +1,70 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#ifndef UNITY_API_SCOPES_INTERNAL_ICEMIDDLEWARE_SCOPEI_H
+#define UNITY_API_SCOPES_INTERNAL_ICEMIDDLEWARE_SCOPEI_H
+
+#include <slice/unity/api/scopes/internal/ice_middleware/Scope.h>
+#include <unity/api/scopes/internal/ScopeObject.h>
+
+namespace unity
+{
+
+namespace api
+{
+
+namespace scopes
+{
+
+namespace internal
+{
+
+class MiddlewareBase;
+
+namespace ice_middleware
+{
+
+// Server-side implementation of a scope object.
+
+class ScopeI : public middleware::Scope
+{
+public:
+    ScopeI(MiddlewareBase* mw_base, ScopeObject::SPtr const& ro);
+    virtual ~ScopeI() noexcept;
+
+    // Slice operations
+    virtual void query(std::string const& q, middleware::ReplyPrx const& r, Ice::Current const&) override;
+
+private:
+    MiddlewareBase* mw_base_;
+    ScopeObject::SPtr so_;
+};
+
+typedef IceUtil::Handle<ScopeI> ScopeIPtr;
+
+} // namespace ice_middleware
+
+} // namespace internal
+
+} // namespace scopes
+
+} // namespace api
+
+} // namespace unity
+
+#endif

=== added directory 'include/unity/internal'
=== removed directory 'include/unity/internal'
=== added directory 'slice'
=== added file 'slice/CMakeLists.txt'
--- slice/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ slice/CMakeLists.txt	2013-08-05 06:40:36 +0000
@@ -0,0 +1,4 @@
+add_subdirectory(unity)
+
+file(GLOB sf "${CMAKE_CURRENT_SOURCE_DIR}/*.ice")
+set(SLICE_FILES ${SLICE_FILES} ${sf} PARENT_SCOPE)

=== added directory 'slice/unity'
=== added file 'slice/unity/CMakeLists.txt'
--- slice/unity/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ slice/unity/CMakeLists.txt	2013-08-05 06:40:36 +0000
@@ -0,0 +1,4 @@
+add_subdirectory(api)
+
+file(GLOB sf "${CMAKE_CURRENT_SOURCE_DIR}/*.ice")
+set(SLICE_FILES ${SLICE_FILES} ${sf} PARENT_SCOPE)

=== added directory 'slice/unity/api'
=== added file 'slice/unity/api/CMakeLists.txt'
--- slice/unity/api/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ slice/unity/api/CMakeLists.txt	2013-08-05 06:40:36 +0000
@@ -0,0 +1,4 @@
+add_subdirectory(scopes)
+
+file(GLOB sf "${CMAKE_CURRENT_SOURCE_DIR}/*.ice")
+set(SLICE_FILES ${SLICE_FILES} ${sf} PARENT_SCOPE)

=== added directory 'slice/unity/api/scopes'
=== added file 'slice/unity/api/scopes/CMakeLists.txt'
--- slice/unity/api/scopes/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ slice/unity/api/scopes/CMakeLists.txt	2013-08-05 06:40:36 +0000
@@ -0,0 +1,4 @@
+add_subdirectory(internal)
+
+file(GLOB sf "${CMAKE_CURRENT_SOURCE_DIR}/*.ice")
+set(SLICE_FILES ${SLICE_FILES} ${sf} PARENT_SCOPE)

=== added directory 'slice/unity/api/scopes/internal'
=== added file 'slice/unity/api/scopes/internal/CMakeLists.txt'
--- slice/unity/api/scopes/internal/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ slice/unity/api/scopes/internal/CMakeLists.txt	2013-08-05 06:40:36 +0000
@@ -0,0 +1,4 @@
+add_subdirectory(ice_middleware)
+
+file(GLOB sf "${CMAKE_CURRENT_SOURCE_DIR}/*.ice")
+set(SLICE_FILES ${SLICE_FILES} ${sf} PARENT_SCOPE)

=== added directory 'slice/unity/api/scopes/internal/ice_middleware'
=== added file 'slice/unity/api/scopes/internal/ice_middleware/CMakeLists.txt'
--- slice/unity/api/scopes/internal/ice_middleware/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ slice/unity/api/scopes/internal/ice_middleware/CMakeLists.txt	2013-08-05 06:40:36 +0000
@@ -0,0 +1,2 @@
+file(GLOB sf "${CMAKE_CURRENT_SOURCE_DIR}/*.ice")
+set(SLICE_FILES ${SLICE_FILES} ${sf} PARENT_SCOPE)

=== added file 'slice/unity/api/scopes/internal/ice_middleware/Registry.ice'
--- slice/unity/api/scopes/internal/ice_middleware/Registry.ice	1970-01-01 00:00:00 +0000
+++ slice/unity/api/scopes/internal/ice_middleware/Registry.ice	2013-08-05 06:40:36 +0000
@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+module unity
+{
+
+module api
+{
+
+module scopes
+{
+
+module internal
+{
+
+module middleware
+{
+
+interface Scope;
+
+dictionary<string, Scope*> ScopeDict;
+
+interface Registry
+{
+    Scope* find(string name);
+    ScopeDict list();
+};
+
+}; // ice_middleware
+
+}; // internal
+
+}; // scopes
+
+}; // api
+
+}; // unity

=== added file 'slice/unity/api/scopes/internal/ice_middleware/Reply.ice'
--- slice/unity/api/scopes/internal/ice_middleware/Reply.ice	1970-01-01 00:00:00 +0000
+++ slice/unity/api/scopes/internal/ice_middleware/Reply.ice	2013-08-05 06:40:36 +0000
@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+module unity
+{
+
+module api
+{
+
+module scopes
+{
+
+module internal
+{
+
+module middleware
+{
+
+interface Reply
+{
+    void send(string result);
+    void finished();
+};
+
+}; // ice_middleware
+
+}; // internal
+
+}; // scopes
+
+}; // api
+
+}; // unity

=== added file 'slice/unity/api/scopes/internal/ice_middleware/Scope.ice'
--- slice/unity/api/scopes/internal/ice_middleware/Scope.ice	1970-01-01 00:00:00 +0000
+++ slice/unity/api/scopes/internal/ice_middleware/Scope.ice	2013-08-05 06:40:36 +0000
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+module unity
+{
+
+module api
+{
+
+module scopes
+{
+
+module internal
+{
+
+module middleware
+{
+
+interface Reply;
+
+interface Scope
+{
+    void query(string q, Reply* r);
+};
+
+}; // ice_middleware
+
+}; // internal
+
+}; // scopes
+
+}; // api
+
+}; // unity

=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2013-06-25 01:19:40 +0000
+++ src/CMakeLists.txt	2013-08-05 06:40:36 +0000
@@ -1,31 +1,5 @@
 add_subdirectory(unity)
 
-# Pseudo-library of object files. We need a dynamic version of the library for normal clients,
-# and a static version for the whitebox tests, so we can write unit tests for classes in the internal namespaces
-# (because, for the .so, non-public APIs are compiled with -fvisibility=hidden).
-# Everything is compiled with -fPIC, so the same object files are suitable for either library.
-# Here, we create an object library that then is used to link the static and dynamic
-# libraries, without having to compile each source file twice with different compile flags.
-
-set(UNITY_SCOPES_LIB_OBJ ${UNITY_SCOPES_LIB}-obj)
-add_library(${UNITY_SCOPES_LIB_OBJ} OBJECT ${UNITY_SCOPES_LIB_SRC})
-set_target_properties(${UNITY_SCOPES_LIB_OBJ} PROPERTIES COMPILE_FLAGS "-fPIC")
-
-# Use the object files to make the shared library.
-set(UNITY_SCOPES_SOVERSION 0)
-add_library(${UNITY_SCOPES_LIB} SHARED $<TARGET_OBJECTS:${UNITY_SCOPES_LIB_OBJ}>)
-set_target_properties(${UNITY_SCOPES_LIB} PROPERTIES
-    VERSION "${UNITY_SCOPES_MAJOR}.${UNITY_SCOPES_MINOR}"
-    SOVERSION ${UNITY_SCOPES_SOVERSION}
-)
-
-# Use the object files to make the static library.
-add_library(${UNITY_SCOPES_STATIC_LIB} STATIC $<TARGET_OBJECTS:${UNITY_SCOPES_LIB_OBJ}>)
-set_target_properties(${UNITY_SCOPES_STATIC_LIB} PROPERTIES OUTPUT_NAME ${UNITY_SCOPES_LIB})
-
-# Only the dynamic library gets installed.
-install(TARGETS ${UNITY_SCOPES_LIB} LIBRARY DESTINATION ${LIB_INSTALL_PREFIX})
-
 # Set up package config.
 configure_file(lib${UNITY_SCOPES_LIB}.pc.in lib${UNITY_SCOPES_LIB}.pc @ONLY)
 install(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${UNITY_SCOPES_LIB}.pc DESTINATION ${LIB_INSTALL_PREFIX}/pkgconfig)

=== modified file 'src/unity/api/scopes/CMakeLists.txt'
--- src/unity/api/scopes/CMakeLists.txt	2013-06-18 09:02:02 +0000
+++ src/unity/api/scopes/CMakeLists.txt	2013-08-05 06:40:36 +0000
@@ -1,8 +1,14 @@
 add_subdirectory(internal)
 
 set(SRC
+    ${CMAKE_CURRENT_SOURCE_DIR}/ObjectProxy.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/RegistryProxy.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/ReplyBase.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/ReplyProxy.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/Runtime.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ScopeBase.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ScopeExceptions.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/ScopeProxy.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Version.cpp
 )
 

=== added file 'src/unity/api/scopes/ObjectProxy.cpp'
--- src/unity/api/scopes/ObjectProxy.cpp	1970-01-01 00:00:00 +0000
+++ src/unity/api/scopes/ObjectProxy.cpp	2013-08-05 06:40:36 +0000
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the Lesser GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * Lesser GNU General Public License for more details.
+ *
+ * You should have received a copy of the Lesser GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#include <unity/api/scopes/ObjectProxy.h>
+
+namespace unity
+{
+
+namespace api
+{
+
+namespace scopes
+{
+
+//! @cond
+
+ObjectProxy::ObjectProxy()
+{
+}
+
+ObjectProxy::~ObjectProxy() noexcept
+{
+}
+
+//! @endcond
+
+} // namespace scopes
+
+} // namespace api
+
+} // namespace unity

=== added file 'src/unity/api/scopes/RegistryProxy.cpp'
--- src/unity/api/scopes/RegistryProxy.cpp	1970-01-01 00:00:00 +0000
+++ src/unity/api/scopes/RegistryProxy.cpp	2013-08-05 06:40:36 +0000
@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the Lesser GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * Lesser GNU General Public License for more details.
+ *
+ * You should have received a copy of the Lesser GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#include <unity/api/scopes/RegistryProxy.h>
+#include <unity/api/scopes/internal/RegistryProxyImpl.h>
+
+namespace unity
+{
+
+namespace api
+{
+
+namespace scopes
+{
+
+//! @cond
+
+RegistryProxy::RegistryProxy(internal::RegistryProxyImpl* impl) :
+    p(impl)
+{
+}
+
+RegistryProxy::~RegistryProxy() noexcept
+{
+}
+
+//! @endcond
+
+ScopeProxy::SPtr RegistryProxy::find(std::string const& scope_name) const
+{
+    return p->find(scope_name);
+}
+
+ScopeMap RegistryProxy::list() const
+{
+    return p->list();
+}
+
+} // namespace scopes
+
+} // namespace api
+
+} // namespace unity

=== added file 'src/unity/api/scopes/ReplyBase.cpp'
--- src/unity/api/scopes/ReplyBase.cpp	1970-01-01 00:00:00 +0000
+++ src/unity/api/scopes/ReplyBase.cpp	2013-08-05 06:40:36 +0000
@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the Lesser GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * Lesser GNU General Public License for more details.
+ *
+ * You should have received a copy of the Lesser GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#include <unity/api/scopes/ReplyBase.h>
+
+using namespace std;
+
+namespace unity
+{
+
+namespace api
+{
+
+namespace scopes
+{
+
+//! @cond
+
+ReplyBase::ReplyBase()
+{
+}
+
+ReplyBase::~ReplyBase() noexcept
+{
+}
+
+//! @endcond
+
+} // namespace scopes
+
+} // namespace api
+
+} // namespace unity

=== added file 'src/unity/api/scopes/ReplyProxy.cpp'
--- src/unity/api/scopes/ReplyProxy.cpp	1970-01-01 00:00:00 +0000
+++ src/unity/api/scopes/ReplyProxy.cpp	2013-08-05 06:40:36 +0000
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the Lesser GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * Lesser GNU General Public License for more details.
+ *
+ * You should have received a copy of the Lesser GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#include <unity/api/scopes/ReplyProxy.h>
+
+#include <unity/api/scopes/internal/ReplyProxyImpl.h>
+
+namespace unity
+{
+
+namespace api
+{
+
+namespace scopes
+{
+
+//! @cond
+
+ReplyProxy::ReplyProxy(internal::ReplyProxyImpl* impl)
+    : p(impl)
+{
+}
+
+ReplyProxy::~ReplyProxy() noexcept
+{
+}
+
+void ReplyProxy::send(std::string const& result)
+{
+    return p->send(result);
+}
+
+void ReplyProxy::finished()
+{
+    return p->finished();
+}
+
+//! @endcond
+
+} // namespace scopes
+
+} // namespace api
+
+} // namespace unity

=== added file 'src/unity/api/scopes/Runtime.cpp'
--- src/unity/api/scopes/Runtime.cpp	1970-01-01 00:00:00 +0000
+++ src/unity/api/scopes/Runtime.cpp	2013-08-05 06:40:36 +0000
@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the Lesser GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * Lesser GNU General Public License for more details.
+ *
+ * You should have received a copy of the Lesser GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#include <unity/api/scopes/Runtime.h>
+
+#include <unity/api/scopes/internal/RuntimeImpl.h>
+
+using namespace std;
+
+namespace unity
+{
+
+namespace api
+{
+
+namespace scopes
+{
+
+constexpr char const* Runtime::DFLT_CONFIGFILE;
+
+//! @cond
+
+Runtime::Runtime(string const& scope_name, string const& configfile) :
+    p(internal::RuntimeImpl::create(scope_name, configfile))
+{
+}
+
+Runtime::~Runtime() noexcept
+{
+}
+
+//! @endcond
+
+Runtime::UPtr Runtime::create(string const& scope_name, string const& configfile)
+{
+    return UPtr(new Runtime(scope_name, configfile));
+}
+
+void Runtime::destroy()
+{
+    p->destroy();
+}
+
+RegistryProxy::SPtr Runtime::registry() const
+{
+    return p->registry();
+}
+
+} // namespace scopes
+
+} // namespace api
+
+} // namespace unity

=== modified file 'src/unity/api/scopes/ScopeBase.cpp'
--- src/unity/api/scopes/ScopeBase.cpp	2013-07-04 00:39:02 +0000
+++ src/unity/api/scopes/ScopeBase.cpp	2013-08-05 06:40:36 +0000
@@ -27,9 +27,19 @@
 namespace scopes
 {
 
-void
-ScopeBase::
-runtime_version(int& v_major, int& v_minor, int& v_micro) noexcept
+//! @cond
+
+ScopeBase::ScopeBase()
+{
+}
+
+ScopeBase::~ScopeBase()
+{
+}
+
+//! @endcond
+
+void ScopeBase::runtime_version(int& v_major, int& v_minor, int& v_micro) noexcept
 {
     v_major = unity::api::scopes::major_version();
     v_minor = unity::api::scopes::minor_version();

=== modified file 'src/unity/api/scopes/ScopeExceptions.cpp'
--- src/unity/api/scopes/ScopeExceptions.cpp	2013-06-25 01:19:40 +0000
+++ src/unity/api/scopes/ScopeExceptions.cpp	2013-08-05 06:40:36 +0000
@@ -56,7 +56,7 @@
 MiddlewareException::
 what() const noexcept
 {
-    return "unity::api::scopes::MiddleWareException";
+    return "unity::api::scopes::MiddlewareException";
 }
 
 exception_ptr
@@ -66,6 +66,41 @@
     return make_exception_ptr(*this);
 }
 
+ConfigException::
+ConfigException(string const& reason)
+    : Exception(make_shared<unity::ExceptionImplBase>(this, reason))
+{
+}
+
+ConfigException::
+ConfigException(ConfigException const&) = default;
+
+//! @cond
+
+ConfigException&
+ConfigException::
+operator=(ConfigException const&) = default;
+
+
+ConfigException::
+~ConfigException() noexcept = default;
+
+//! @endcond
+
+char const*
+ConfigException::
+what() const noexcept
+{
+    return "unity::api::scopes::ConfigException";
+}
+
+exception_ptr
+ConfigException::
+self() const
+{
+    return make_exception_ptr(*this);
+}
+
 } // namespace scopes
 
 } // namespace api

=== added file 'src/unity/api/scopes/ScopeProxy.cpp'
--- src/unity/api/scopes/ScopeProxy.cpp	1970-01-01 00:00:00 +0000
+++ src/unity/api/scopes/ScopeProxy.cpp	2013-08-05 06:40:36 +0000
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the Lesser GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * Lesser GNU General Public License for more details.
+ *
+ * You should have received a copy of the Lesser GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#include <unity/api/scopes/ScopeProxy.h>
+
+#include <unity/api/scopes/internal/ScopeProxyImpl.h>
+
+namespace unity
+{
+
+namespace api
+{
+
+namespace scopes
+{
+
+//! @cond
+
+ScopeProxy::ScopeProxy(internal::ScopeProxyImpl* impl) :
+    p(impl)
+{
+}
+
+ScopeProxy::~ScopeProxy() noexcept
+{
+}
+
+void ScopeProxy::query(std::string const& q, ReplyBase::SPtr const& reply)
+{
+    p->query(q, reply);
+}
+
+//! @endcond
+
+} // namespace scopes
+
+} // namespace api
+
+} // namespace unity

=== modified file 'src/unity/api/scopes/Version.cpp'
--- src/unity/api/scopes/Version.cpp	2013-07-02 00:58:04 +0000
+++ src/unity/api/scopes/Version.cpp	2013-08-05 06:40:36 +0000
@@ -44,7 +44,8 @@
     return UNITY_SCOPES_VERSION_MICRO;
 }
 
-char const* str()
+char const*
+version_string()
 {
     return UNITY_SCOPES_VERSION_STRING;
 }

=== added file 'src/unity/api/scopes/internal/AbstractObject.cpp'
--- src/unity/api/scopes/internal/AbstractObject.cpp	1970-01-01 00:00:00 +0000
+++ src/unity/api/scopes/internal/AbstractObject.cpp	2013-08-05 06:40:36 +0000
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the Lesser GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * Lesser GNU General Public License for more details.
+ *
+ * You should have received a copy of the Lesser GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#include <unity/api/scopes/internal/AbstractObject.h>
+
+namespace unity
+{
+
+namespace api
+{
+
+namespace scopes
+{
+
+namespace internal
+{
+
+AbstractObject::AbstractObject()
+{
+}
+
+AbstractObject::~AbstractObject() noexcept
+{
+}
+
+} // namespace internal
+
+} // namespace scopes
+
+} // namespace api
+
+} // namespace unity

=== modified file 'src/unity/api/scopes/internal/CMakeLists.txt'
--- src/unity/api/scopes/internal/CMakeLists.txt	2013-06-18 09:02:02 +0000
+++ src/unity/api/scopes/internal/CMakeLists.txt	2013-08-05 06:40:36 +0000
@@ -1,7 +1,38 @@
+add_subdirectory(ice_middleware)
+
 set(SRC
+    ${CMAKE_CURRENT_SOURCE_DIR}/AbstractObject.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/ConfigBase.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/DynamicLoader.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/MiddlewareBase.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/MiddlewareFactory.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/MiddlewareFactoryConfig.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/MWObject.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/MWObjectProxy.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/MWRegistryProxy.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/MWReplyProxy.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/MWScopeProxy.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/RegistryConfig.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/RegistryObject.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/RegistryProxyImpl.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/ReplyObject.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/ReplyProxyImpl.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/RuntimeConfig.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/RuntimeImpl.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ScopeLoader.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/ScopeObject.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/ScopeProxyImpl.cpp
 )
 
 set(UNITY_SCOPES_LIB_SRC ${UNITY_SCOPES_LIB_SRC} ${SRC} PARENT_SCOPE)
+
+set(CONFIG_FILE_PREFIX "var/unity/api/scopes/config")
+
+configure_file(Registry.config.in ${CMAKE_CURRENT_BINARY_DIR}/Registry.config)
+
+add_executable(scope-registry RegistryMain.cpp ice_middleware/RegistryI.cpp)
+target_link_libraries(scope-registry ${UNITY_SCOPES_LIB} ${OTHER_LIBS})
+