Add optional file output to FairMQSink

Warn on unknown --channel-config args
Update Copyright string
2025-10-15 17:41:45 +00:00 · 2021-03-01 15:33:45 +01:00 · 2021-03-01 08:37:57 +01:00 · 2021-03-01 08:37:57 +01:00 · 2021-02-19 09:54:29 +01:00 · 2021-02-10 10:36:08 +01:00
161 changed files with 1370 additions and 2001 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -18,11 +18,7 @@ get_git_version()
 project(FairMQ VERSION ${PROJECT_VERSION} LANGUAGES CXX)
 message(STATUS "${BWhite}${PROJECT_NAME}${CR} ${PROJECT_GIT_VERSION} from ${PROJECT_DATE}")

-if(BUILD_OFI_TRANSPORT OR BUILD_SDK OR BUILD_PMIX_PLUGIN)
-  set(PROJECT_MIN_CXX_STANDARD 14)
-else()
-  set(PROJECT_MIN_CXX_STANDARD 11)
-endif()
+set(PROJECT_MIN_CXX_STANDARD 17)

 set_fairmq_defaults()

@@ -82,7 +78,7 @@ endif()

 if(BUILD_DDS_PLUGIN OR BUILD_SDK)
  find_package2(PRIVATE DDS REQUIRED
-    VERSION 3.0
+    VERSION 3.5.3
  )
  set(DDS_Boost_COMPONENTS system log log_setup regex filesystem thread)
  set(DDS_Boost_VERSION 1.67)
@@ -136,7 +132,7 @@ endif()

 if(BUILD_SDK)
  find_package2(BUNDLED asio
-    VERSION 1.13.0
+    VERSION 1.18.0
  )
  if(NOT asio_FOUND)
    build_bundled(asio extern/asio)
@@ -262,7 +258,7 @@ install_cmake_package()

 # Summary ######################################################################
 message(STATUS "  ")
-message(STATUS "  ${Cyan}CXX STANDARD${CR}       ${BGreen}C++${CMAKE_CXX_STANDARD}${CR} (>= C++${PROJECT_MIN_CXX_STANDARD}, change with ${BMagenta}-DCMAKE_CXX_STANDARD=17${CR})")
+message(STATUS "  ${Cyan}CXX STANDARD${CR}       ${BGreen}C++${CMAKE_CXX_STANDARD}${CR} (>= C++${PROJECT_MIN_CXX_STANDARD}, change with ${BMagenta}-DCMAKE_CXX_STANDARD=20${CR})")
 if(CMAKE_CXX_FLAGS)
  message(STATUS "  ")
  message(STATUS "  ${Cyan}GLOBAL CXX FLAGS${CR}  ${BGreen}${CMAKE_CXX_FLAGS}${CR}")
@@ -365,9 +361,9 @@ else()
 endif()
 message(STATUS "  ${BWhite}tests${CR}              ${tests_summary}")
 if(BUILD_OFI_TRANSPORT)
-  set(ofi_summary "${BGreen}YES${CR}    EXPERIMENTAL (requires C++14) (disable with ${BMagenta}-DBUILD_OFI_TRANSPORT=OFF${CR})")
+  set(ofi_summary "${BGreen}YES${CR}    EXPERIMENTAL (disable with ${BMagenta}-DBUILD_OFI_TRANSPORT=OFF${CR})")
 else()
-  set(ofi_summary "${BRed} NO${CR}    EXPERIMENTAL (requires C++14) (default, enable with ${BMagenta}-DBUILD_OFI_TRANSPORT=ON${CR})")
+  set(ofi_summary "${BRed} NO${CR}    EXPERIMENTAL (default, enable with ${BMagenta}-DBUILD_OFI_TRANSPORT=ON${CR})")
 endif()
 message(STATUS "  ${BWhite}ofi_transport${CR}      ${ofi_summary}")
 if(BUILD_DDS_PLUGIN)
@@ -377,9 +373,9 @@ else()
 endif()
 message(STATUS "  ${BWhite}dds_plugin${CR}         ${dds_summary}")
 if(BUILD_PMIX_PLUGIN)
-  set(pmix_summary "${BGreen}YES${CR}    EXPERIMENTAL (requires C++14) (disable with ${BMagenta}-DBUILD_PMIX_PLUGIN=OFF${CR})")
+  set(pmix_summary "${BGreen}YES${CR}    EXPERIMENTAL (disable with ${BMagenta}-DBUILD_PMIX_PLUGIN=OFF${CR})")
 else()
-  set(pmix_summary "${BRed} NO${CR}    EXPERIMENTAL (requires C++14) (default, enable with ${BMagenta}-DBUILD_PMIX_PLUGIN=ON${CR})")
+  set(pmix_summary "${BRed} NO${CR}    EXPERIMENTAL (default, enable with ${BMagenta}-DBUILD_PMIX_PLUGIN=ON${CR})")
 endif()
 message(STATUS "  ${BWhite}pmix_plugin${CR}        ${pmix_summary}")
 if(BUILD_EXAMPLES)
@@ -395,9 +391,9 @@ else()
 endif()
 message(STATUS "  ${BWhite}docs${CR}               ${docs_summary}")
 if(BUILD_SDK)
-  set(sdk_summary "${BGreen}YES${CR}    EXPERIMENTAL (required C++14) (disable with ${BMagenta}-DBUILD_SDK=OFF${CR})")
+  set(sdk_summary "${BGreen}YES${CR}    EXPERIMENTAL (disable with ${BMagenta}-DBUILD_SDK=OFF${CR})")
 else()
-  set(sdk_summary "${BRed} NO${CR}    EXPERIMENTAL (required C++14) (default, enable with ${BMagenta}-DBUILD_SDK=ON${CR})")
+  set(sdk_summary "${BRed} NO${CR}    EXPERIMENTAL (default, enable with ${BMagenta}-DBUILD_SDK=ON${CR})")
 endif()
 message(STATUS "  ${BWhite}sdk${CR}                ${sdk_summary}")
 if(BUILD_SDK_COMMANDS)
@@ -432,9 +428,9 @@ message(STATUS "  ")
 message(STATUS "  ${Cyan}RUN STATIC ANALYSIS  ${static_ana_summary}")
 message(STATUS "  ")
 if(FAIRMQ_DEBUG_MODE)
-  message(STATUS "  ${Cyan}DEBUG_MODE${CR}         ${BGreen}${FAIRMQ_DEBUG_MODE}${CR} (disable with ${BMagenta}-DFAIRMQ_DEBUG_MODE=OFF${CR})")
+  message(STATUS "  ${Cyan}DEBUG MODE${CR}         ${BGreen}${FAIRMQ_DEBUG_MODE}${CR} (disable with ${BMagenta}-DFAIRMQ_DEBUG_MODE=OFF${CR})")
 else()
-  message(STATUS "  ${Cyan}DEBUG_MODE${CR}         ${BRed}${FAIRMQ_DEBUG_MODE}${CR} (enable with ${BMagenta}-DFAIRMQ_DEBUG_MODE=ON${CR})")
+  message(STATUS "  ${Cyan}DEBUG MODE${CR}         ${BRed}${FAIRMQ_DEBUG_MODE}${CR} (enable with ${BMagenta}-DFAIRMQ_DEBUG_MODE=ON${CR})")
 endif()
 message(STATUS "  ")
 ################################################################################
--- a/1
+++ b/1
@@ -8,5 +8,6 @@ Lebedev, Andrey
 Mrnjavac, Teo <teo.m@cern.ch>
 Neskovic, Gvozden
 Richter, Matthias
+Tacke, Christian
 Uhlig, Florian
 Wenzel, Sandro
--- a/FairMQTest.cmake
+++ b/FairMQTest.cmake
@@ -30,9 +30,6 @@ Set(configure_options "${configure_options};-DCMAKE_PREFIX_PATH=$ENV{SIMPATH}")
 Set(configure_options "${configure_options};-DBUILD_DDS_PLUGIN=ON")
 Set(configure_options "${configure_options};-DBUILD_SDK=ON")
 Set(configure_options "${configure_options};-DBUILD_SDK_COMMANDS=ON")
-Set(configure_options "${configure_options};-DFAST_BUILD=ON")
-Set(configure_options "${configure_options};-DCOTIRE_MAXIMUM_NUMBER_OF_UNITY_INCLUDES=-j$ENV{number_of_processors}")
-Set(configure_options "${configure_options};-DBoost_NO_BOOST_CMAKE=ON")

 Set(EXTRA_FLAGS $ENV{EXTRA_FLAGS})
 If(EXTRA_FLAGS)
@@ -60,8 +57,13 @@ Ctest_Configure(BUILD "${CTEST_BINARY_DIRECTORY}"

 Ctest_Build(BUILD "${CTEST_BINARY_DIRECTORY}")

+unset(exclude_tests)
+if($ENV{EXCLUDE_UNSTABLE_DDS_TESTS})
+  set(exclude_tests EXCLUDE ".*\\.localhost$")
+endif()
 Ctest_Test(BUILD "${CTEST_BINARY_DIRECTORY}"
           # PARALLEL_LEVEL $ENV{number_of_processors}
+           ${exclude_tests}
           PARALLEL_LEVEL $ENV{number_of_processors}
           RETURN_VALUE _ctest_test_ret_val
          )
--- a/10
+++ b/10
@@ -46,6 +46,11 @@ def jobMatrix(String prefix, List specs, Closure callback) {
            echo "export GIT_BRANCH=$JOB_BASE_NAME" >> Dart.cfg
            echo "echo \\\$PATH" >> Dart.cfg
          '''
+
+          if (os =~ /macOS10.14/) {
+            sh "echo \"export EXCLUDE_UNSTABLE_DDS_TESTS=1\" >> Dart.cfg"
+          }
+
          sh 'cat Dart.cfg'

          callback.call(spec, label)
@@ -74,8 +79,9 @@ pipeline{
      steps{
        script {
          def build_jobs = jobMatrix('build', [
-            [os: 'Debian8',    arch: 'x86_64', compiler: 'gcc9.1.0',        fairsoft: 'fairmq_dev'],
-            [os: 'macOS10.15', arch: 'x86_64', compiler: 'AppleLLVM11.0.3', fairsoft: 'fairmq_dev'],
+            [os: 'Debian8',    arch: 'x86_64', compiler: 'gcc9.1.0',       fairsoft: 'fairmq_dev'],
+            [os: 'macOS10.14', arch: 'x86_64', compiler: 'AppleClang11.0', fairsoft: 'fairmq_dev'],
+            [os: 'macOS10.15', arch: 'x86_64', compiler: 'AppleClang12.0', fairsoft: 'fairmq_dev'],
          ]) { spec, label ->
            sh './Dart.sh alfa_ci Dart.cfg'
          }
--- a/cmake/FindPMIx.cmake
+++ b/cmake/FindPMIx.cmake
@@ -6,28 +6,35 @@
 #                  copied verbatim in the file "LICENSE"                       #
 ################################################################################

+
+# The "lib/${CMAKE_LIBRARY_ARCHITECTURE}/pmix" part in all
+# the PATH_SUFFIXES is here to be able to find Debian's
+# libpmix-dev package. It installs everything below
+# /usr/lib/${CMAKE_LIBRARY_ARCHITECTURE}/pmix
+
+
 find_path(PMIx_INCLUDE_DIR
  NAMES pmix.h
  HINTS ${PMIX_ROOT} $ENV{PMIX_ROOT}
-  PATH_SUFFIXES include
+  PATH_SUFFIXES include lib/${CMAKE_LIBRARY_ARCHITECTURE}/pmix/include
 )

 find_path(PMIx_LIBRARY_DIR
  NAMES libpmix.dylib libpmix.so
  HINTS ${PMIX_ROOT} $ENV{PMIX_ROOT}
-  PATH_SUFFIXES lib lib64
+  PATH_SUFFIXES lib lib64 lib/${CMAKE_LIBRARY_ARCHITECTURE}/pmix/lib
 )

 find_library(PMIx_LIBRARY_SHARED
  NAMES libpmix.dylib libpmix.so
  HINTS ${PMIX_ROOT} $ENV{PMIX_ROOT}
-  PATH_SUFFIXES lib lib64
+  PATH_SUFFIXES lib lib64 lib/${CMAKE_LIBRARY_ARCHITECTURE}/pmix/lib
 )

 find_file(PMIx_VERSION_FILE
  NAMES pmix_version.h
  HINTS ${PMIX_ROOT} $ENV{PMIX_ROOT}
-  PATH_SUFFIXES include
+  PATH_SUFFIXES include lib/${CMAKE_LIBRARY_ARCHITECTURE}/pmix/include
 )

 file(READ "${PMIx_VERSION_FILE}" __version_raw)
--- a/extern/asio
+++ b/extern/asio
--- a/fairmq/DeviceRunner.cxx
+++ b/fairmq/DeviceRunner.cxx
@@ -56,7 +56,13 @@ bool DeviceRunner::HandleGeneralOptions(const fair::mq::ProgOptions& config, boo
            fair::Logger::SetConsoleSeverity("nolog");
        } else {
            fair::Logger::SetConsoleColor(color);
-            fair::Logger::SetConsoleSeverity(severity);
+            auto envFairMQSeverity = getenv("FAIRMQ_SEVERITY");
+            if (envFairMQSeverity) {
+                severity = envFairMQSeverity;
+            }
+            if (severity != "") {
+                fair::Logger::SetConsoleSeverity(severity);
+            }
        }

        if (printLogo) {
@@ -154,8 +160,8 @@ auto DeviceRunner::Run() -> int

    // Handle --version
    if (fConfig.Count("version")) {
-        cout << "FairMQ version: " << FAIRMQ_GIT_VERSION << endl;
-        cout << "User device version: " << fDevice->GetVersion() << endl;
+        LOGV(info, verylow) << "FairMQ version: " << FAIRMQ_GIT_VERSION;
+        LOGV(info, verylow) << "User device version: " << fDevice->GetVersion();
        fDevice->ChangeState(fair::mq::Transition::End);
        return 0;
    }
--- a/fairmq/DeviceRunner.h
+++ b/fairmq/DeviceRunner.h
@@ -19,8 +19,8 @@
 #include <string>
 #include <vector>

-namespace fair {
-namespace mq {
+namespace fair::mq
+{

 /**
 * @class DeviceRunner DeviceRunner.h <fairmq/DeviceRunner.h>
@@ -88,7 +88,6 @@ struct ModifyRawCmdLineArgs : Event<DeviceRunner&> {};
 struct InstantiateDevice : Event<DeviceRunner&> {};
 } /* namespace hooks */

-} /* namespace mq */
-} /* namespace fair */
+} // namespace fair::mq

 #endif /* FAIR_MQ_DEVICERUNNER_H */
--- a/fairmq/EventManager.h
+++ b/fairmq/EventManager.h
@@ -21,9 +21,7 @@
 #include <boost/functional/hash.hpp>
 #include <boost/signals2.hpp>

-namespace fair
-{
-namespace mq
+namespace fair::mq
 {

 // Inherit from this base event type to create custom event types
@@ -137,7 +135,6 @@ class EventManager
    }
 }; /* class EventManager */

-} /* namespace mq */
-} /* namespace fair */
+} // namespace fair::mq

 #endif /* FAIR_MQ_EVENTMANAGER_H */
--- a/fairmq/FairMQChannel.cxx
+++ b/fairmq/FairMQChannel.cxx
@@ -81,31 +81,30 @@ FairMQChannel::FairMQChannel(const string& name, const string& type, const strin
    , fPortRangeMin(DefaultPortRangeMin)
    , fPortRangeMax(DefaultPortRangeMax)
    , fAutoBind(DefaultAutoBind)
-    , fIsValid(false)
+    , fValid(false)
    , fMultipart(false)
-    , fModified(true)
-    , fReset(false)
-    , fMtx()
-{}
+{
+    // LOG(warn) << "Constructing channel '" << fName << "'";
+}

 FairMQChannel::FairMQChannel(const string& name, int index, const fair::mq::Properties& properties)
    : FairMQChannel(tools::ToString(name, "[", index, "]"), "unspecified", "unspecified", "unspecified", nullptr)
 {
    string prefix(tools::ToString("chans.", name, ".", index, "."));

-    fType = GetPropertyOrDefault(properties, string(prefix + "type"), fType);
-    fMethod = GetPropertyOrDefault(properties, string(prefix + "method"), fMethod);
-    fAddress = GetPropertyOrDefault(properties, string(prefix + "address"), fAddress);
-    fTransportType = TransportTypes.at(GetPropertyOrDefault(properties, string(prefix + "transport"), TransportNames.at(fTransportType)));
-    fSndBufSize = GetPropertyOrDefault(properties, string(prefix + "sndBufSize"), fSndBufSize);
-    fRcvBufSize = GetPropertyOrDefault(properties, string(prefix + "rcvBufSize"), fRcvBufSize);
-    fSndKernelSize = GetPropertyOrDefault(properties, string(prefix + "sndKernelSize"), fSndKernelSize);
-    fRcvKernelSize = GetPropertyOrDefault(properties, string(prefix + "rcvKernelSize"), fRcvKernelSize);
-    fLinger = GetPropertyOrDefault(properties, string(prefix + "linger"), fLinger);
-    fRateLogging = GetPropertyOrDefault(properties, string(prefix + "rateLogging"), fRateLogging);
-    fPortRangeMin = GetPropertyOrDefault(properties, string(prefix + "portRangeMin"), fPortRangeMin);
-    fPortRangeMax = GetPropertyOrDefault(properties, string(prefix + "portRangeMax"), fPortRangeMax);
-    fAutoBind = GetPropertyOrDefault(properties, string(prefix + "autoBind"), fAutoBind);
+    fType = GetPropertyOrDefault(properties, string(prefix + "type"), std::string(DefaultType));
+    fMethod = GetPropertyOrDefault(properties, string(prefix + "method"), std::string(DefaultMethod));
+    fAddress = GetPropertyOrDefault(properties, string(prefix + "address"), std::string(DefaultAddress));
+    fTransportType = TransportType(GetPropertyOrDefault(properties, string(prefix + "transport"), std::string(DefaultTransportName)));
+    fSndBufSize = GetPropertyOrDefault(properties, string(prefix + "sndBufSize"), DefaultSndBufSize);
+    fRcvBufSize = GetPropertyOrDefault(properties, string(prefix + "rcvBufSize"), DefaultRcvBufSize);
+    fSndKernelSize = GetPropertyOrDefault(properties, string(prefix + "sndKernelSize"), DefaultSndKernelSize);
+    fRcvKernelSize = GetPropertyOrDefault(properties, string(prefix + "rcvKernelSize"), DefaultRcvKernelSize);
+    fLinger = GetPropertyOrDefault(properties, string(prefix + "linger"), DefaultLinger);
+    fRateLogging = GetPropertyOrDefault(properties, string(prefix + "rateLogging"), DefaultRateLogging);
+    fPortRangeMin = GetPropertyOrDefault(properties, string(prefix + "portRangeMin"), DefaultPortRangeMin);
+    fPortRangeMax = GetPropertyOrDefault(properties, string(prefix + "portRangeMax"), DefaultPortRangeMax);
+    fAutoBind = GetPropertyOrDefault(properties, string(prefix + "autoBind"), DefaultAutoBind);
 }

 FairMQChannel::FairMQChannel(const FairMQChannel& chan)
@@ -129,10 +128,8 @@ FairMQChannel::FairMQChannel(const FairMQChannel& chan, const string& newName)
    , fPortRangeMin(chan.fPortRangeMin)
    , fPortRangeMax(chan.fPortRangeMax)
    , fAutoBind(chan.fAutoBind)
-    , fIsValid(false)
+    , fValid(false)
    , fMultipart(chan.fMultipart)
-    , fModified(chan.fModified)
-    , fReset(false)
 {}

 FairMQChannel& FairMQChannel::operator=(const FairMQChannel& chan)
@@ -141,372 +138,34 @@ FairMQChannel& FairMQChannel::operator=(const FairMQChannel& chan)
        return *this;
    }

-    {
-        // TODO: replace this with std::scoped_lock (c++17)
-        lock(fMtx, chan.fMtx);
-        lock_guard<mutex> lock1(fMtx, adopt_lock);
-        lock_guard<mutex> lock2(chan.fMtx, adopt_lock);
-
-        fTransportFactory = nullptr;
-        fTransportType = chan.fTransportType;
-        fSocket = nullptr;
-        fName = chan.fName;
-        fType = chan.fType;
-        fMethod = chan.fMethod;
-        fAddress = chan.fAddress;
-        fSndBufSize = chan.fSndBufSize;
-        fRcvBufSize = chan.fRcvBufSize;
-        fSndKernelSize = chan.fSndKernelSize;
-        fRcvKernelSize = chan.fRcvKernelSize;
-        fLinger = chan.fLinger;
-        fRateLogging = chan.fRateLogging;
-        fPortRangeMin = chan.fPortRangeMin;
-        fPortRangeMax = chan.fPortRangeMax;
-        fAutoBind = chan.fAutoBind;
-        fIsValid = false;
-        fMultipart = chan.fMultipart;
-        fModified = chan.fModified;
-        fReset = false;
-    }
+    fTransportFactory = nullptr;
+    fTransportType = chan.fTransportType;
+    fSocket = nullptr;
+    fName = chan.fName;
+    fType = chan.fType;
+    fMethod = chan.fMethod;
+    fAddress = chan.fAddress;
+    fSndBufSize = chan.fSndBufSize;
+    fRcvBufSize = chan.fRcvBufSize;
+    fSndKernelSize = chan.fSndKernelSize;
+    fRcvKernelSize = chan.fRcvKernelSize;
+    fLinger = chan.fLinger;
+    fRateLogging = chan.fRateLogging;
+    fPortRangeMin = chan.fPortRangeMin;
+    fPortRangeMax = chan.fPortRangeMax;
+    fAutoBind = chan.fAutoBind;
+    fValid = false;
+    fMultipart = chan.fMultipart;

    return *this;
 }

-FairMQSocket & FairMQChannel::GetSocket() const
-{
-    assert(fSocket);
-    return *fSocket;
-}
-
-string FairMQChannel::GetName() const
-{
-    lock_guard<mutex> lock(fMtx);
-    return fName;
-}
-
-string FairMQChannel::GetPrefix() const
-{
-    lock_guard<mutex> lock(fMtx);
-    string prefix = fName;
-    prefix = prefix.erase(fName.rfind('['));
-    return prefix;
-}
-
-string FairMQChannel::GetIndex() const
-{
-    lock_guard<mutex> lock(fMtx);
-    string indexStr = fName;
-    indexStr.erase(indexStr.rfind(']'));
-    indexStr.erase(0, indexStr.rfind('[') + 1);
-    return indexStr;
-}
-
-string FairMQChannel::GetType() const
-try {
-    lock_guard<mutex> lock(fMtx);
-    return fType;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::GetType: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-string FairMQChannel::GetMethod() const
-try {
-    lock_guard<mutex> lock(fMtx);
-    return fMethod;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::GetMethod: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-string FairMQChannel::GetAddress() const
-try {
-    lock_guard<mutex> lock(fMtx);
-    return fAddress;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::GetAddress: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-string FairMQChannel::GetTransportName() const
-try {
-    lock_guard<mutex> lock(fMtx);
-    return TransportNames.at(fTransportType);
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::GetTransportName: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-Transport FairMQChannel::GetTransportType() const
-try {
-    lock_guard<mutex> lock(fMtx);
-    return fTransportType;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::GetTransportType: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-
-int FairMQChannel::GetSndBufSize() const
-try {
-    lock_guard<mutex> lock(fMtx);
-    return fSndBufSize;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::GetSndBufSize: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-int FairMQChannel::GetRcvBufSize() const
-try {
-    lock_guard<mutex> lock(fMtx);
-    return fRcvBufSize;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::GetRcvBufSize: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-int FairMQChannel::GetSndKernelSize() const
-try {
-    lock_guard<mutex> lock(fMtx);
-    return fSndKernelSize;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::GetSndKernelSize: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-int FairMQChannel::GetRcvKernelSize() const
-try {
-    lock_guard<mutex> lock(fMtx);
-    return fRcvKernelSize;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::GetRcvKernelSize: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-int FairMQChannel::GetLinger() const
-try {
-    lock_guard<mutex> lock(fMtx);
-    return fLinger;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::GetLinger: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-int FairMQChannel::GetRateLogging() const
-try {
-    lock_guard<mutex> lock(fMtx);
-    return fRateLogging;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::GetRateLogging: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-int FairMQChannel::GetPortRangeMin() const
-try {
-    lock_guard<mutex> lock(fMtx);
-    return fPortRangeMin;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::GetPortRangeMin: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-int FairMQChannel::GetPortRangeMax() const
-try {
-    lock_guard<mutex> lock(fMtx);
-    return fPortRangeMax;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::GetPortRangeMax: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-bool FairMQChannel::GetAutoBind() const
-try {
-    lock_guard<mutex> lock(fMtx);
-    return fAutoBind;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::GetAutoBind: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-void FairMQChannel::UpdateType(const string& type)
-try {
-    lock_guard<mutex> lock(fMtx);
-    fIsValid = false;
-    fType = type;
-    fModified = true;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::UpdateType: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-void FairMQChannel::UpdateMethod(const string& method)
-try {
-    lock_guard<mutex> lock(fMtx);
-    fIsValid = false;
-    fMethod = method;
-    fModified = true;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::UpdateMethod: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-void FairMQChannel::UpdateAddress(const string& address)
-try {
-    lock_guard<mutex> lock(fMtx);
-    fIsValid = false;
-    fAddress = address;
-    fModified = true;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::UpdateAddress: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-void FairMQChannel::UpdateTransport(const string& transport)
-try {
-    lock_guard<mutex> lock(fMtx);
-    fIsValid = false;
-    fTransportType = TransportTypes.at(transport);
-    fModified = true;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::UpdateTransport: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-void FairMQChannel::UpdateSndBufSize(const int sndBufSize)
-try {
-    lock_guard<mutex> lock(fMtx);
-    fIsValid = false;
-    fSndBufSize = sndBufSize;
-    fModified = true;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::UpdateSndBufSize: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-void FairMQChannel::UpdateRcvBufSize(const int rcvBufSize)
-try {
-    lock_guard<mutex> lock(fMtx);
-    fIsValid = false;
-    fRcvBufSize = rcvBufSize;
-    fModified = true;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::UpdateRcvBufSize: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-void FairMQChannel::UpdateSndKernelSize(const int sndKernelSize)
-try {
-    lock_guard<mutex> lock(fMtx);
-    fIsValid = false;
-    fSndKernelSize = sndKernelSize;
-    fModified = true;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::UpdateSndKernelSize: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-void FairMQChannel::UpdateRcvKernelSize(const int rcvKernelSize)
-try {
-    lock_guard<mutex> lock(fMtx);
-    fIsValid = false;
-    fRcvKernelSize = rcvKernelSize;
-    fModified = true;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::UpdateRcvKernelSize: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-void FairMQChannel::UpdateLinger(const int duration)
-try {
-    lock_guard<mutex> lock(fMtx);
-    fIsValid = false;
-    fLinger = duration;
-    fModified = true;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::UpdateLinger: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-void FairMQChannel::UpdateRateLogging(const int rateLogging)
-try {
-    lock_guard<mutex> lock(fMtx);
-    fIsValid = false;
-    fRateLogging = rateLogging;
-    fModified = true;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::UpdateRateLogging: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-void FairMQChannel::UpdatePortRangeMin(const int minPort)
-try {
-    lock_guard<mutex> lock(fMtx);
-    fIsValid = false;
-    fPortRangeMin = minPort;
-    fModified = true;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::UpdatePortRangeMin: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-void FairMQChannel::UpdatePortRangeMax(const int maxPort)
-try {
-    lock_guard<mutex> lock(fMtx);
-    fIsValid = false;
-    fPortRangeMax = maxPort;
-    fModified = true;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::UpdatePortRangeMax: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-void FairMQChannel::UpdateAutoBind(const bool autobind)
-try {
-    lock_guard<mutex> lock(fMtx);
-    fIsValid = false;
-    fAutoBind = autobind;
-    fModified = true;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::UpdateAutoBind: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-auto FairMQChannel::SetModified(const bool modified) -> void
-try {
-    lock_guard<mutex> lock(fMtx);
-    fModified = modified;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::SetModified: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-void FairMQChannel::UpdateName(const string& name)
-try {
-    lock_guard<mutex> lock(fMtx);
-    fIsValid = false;
-    fName = name;
-    fModified = true;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::UpdateName: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
-bool FairMQChannel::IsValid() const
-try {
-    lock_guard<mutex> lock(fMtx);
-    return fIsValid;
-} catch (exception& e) {
-    LOG(error) << "Exception caught in FairMQChannel::IsValid: " << e.what();
-    throw ChannelConfigurationError(tools::ToString("failed to acquire lock: ", e.what()));
-}
-
 bool FairMQChannel::Validate()
 try {
-    lock_guard<mutex> lock(fMtx);
    stringstream ss;
    ss << "Validating channel '" << fName << "'... ";

-    if (fIsValid) {
+    if (fValid) {
        ss << "ALREADY VALID";
        LOG(debug) << ss.str();
        return true;
@@ -539,7 +198,7 @@ try {
    } else {
        vector<string> endpoints;
        boost::algorithm::split(endpoints, fAddress, boost::algorithm::is_any_of(";"));
-        for (const auto endpoint : endpoints) {
+        for (const auto& endpoint : endpoints) {
            string address;
            if (endpoint[0] == '@' || endpoint[0] == '+' || endpoint[0] == '>') {
                address = endpoint.substr(1);
@@ -641,7 +300,7 @@ try {
        throw ChannelConfigurationError(tools::ToString("invalid socket rate logging interval (cannot be negative): '", fRateLogging, "'"));
    }

-    fIsValid = true;
+    fValid = true;
    ss << "VALID";
    LOG(debug) << ss.str();
    return true;
@@ -652,8 +311,6 @@ try {

 void FairMQChannel::Init()
 {
-    lock_guard<mutex> lock(fMtx);
-
    fSocket = fTransportFactory->CreateSocket(fType, fName);

    // set linger duration (how long socket should wait for outstanding transfers before shutdown)
@@ -674,14 +331,11 @@ void FairMQChannel::Init()

 bool FairMQChannel::ConnectEndpoint(const string& endpoint)
 {
-    lock_guard<mutex> lock(fMtx);
    return fSocket->Connect(endpoint);
 }

 bool FairMQChannel::BindEndpoint(string& endpoint)
 {
-    lock_guard<mutex> lock(fMtx);
-
    // try to bind to the configured port. If it fails, try random one (if AutoBind is on).
    if (fSocket->Bind(endpoint)) {
        return true;
@@ -722,10 +376,3 @@ bool FairMQChannel::BindEndpoint(string& endpoint)
    }

 }
-
-void FairMQChannel::ResetChannel()
-{
-    lock_guard<mutex> lock(fMtx);
-    fIsValid = false;
-    // TODO: implement channel resetting
-}
--- a/fairmq/FairMQChannel.h
+++ b/fairmq/FairMQChannel.h
@@ -25,6 +25,12 @@
 #include <utility> // std::move
 #include <cstdint> // int64_t

+/**
+ * @class FairMQChannel FairMQChannel.h <FairMQChannel.h>
+ * @brief Wrapper class for FairMQSocket and related methods
+ *
+ * The class is not thread-safe.
+ */
 class FairMQChannel
 {
    friend class FairMQDevice;
@@ -75,14 +81,11 @@ class FairMQChannel
    // FairMQChannel& operator=(FairMQChannel&&) = delete;

    /// Destructor
-    virtual ~FairMQChannel()
-    {
-        // LOG(debug) << "Destroying channel " << fName;
-    }
+    virtual ~FairMQChannel() { /* LOG(warn) << "Destroying channel '" << fName << "'"; */ }

    struct ChannelConfigurationError : std::runtime_error { using std::runtime_error::runtime_error; };

-    FairMQSocket& GetSocket() const;
+    FairMQSocket& GetSocket() const { assert(fSocket); return *fSocket; }

    bool Bind(const std::string& address)
    {
@@ -100,139 +103,142 @@ class FairMQChannel

    /// Get channel name
    /// @return Returns full channel name (e.g. "data[0]")
-    std::string GetChannelName() const __attribute__((deprecated("Use GetName()"))) { return GetName(); }
-    std::string GetName() const ;
+    std::string GetName() const { return fName; }

    /// Get channel prefix
    /// @return Returns channel prefix (e.g. "data" in "data[0]")
-    std::string GetChannelPrefix() const  __attribute__((deprecated("Use GetPrefix()"))) { return GetPrefix(); }
-    std::string GetPrefix() const;
+    std::string GetPrefix() const
+    {
+        std::string prefix = fName;
+        prefix = prefix.erase(fName.rfind('['));
+        return prefix;
+    }

    /// Get channel index
    /// @return Returns channel index (e.g. 0 in "data[0]")
-    std::string GetChannelIndex() const __attribute__((deprecated("Use GetIndex()"))) { return GetIndex(); }
-    std::string GetIndex() const;
+    std::string GetIndex() const
+    {
+        std::string indexStr = fName;
+        indexStr.erase(indexStr.rfind(']'));
+        indexStr.erase(0, indexStr.rfind('[') + 1);
+        return indexStr;
+    }

    /// Get socket type
    /// @return Returns socket type (push/pull/pub/sub/spub/xsub/pair/req/rep/dealer/router/)
-    std::string GetType() const;
+    std::string GetType() const { return fType; }

    /// Get socket method
    /// @return Returns socket method (bind/connect)
-    std::string GetMethod() const;
+    std::string GetMethod() const { return fMethod; }

    /// Get socket address (e.g. "tcp://127.0.0.1:5555" or "ipc://abc")
    /// @return Returns socket address (e.g. "tcp://127.0.0.1:5555" or "ipc://abc")
-    std::string GetAddress() const;
+    std::string GetAddress() const { return fAddress; }

    /// Get channel transport name ("default", "zeromq" or "shmem")
    /// @return Returns channel transport name (e.g. "default", "zeromq" or "shmem")
-    std::string GetTransportName() const;
+    std::string GetTransportName() const { return fair::mq::TransportName(fTransportType); }

    /// Get channel transport type
    /// @return Returns channel transport type
-    fair::mq::Transport GetTransportType() const;
+    fair::mq::Transport GetTransportType() const { return fTransportType; }

    /// Get socket send buffer size (in number of messages)
    /// @return Returns socket send buffer size (in number of messages)
-    int GetSndBufSize() const;
+    int GetSndBufSize() const { return fSndBufSize; }

    /// Get socket receive buffer size (in number of messages)
    /// @return Returns socket receive buffer size (in number of messages)
-    int GetRcvBufSize() const;
+    int GetRcvBufSize() const { return fRcvBufSize; }

    /// Get socket kernel transmit send buffer size (in bytes)
    /// @return Returns socket kernel transmit send buffer size (in bytes)
-    int GetSndKernelSize() const;
+    int GetSndKernelSize() const { return fSndKernelSize; }

    /// Get socket kernel transmit receive buffer size (in bytes)
    /// @return Returns socket kernel transmit receive buffer size (in bytes)
-    int GetRcvKernelSize() const;
+    int GetRcvKernelSize() const { return fRcvKernelSize; }

    /// Get linger duration (in milliseconds)
    /// @return Returns linger duration (in milliseconds)
-    int GetLinger() const;
+    int GetLinger() const { return fLinger; }

    /// Get socket rate logging interval (in seconds)
    /// @return Returns socket rate logging interval (in seconds)
-    int GetRateLogging() const;
+    int GetRateLogging() const { return fRateLogging; }

    /// Get start of the port range for automatic binding
    /// @return start of the port range
-    int GetPortRangeMin() const;
+    int GetPortRangeMin() const { return fPortRangeMin; }

    /// Get end of the port range for automatic binding
    /// @return end of the port range
-    int GetPortRangeMax() const;
+    int GetPortRangeMax() const { return fPortRangeMax; }

    /// Set automatic binding (pick random port if bind fails)
    /// @return true/false, true if automatic binding is enabled
-    bool GetAutoBind() const;
-
-    /// Set socket type
-    /// @param type Socket type (push/pull/pub/sub/spub/xsub/pair/req/rep/dealer/router/)
-    void UpdateType(const std::string& type);
-
-    /// Set socket method
-    /// @param method Socket method (bind/connect)
-    void UpdateMethod(const std::string& method);
-
-    /// Set socket address
-    /// @param Socket address (e.g. "tcp://127.0.0.1:5555" or "ipc://abc")
-    void UpdateAddress(const std::string& address);
-
-    /// Set channel transport
-    /// @param transport transport string ("default", "zeromq" or "shmem")
-    void UpdateTransport(const std::string& transport);
-
-    /// Set socket send buffer size
-    /// @param sndBufSize Socket send buffer size (in number of messages)
-    void UpdateSndBufSize(const int sndBufSize);
-
-    /// Set socket receive buffer size
-    /// @param rcvBufSize Socket receive buffer size (in number of messages)
-    void UpdateRcvBufSize(const int rcvBufSize);
-
-    /// Set socket kernel transmit send buffer size (in bytes)
-    /// @param sndKernelSize Socket send buffer size (in bytes)
-    void UpdateSndKernelSize(const int sndKernelSize);
-
-    /// Set socket kernel transmit receive buffer size (in bytes)
-    /// @param rcvKernelSize Socket receive buffer size (in bytes)
-    void UpdateRcvKernelSize(const int rcvKernelSize);
-
-    /// Set linger duration (in milliseconds)
-    /// @param duration linger duration (in milliseconds)
-    void UpdateLinger(const int duration);
-
-    /// Set socket rate logging interval (in seconds)
-    /// @param rateLogging Socket rate logging interval (in seconds)
-    void UpdateRateLogging(const int rateLogging);
-
-    /// Set start of the port range for automatic binding
-    /// @param minPort start of the port range
-    void UpdatePortRangeMin(const int minPort);
-
-    /// Set end of the port range for automatic binding
-    /// @param maxPort end of the port range
-    void UpdatePortRangeMax(const int maxPort);
-
-    /// Set automatic binding (pick random port if bind fails)
-    /// @param autobind true/false, true to enable automatic binding
-    void UpdateAutoBind(const bool autobind);
+    bool GetAutoBind() const { return fAutoBind; }

    /// Set channel name
    /// @param name Arbitrary channel name
-    void UpdateChannelName(const std::string& name) __attribute__((deprecated("Use UpdateName()"))) { UpdateName(name); }
-    void UpdateName(const std::string& name);
+    void UpdateName(const std::string& name) { fName = name; Invalidate(); }
+
+    /// Set socket type
+    /// @param type Socket type (push/pull/pub/sub/spub/xsub/pair/req/rep/dealer/router/)
+    void UpdateType(const std::string& type) { fType = type; Invalidate(); }
+
+    /// Set socket method
+    /// @param method Socket method (bind/connect)
+    void UpdateMethod(const std::string& method) { fMethod = method; Invalidate(); }
+
+    /// Set socket address
+    /// @param Socket address (e.g. "tcp://127.0.0.1:5555" or "ipc://abc")
+    void UpdateAddress(const std::string& address) { fAddress = address; Invalidate(); }
+
+    /// Set channel transport
+    /// @param transport transport string ("default", "zeromq" or "shmem")
+    void UpdateTransport(const std::string& transport) { fTransportType = fair::mq::TransportType(transport); Invalidate(); }
+
+    /// Set socket send buffer size
+    /// @param sndBufSize Socket send buffer size (in number of messages)
+    void UpdateSndBufSize(const int sndBufSize) { fSndBufSize = sndBufSize; Invalidate(); }
+
+    /// Set socket receive buffer size
+    /// @param rcvBufSize Socket receive buffer size (in number of messages)
+    void UpdateRcvBufSize(const int rcvBufSize) { fRcvBufSize = rcvBufSize; Invalidate(); }
+
+    /// Set socket kernel transmit send buffer size (in bytes)
+    /// @param sndKernelSize Socket send buffer size (in bytes)
+    void UpdateSndKernelSize(const int sndKernelSize) { fSndKernelSize = sndKernelSize; Invalidate(); }
+
+    /// Set socket kernel transmit receive buffer size (in bytes)
+    /// @param rcvKernelSize Socket receive buffer size (in bytes)
+    void UpdateRcvKernelSize(const int rcvKernelSize) { fRcvKernelSize = rcvKernelSize; Invalidate(); }
+
+    /// Set linger duration (in milliseconds)
+    /// @param duration linger duration (in milliseconds)
+    void UpdateLinger(const int duration) { fLinger = duration; Invalidate(); }
+
+    /// Set socket rate logging interval (in seconds)
+    /// @param rateLogging Socket rate logging interval (in seconds)
+    void UpdateRateLogging(const int rateLogging) { fRateLogging = rateLogging; Invalidate(); }
+
+    /// Set start of the port range for automatic binding
+    /// @param minPort start of the port range
+    void UpdatePortRangeMin(const int minPort) { fPortRangeMin = minPort; Invalidate(); }
+
+    /// Set end of the port range for automatic binding
+    /// @param maxPort end of the port range
+    void UpdatePortRangeMax(const int maxPort) { fPortRangeMax = maxPort; Invalidate(); }
+
+    /// Set automatic binding (pick random port if bind fails)
+    /// @param autobind true/false, true to enable automatic binding
+    void UpdateAutoBind(const bool autobind) { fAutoBind = autobind; Invalidate(); }

    /// Checks if the configured channel settings are valid (checks the validity parameter, without running full validation (as oposed to ValidateChannel()))
    /// @return true if channel settings are valid, false otherwise.
-    bool IsValid() const;
-
-    /// Validates channel configuration
-    /// @return true if channel settings are valid, false otherwise.
-    bool ValidateChannel() __attribute__((deprecated("Use Validate()"))) { return Validate(); }
+    bool IsValid() const { return fValid; }

    /// Validates channel configuration
    /// @return true if channel settings are valid, false otherwise.
@@ -244,14 +250,14 @@ class FairMQChannel

    bool BindEndpoint(std::string& endpoint);

-    /// Resets the channel (requires validation to be used again).
-    void ResetChannel();
+    /// invalidates the channel (requires validation to be used again).
+    void Invalidate() { fValid = false; }

    /// Sends a message to the socket queue.
    /// @param msg Constant reference of unique_ptr to a FairMQMessage
    /// @param sndTimeoutInMs send timeout in ms. -1 will wait forever (or until interrupt (e.g. via state change)), 0 will not wait (return immediately if cannot send)
-    /// @return Number of bytes that have been queued, TransferResult::timeout if timed out, TransferResult::error if there was an error, TransferResult::interrupted if interrupted (e.g. by requested state change)
-    int Send(FairMQMessagePtr& msg, int sndTimeoutInMs = -1)
+    /// @return Number of bytes that have been queued, TransferCode::timeout if timed out, TransferCode::error if there was an error, TransferCode::interrupted if interrupted (e.g. by requested state change)
+    int64_t Send(FairMQMessagePtr& msg, int sndTimeoutInMs = -1)
    {
        CheckSendCompatibility(msg);
        return fSocket->Send(msg, sndTimeoutInMs);
@@ -260,8 +266,8 @@ class FairMQChannel
    /// Receives a message from the socket queue.
    /// @param msg Constant reference of unique_ptr to a FairMQMessage
    /// @param rcvTimeoutInMs receive timeout in ms. -1 will wait forever (or until interrupt (e.g. via state change)), 0 will not wait (return immediately if cannot receive)
-    /// @return Number of bytes that have been received, TransferResult::timeout if timed out, TransferResult::error if there was an error, TransferResult::interrupted if interrupted (e.g. by requested state change)
-    int Receive(FairMQMessagePtr& msg, int rcvTimeoutInMs = -1)
+    /// @return Number of bytes that have been received, TransferCode::timeout if timed out, TransferCode::error if there was an error, TransferCode::interrupted if interrupted (e.g. by requested state change)
+    int64_t Receive(FairMQMessagePtr& msg, int rcvTimeoutInMs = -1)
    {
        CheckReceiveCompatibility(msg);
        return fSocket->Receive(msg, rcvTimeoutInMs);
@@ -270,7 +276,7 @@ class FairMQChannel
    /// Send a vector of messages
    /// @param msgVec message vector reference
    /// @param sndTimeoutInMs send timeout in ms. -1 will wait forever (or until interrupt (e.g. via state change)), 0 will not wait (return immediately if cannot send)
-    /// @return Number of bytes that have been queued, TransferResult::timeout if timed out, TransferResult::error if there was an error, TransferResult::interrupted if interrupted (e.g. by requested state change)
+    /// @return Number of bytes that have been queued, TransferCode::timeout if timed out, TransferCode::error if there was an error, TransferCode::interrupted if interrupted (e.g. by requested state change)
    int64_t Send(std::vector<FairMQMessagePtr>& msgVec, int sndTimeoutInMs = -1)
    {
        CheckSendCompatibility(msgVec);
@@ -280,7 +286,7 @@ class FairMQChannel
    /// Receive a vector of messages
    /// @param msgVec message vector reference
    /// @param rcvTimeoutInMs receive timeout in ms. -1 will wait forever (or until interrupt (e.g. via state change)), 0 will not wait (return immediately if cannot receive)
-    /// @return Number of bytes that have been received, TransferResult::timeout if timed out, TransferResult::error if there was an error, TransferResult::interrupted if interrupted (e.g. by requested state change)
+    /// @return Number of bytes that have been received, TransferCode::timeout if timed out, TransferCode::error if there was an error, TransferCode::interrupted if interrupted (e.g. by requested state change)
    int64_t Receive(std::vector<FairMQMessagePtr>& msgVec, int rcvTimeoutInMs = -1)
    {
        CheckReceiveCompatibility(msgVec);
@@ -290,7 +296,7 @@ class FairMQChannel
    /// Send FairMQParts
    /// @param parts FairMQParts reference
    /// @param sndTimeoutInMs send timeout in ms. -1 will wait forever (or until interrupt (e.g. via state change)), 0 will not wait (return immediately if cannot send)
-    /// @return Number of bytes that have been queued, TransferResult::timeout if timed out, TransferResult::error if there was an error, TransferResult::interrupted if interrupted (e.g. by requested state change)
+    /// @return Number of bytes that have been queued, TransferCode::timeout if timed out, TransferCode::error if there was an error, TransferCode::interrupted if interrupted (e.g. by requested state change)
    int64_t Send(FairMQParts& parts, int sndTimeoutInMs = -1)
    {
        return Send(parts.fParts, sndTimeoutInMs);
@@ -299,7 +305,7 @@ class FairMQChannel
    /// Receive FairMQParts
    /// @param parts FairMQParts reference
    /// @param rcvTimeoutInMs receive timeout in ms. -1 will wait forever (or until interrupt (e.g. via state change)), 0 will not wait (return immediately if cannot receive)
-    /// @return Number of bytes that have been received, TransferResult::timeout if timed out, TransferResult::error if there was an error, TransferResult::interrupted if interrupted (e.g. by requested state change)
+    /// @return Number of bytes that have been received, TransferCode::timeout if timed out, TransferCode::error if there was an error, TransferCode::interrupted if interrupted (e.g. by requested state change)
    int64_t Receive(FairMQParts& parts, int rcvTimeoutInMs = -1)
    {
        return Receive(parts.fParts, rcvTimeoutInMs);
@@ -310,10 +316,7 @@ class FairMQChannel
    unsigned long GetMessagesTx() const { return fSocket->GetMessagesTx(); }
    unsigned long GetMessagesRx() const { return fSocket->GetMessagesRx(); }

-    auto Transport() -> FairMQTransportFactory*
-    {
-        return fTransportFactory.get();
-    };
+    auto Transport() -> FairMQTransportFactory* { return fTransportFactory.get(); };

    template<typename... Args>
    FairMQMessagePtr NewMessage(Args&&... args)
@@ -374,13 +377,9 @@ class FairMQChannel
    int fPortRangeMax;
    bool fAutoBind;

-    bool fIsValid;
+    bool fValid;

    bool fMultipart;
-    bool fModified;
-    bool fReset;
-
-    mutable std::mutex fMtx;

    void CheckSendCompatibility(FairMQMessagePtr& msg)
    {
@@ -437,8 +436,6 @@ class FairMQChannel
        fTransportFactory = factory;
        fTransportType = factory->GetType();
    }
-
-    auto SetModified(const bool modified) -> void;
 };

 #endif /* FAIRMQCHANNEL_H_ */
--- a/fairmq/FairMQDevice.cxx
+++ b/fairmq/FairMQDevice.cxx
@@ -24,34 +24,6 @@
 using namespace std;
 using namespace fair::mq;

-static map<Transition, State> backwardsCompatibilityWaitForEndOfStateHelper =
-{
-    { Transition::InitDevice,   State::InitializingDevice },
-    { Transition::CompleteInit, State::Initialized },
-    { Transition::Bind,         State::Bound },
-    { Transition::Connect,      State::DeviceReady },
-    { Transition::InitTask,     State::Ready },
-    { Transition::Run,          State::Ready },
-    { Transition::Stop,         State::Ready },
-    { Transition::ResetTask,    State::DeviceReady },
-    { Transition::ResetDevice,  State::Idle }
-};
-
-static map<int, Transition> backwardsCompatibilityChangeStateHelper =
-{
-    { FairMQDevice::Event::INIT_DEVICE,           Transition::InitDevice },
-    { FairMQDevice::Event::internal_DEVICE_READY, Transition::Auto },
-    { FairMQDevice::Event::INIT_TASK,             Transition::InitTask },
-    { FairMQDevice::Event::internal_READY,        Transition::Auto },
-    { FairMQDevice::Event::RUN,                   Transition::Run },
-    { FairMQDevice::Event::STOP,                  Transition::Stop },
-    { FairMQDevice::Event::RESET_TASK,            Transition::ResetTask },
-    { FairMQDevice::Event::RESET_DEVICE,          Transition::ResetDevice },
-    { FairMQDevice::Event::internal_IDLE,         Transition::Auto },
-    { FairMQDevice::Event::END,                   Transition::End },
-    { FairMQDevice::Event::ERROR_FOUND,           Transition::ErrorFound }
-};
-
 constexpr const char* FairMQDevice::DefaultId;
 constexpr int FairMQDevice::DefaultIOThreads;
 constexpr const char* FairMQDevice::DefaultTransportName;
@@ -103,7 +75,7 @@ FairMQDevice::FairMQDevice(ProgOptions* config, const tools::Version version)
    : fTransportFactory(nullptr)
    , fTransports()
    , fChannels()
-    , fInternalConfig(config ? nullptr : tools::make_unique<ProgOptions>())
+    , fInternalConfig(config ? nullptr : make_unique<ProgOptions>())
    , fConfig(config ? config : fInternalConfig.get())
    , fId(DefaultId)
    , fDefaultTransportType(DefaultTransportType)
@@ -244,16 +216,6 @@ void FairMQDevice::TransitionTo(const fair::mq::State s)
    }
 }

-bool FairMQDevice::ChangeState(const int transition)
-{
-    return ChangeState(backwardsCompatibilityChangeStateHelper.at(transition));
-}
-
-void FairMQDevice::WaitForEndOfState(Transition transition)
-{
-    WaitForState(backwardsCompatibilityWaitForEndOfStateHelper.at(transition));
-}
-
 void FairMQDevice::InitWrapper()
 {
    // run initialization once CompleteInit transition is requested
@@ -390,7 +352,6 @@ void FairMQDevice::AttachChannels(vector<FairMQChannel*>& chans)
        if ((*itr)->Validate()) {
            (*itr)->Init();
            if (AttachChannel(**itr)) {
-                (*itr)->SetModified(false);
                // remove the channel from the uninitialized container
                itr = chans.erase(itr);
            } else {
--- a/fairmq/FairMQDevice.h
+++ b/fairmq/FairMQDevice.h
@@ -26,7 +26,6 @@
 #include <algorithm> // find
 #include <string>
 #include <chrono>
-#include <iostream>
 #include <unordered_map>
 #include <functional>
 #include <stdexcept>
@@ -42,51 +41,16 @@ using FairMQChannelMap = std::unordered_map<std::string, std::vector<FairMQChann
 using InputMsgCallback = std::function<bool(FairMQMessagePtr&, int)>;
 using InputMultipartCallback = std::function<bool(FairMQParts&, int)>;

-namespace fair
-{
-namespace mq
+namespace fair::mq
 {
 struct OngoingTransition : std::runtime_error { using std::runtime_error::runtime_error; };
 }
-}

 class FairMQDevice
 {
    friend class FairMQChannel;

  public:
-    // backwards-compatibility enum for old state machine interface, todo: delete this
-    enum Event
-    {
-        INIT_DEVICE,
-        internal_DEVICE_READY,
-        INIT_TASK,
-        internal_READY,
-        RUN,
-        STOP,
-        RESET_TASK,
-        RESET_DEVICE,
-        internal_IDLE,
-        END,
-        ERROR_FOUND
-    };
-
-    // backwards-compatibility enum for old state machine interface, todo: delete this
-    enum State
-    {
-        OK,
-        Error,
-        IDLE,
-        INITIALIZING_DEVICE,
-        DEVICE_READY,
-        INITIALIZING_TASK,
-        READY,
-        RUNNING,
-        RESETTING_TASK,
-        RESETTING_DEVICE,
-        EXITING
-    };
-
    /// Default constructor
    FairMQDevice();
    /// Constructor with external fair::mq::ProgOptions
@@ -129,8 +93,8 @@ class FairMQDevice
    /// @param chan channel name
    /// @param i channel index
    /// @param sndTimeoutInMs send timeout in ms, -1 will wait forever (or until interrupt (e.g. via state change)), 0 will not wait (return immediately if cannot send)
-    /// @return Number of bytes that have been queued, TransferResult::timeout if timed out, TransferResult::error if there was an error, TransferResult::interrupted if interrupted (e.g. by requested state change)
-    int Send(FairMQMessagePtr& msg, const std::string& channel, const int index = 0, int sndTimeoutInMs = -1)
+    /// @return Number of bytes that have been queued, TransferCode::timeout if timed out, TransferCode::error if there was an error, TransferCode::interrupted if interrupted (e.g. by requested state change)
+    int64_t Send(FairMQMessagePtr& msg, const std::string& channel, const int index = 0, int sndTimeoutInMs = -1)
    {
        return GetChannel(channel, index).Send(msg, sndTimeoutInMs);
    }
@@ -140,8 +104,8 @@ class FairMQDevice
    /// @param chan channel name
    /// @param i channel index
    /// @param rcvTimeoutInMs receive timeout in ms, -1 will wait forever (or until interrupt (e.g. via state change)), 0 will not wait (return immediately if cannot receive)
-    /// @return Number of bytes that have been received, TransferResult::timeout if timed out, TransferResult::error if there was an error, TransferResult::interrupted if interrupted (e.g. by requested state change)
-    int Receive(FairMQMessagePtr& msg, const std::string& channel, const int index = 0, int rcvTimeoutInMs = -1)
+    /// @return Number of bytes that have been received, TransferCode::timeout if timed out, TransferCode::error if there was an error, TransferCode::interrupted if interrupted (e.g. by requested state change)
+    int64_t Receive(FairMQMessagePtr& msg, const std::string& channel, const int index = 0, int rcvTimeoutInMs = -1)
    {
        return GetChannel(channel, index).Receive(msg, rcvTimeoutInMs);
    }
@@ -151,7 +115,7 @@ class FairMQDevice
    /// @param chan channel name
    /// @param i channel index
    /// @param sndTimeoutInMs send timeout in ms, -1 will wait forever (or until interrupt (e.g. via state change)), 0 will not wait (return immediately if cannot send)
-    /// @return Number of bytes that have been queued, TransferResult::timeout if timed out, TransferResult::error if there was an error, TransferResult::interrupted if interrupted (e.g. by requested state change)
+    /// @return Number of bytes that have been queued, TransferCode::timeout if timed out, TransferCode::error if there was an error, TransferCode::interrupted if interrupted (e.g. by requested state change)
    int64_t Send(FairMQParts& parts, const std::string& channel, const int index = 0, int sndTimeoutInMs = -1)
    {
        return GetChannel(channel, index).Send(parts.fParts, sndTimeoutInMs);
@@ -162,7 +126,7 @@ class FairMQDevice
    /// @param chan channel name
    /// @param i channel index
    /// @param rcvTimeoutInMs receive timeout in ms, -1 will wait forever (or until interrupt (e.g. via state change)), 0 will not wait (return immediately if cannot receive)
-    /// @return Number of bytes that have been received, TransferResult::timeout if timed out, TransferResult::error if there was an error, TransferResult::interrupted if interrupted (e.g. by requested state change)
+    /// @return Number of bytes that have been received, TransferCode::timeout if timed out, TransferCode::error if there was an error, TransferCode::interrupted if interrupted (e.g. by requested state change)
    int64_t Receive(FairMQParts& parts, const std::string& channel, const int index = 0, int rcvTimeoutInMs = -1)
    {
        return GetChannel(channel, index).Receive(parts.fParts, rcvTimeoutInMs);
@@ -363,10 +327,10 @@ class FairMQDevice
    void PrintRegisteredChannels()
    {
        if (fChannelRegistry.size() < 1) {
-            std::cout << "no channels registered." << std::endl;
+            LOGV(info, verylow) << "no channels registered.";
        } else {
            for (const auto& c : fChannelRegistry) {
-                std::cout << c.first << ":" << c.second.first << ":" << c.second.second << std::endl;
+                LOGV(info, verylow) << c.first << ":" << c.second.first << ":" << c.second.second;
            }
        }
    }
@@ -450,8 +414,6 @@ class FairMQDevice
    /// Called in the RUNNING state once after executing the Run()/ConditionalRun() method
    virtual void PostRun() {}

-    virtual void Pause() __attribute__((deprecated("PAUSE state is removed. This method is never called. To pause Run, go to READY with STOP transition and back to RUNNING with RUN to resume."))) {}
-
    /// Resets the user task (to be overloaded in child classes)
    virtual void ResetTask() {}

@@ -462,11 +424,6 @@ class FairMQDevice
    bool ChangeState(const fair::mq::Transition transition) { return fStateMachine.ChangeState(transition); }
    bool ChangeState(const std::string& transition) { return fStateMachine.ChangeState(fair::mq::GetTransition(transition)); }

-    bool ChangeState(const int transition) __attribute__((deprecated("Use ChangeState(const fair::mq::Transition transition).")));
-
-    void WaitForEndOfState(const fair::mq::Transition transition) __attribute__((deprecated("Use WaitForState(fair::mq::State expectedState).")));
-    void WaitForEndOfState(const std::string& transition) __attribute__((deprecated("Use WaitForState(fair::mq::State expectedState)."))) { WaitForState(transition); }
-
    fair::mq::State WaitForNextState() { return fStateQueue.WaitForNext(); }
    void WaitForState(fair::mq::State state) { fStateQueue.WaitForState(state); }
    void WaitForState(const std::string& state) { WaitForState(fair::mq::GetState(state)); }
@@ -479,9 +436,6 @@ class FairMQDevice
    void SubscribeToNewTransition(const std::string& key, std::function<void(const fair::mq::Transition)> callback) { fStateMachine.SubscribeToNewTransition(key, callback); }
    void UnsubscribeFromNewTransition(const std::string& key) { fStateMachine.UnsubscribeFromNewTransition(key); }

-    bool CheckCurrentState(const int /* state */) const __attribute__((deprecated("Use NewStatePending()."))) { return !fStateMachine.NewStatePending(); }
-    bool CheckCurrentState(const std::string& /* state */) const __attribute__((deprecated("Use NewStatePending()."))) { return !fStateMachine.NewStatePending(); }
-
    /// Returns true is a new state has been requested, signaling the current handler to stop.
    bool NewStatePending() const { return fStateMachine.NewStatePending(); }

--- a/fairmq/FairMQMessage.h
+++ b/fairmq/FairMQMessage.h
@@ -18,9 +18,7 @@
 using fairmq_free_fn = void(void* data, void* hint);
 class FairMQTransportFactory;

-namespace fair
-{
-namespace mq
+namespace fair::mq
 {

 struct Alignment
@@ -29,8 +27,7 @@ struct Alignment
    explicit operator size_t() const { return alignment; }
 };

-} /* namespace mq */
-} /* namespace fair */
+} // namespace fair::mq

 class FairMQMessage
 {
@@ -39,7 +36,9 @@ class FairMQMessage
    FairMQMessage(FairMQTransportFactory* factory) : fTransport(factory) {}

    virtual void Rebuild() = 0;
+    virtual void Rebuild(fair::mq::Alignment alignment) = 0;
    virtual void Rebuild(const size_t size) = 0;
+    virtual void Rebuild(const size_t size, fair::mq::Alignment alignment) = 0;
    virtual void Rebuild(void* data, const size_t size, fairmq_free_fn* ffn, void* hint = nullptr) = 0;

    virtual void* GetData() const = 0;
@@ -61,9 +60,7 @@ class FairMQMessage

 using FairMQMessagePtr = std::unique_ptr<FairMQMessage>;

-namespace fair
-{
-namespace mq
+namespace fair::mq
 {

 using Message = FairMQMessage;
@@ -71,7 +68,6 @@ using MessagePtr = FairMQMessagePtr;
 struct MessageError : std::runtime_error { using std::runtime_error::runtime_error; };
 struct MessageBadAlloc : std::runtime_error { using std::runtime_error::runtime_error; };

-} /* namespace mq */
-} /* namespace fair */
+} // namespace fair::mq

 #endif /* FAIRMQMESSAGE_H_ */
--- a/fairmq/FairMQPoller.h
+++ b/fairmq/FairMQPoller.h
@@ -26,16 +26,13 @@ class FairMQPoller

 using FairMQPollerPtr = std::unique_ptr<FairMQPoller>;

-namespace fair
-{
-namespace mq
+namespace fair::mq
 {

 using Poller = FairMQPoller;
 using PollerPtr = FairMQPollerPtr;
 struct PollerError : std::runtime_error { using std::runtime_error::runtime_error; };

-} /* namespace mq */
-} /* namespace fair */
+} // namespace fair::mq

 #endif /* FAIRMQPOLLER_H_ */
--- a/fairmq/FairMQSocket.h
+++ b/fairmq/FairMQSocket.h
@@ -19,20 +19,18 @@

 class FairMQTransportFactory;

-namespace fair
-{
-namespace mq
+namespace fair::mq
 {

-enum class TransferResult : int
+enum class TransferCode : int
 {
+    success = 0,
    error = -1,
    timeout = -2,
    interrupted = -3
 };

-} // namespace mq
-} // namespace fair
+} // namespace fair::mq

 class FairMQSocket
 {
@@ -45,8 +43,8 @@ class FairMQSocket
    virtual bool Bind(const std::string& address) = 0;
    virtual bool Connect(const std::string& address) = 0;

-    virtual int Send(FairMQMessagePtr& msg, int timeout = -1) = 0;
-    virtual int Receive(FairMQMessagePtr& msg, int timeout = -1) = 0;
+    virtual int64_t Send(FairMQMessagePtr& msg, int timeout = -1) = 0;
+    virtual int64_t Receive(FairMQMessagePtr& msg, int timeout = -1) = 0;
    virtual int64_t Send(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, int timeout = -1) = 0;
    virtual int64_t Receive(std::vector<std::unique_ptr<FairMQMessage>>& msgVec, int timeout = -1) = 0;

@@ -86,16 +84,13 @@ class FairMQSocket

 using FairMQSocketPtr = std::unique_ptr<FairMQSocket>;

-namespace fair
-{
-namespace mq
+namespace fair::mq
 {

 using Socket = FairMQSocket;
 using SocketPtr = FairMQSocketPtr;
 struct SocketError : std::runtime_error { using std::runtime_error::runtime_error; };

-} /* namespace mq */
-} /* namespace fair */
+} // namespace fair::mq

 #endif /* FAIRMQSOCKET_H_ */
--- a/fairmq/FairMQTransportFactory.cxx
+++ b/fairmq/FairMQTransportFactory.cxx
@@ -13,7 +13,8 @@
 #include <fairmq/ofi/TransportFactory.h>
 #endif
 #include <FairMQLogger.h>
-#include <fairmq/Tools.h>
+#include <fairmq/tools/Unique.h>
+#include <fairmq/tools/Strings.h>

 #include <fairlogger/Logger.h>

--- a/fairmq/FairMQTransportFactory.h
+++ b/fairmq/FairMQTransportFactory.h
@@ -24,7 +24,7 @@
 #include <cstddef> // size_t

 class FairMQChannel;
-namespace fair { namespace mq { class ProgOptions; } }
+namespace fair::mq { class ProgOptions; }

 class FairMQTransportFactory
 {
@@ -171,15 +171,12 @@ class FairMQTransportFactory
    }
 };

-namespace fair
-{
-namespace mq
+namespace fair::mq
 {

 using TransportFactory = FairMQTransportFactory;
 struct TransportFactoryError : std::runtime_error { using std::runtime_error::runtime_error; };

-} /* namespace mq */
-} /* namespace fair */
+} // namespace fair::mq

 #endif /* FAIRMQTRANSPORTFACTORY_H_ */
--- a/fairmq/FairMQUnmanagedRegion.h
+++ b/fairmq/FairMQUnmanagedRegion.h
@@ -104,9 +104,7 @@ inline std::ostream& operator<<(std::ostream& os, const FairMQRegionEvent& event
    }
 }

-namespace fair
-{
-namespace mq
+namespace fair::mq
 {

 using RegionCallback = FairMQRegionCallback;
@@ -118,7 +116,6 @@ using RegionBlock = FairMQRegionBlock;
 using UnmanagedRegion = FairMQUnmanagedRegion;
 using UnmanagedRegionPtr = FairMQUnmanagedRegionPtr;

-} /* namespace mq */
-} /* namespace fair */
+} // namespace fair::mq

 #endif /* FAIRMQUNMANAGEDREGION_H_ */
--- a/fairmq/JSONParser.cxx
+++ b/fairmq/JSONParser.cxx
@@ -15,7 +15,6 @@
 #include "JSONParser.h"
 #include "FairMQChannel.h"
 #include <fairmq/PropertyOutput.h>
-#include <fairmq/tools/CppSTL.h>
 #include <fairmq/tools/Strings.h>

 #include <fairlogger/Logger.h>
@@ -31,9 +30,7 @@ using namespace fair::mq;
 using namespace fair::mq::tools;
 using namespace boost::property_tree;

-namespace fair
-{
-namespace mq
+namespace fair::mq
 {

 fair::mq::Properties PtreeParser(const ptree& pt, const string& id)
@@ -186,5 +183,4 @@ void SubChannelParser(const ptree& channelTree, fair::mq::Properties& properties
 }

 } // helper namespace
-} // namespace mq
-} // namespace fair
+} // namespace fair::mq
--- a/fairmq/JSONParser.h
+++ b/fairmq/JSONParser.h
@@ -21,9 +21,7 @@
 #include <stdexcept>
 #include <string>

-namespace fair
-{
-namespace mq
+namespace fair::mq
 {

 struct ParserError : std::runtime_error { using std::runtime_error::runtime_error; };
@@ -41,7 +39,6 @@ void SubChannelParser(const boost::property_tree::ptree& tree, fair::mq::Propert

 } // helper namespace

-} // namespace mq
-} // namespace fair
+} // namespace fair::mq

 #endif /* FAIR_MQ_JSONPARSER_H */
--- a/fairmq/MemoryResourceTools.h
+++ b/fairmq/MemoryResourceTools.h
@@ -15,8 +15,8 @@
 #include <fairmq/FairMQTransportFactory.h>
 #include <fairmq/MemoryResources.h>

-namespace fair {
-namespace mq {
+namespace fair::mq
+{

 using BytePmrAllocator = pmr::polymorphic_allocator<fair::mq::byte>;

@@ -62,5 +62,4 @@ FairMQMessagePtr getMessage(ContainerT &&container_, FairMQMemoryResource *targe
    return message;
 }

-} /* namespace mq */
-} /* namespace fair */
+} // namespace fair::mq
--- a/fairmq/MemoryResources.h
+++ b/fairmq/MemoryResources.h
@@ -26,8 +26,8 @@ class FairMQTransportFactory;
 #include <stdexcept>
 #include <utility>

-namespace fair {
-namespace mq {
+namespace fair::mq
+{

 using byte = unsigned char;
 namespace pmr = boost::container::pmr;
@@ -107,7 +107,6 @@ class ChannelResource : public FairMQMemoryResource
    };
 };

-} /* namespace mq */
-} /* namespace fair */
+} // namespace fair::mq

 #endif /* FAIR_MQ_MEMORY_RESOURCES_H */
--- a/fairmq/Plugin.h
+++ b/fairmq/Plugin.h
@@ -9,7 +9,6 @@
 #ifndef FAIR_MQ_PLUGIN_H
 #define FAIR_MQ_PLUGIN_H

-#include <fairmq/tools/CppSTL.h>
 #include <fairmq/tools/Version.h>
 #include <fairmq/PluginServices.h>

@@ -25,9 +24,7 @@
 #include <tuple>
 #include <utility>

-namespace fair
-{
-namespace mq
+namespace fair::mq
 {

 /**
@@ -134,13 +131,12 @@ class Plugin
    PluginServices* fPluginServices;
 }; /* class Plugin */

-} /* namespace mq */
-} /* namespace fair */
+} // namespace fair::mq

 #define REGISTER_FAIRMQ_PLUGIN(KLASS, NAME, VERSION, MAINTAINER, HOMEPAGE, PROGOPTIONS) \
 static auto Make_##NAME##_Plugin(fair::mq::PluginServices* pluginServices) -> std::unique_ptr<fair::mq::Plugin> \
 { \
-    return fair::mq::tools::make_unique<KLASS>(std::string{#NAME}, VERSION, std::string{MAINTAINER}, std::string{HOMEPAGE}, pluginServices); \
+    return std::make_unique<KLASS>(std::string{#NAME}, VERSION, std::string{MAINTAINER}, std::string{HOMEPAGE}, pluginServices); \
 } \
 BOOST_DLL_ALIAS(Make_##NAME##_Plugin, make_##NAME##_plugin) \
 BOOST_DLL_ALIAS(PROGOPTIONS, get_##NAME##_plugin_progoptions)
--- a/fairmq/PluginManager.h
+++ b/fairmq/PluginManager.h
@@ -11,7 +11,6 @@

 #include <fairmq/Plugin.h>
 #include <fairmq/PluginServices.h>
-#include <fairmq/tools/CppSTL.h>
 #include <fairmq/tools/Strings.h>

 #define BOOST_FILESYSTEM_VERSION 3
@@ -31,9 +30,7 @@
 #include <vector>
 #include <utility> // forward

-namespace fair
-{
-namespace mq
+namespace fair::mq
 {

 /**
@@ -80,7 +77,7 @@ class PluginManager
    auto ForEachPluginProgOptions(std::function<void (boost::program_options::options_description)> func) const -> void { for(const auto& pair : fPluginProgOptions) { func(pair.second); } }

    template<typename... Args>
-    auto EmplacePluginServices(Args&&... args) -> void { fPluginServices = fair::mq::tools::make_unique<PluginServices>(std::forward<Args>(args)...); }
+    auto EmplacePluginServices(Args&&... args) -> void { fPluginServices = std::make_unique<PluginServices>(std::forward<Args>(args)...); }

    auto WaitForPluginsToReleaseDeviceControl() -> void { fPluginServices->WaitForReleaseDeviceControl(); }

@@ -126,7 +123,6 @@ class PluginManager
    std::map<std::string, boost::program_options::options_description> fPluginProgOptions;
 }; /* class PluginManager */

-} /* namespace mq */
-} /* namespace fair */
+} // namespace fair::mq

 #endif /* FAIR_MQ_PLUGINMANAGER_H */
--- a/fairmq/PluginServices.h
+++ b/fairmq/PluginServices.h
@@ -26,9 +26,7 @@
 #include <unordered_map>
 #include <vector>

-namespace fair
-{
-namespace mq
+namespace fair::mq
 {

 /**
@@ -281,7 +279,6 @@ class PluginServices
    std::condition_variable fReleaseDeviceControlCondition;
 }; /* class PluginServices */

-} /* namespace mq */
-} /* namespace fair */
+} // namespace fair::mq

 #endif /* FAIR_MQ_PLUGINSERVICES_H */
--- a/fairmq/ProgOptions.cxx
+++ b/fairmq/ProgOptions.cxx
@@ -39,9 +39,7 @@ struct ValInfo
    string origin;
 };

-namespace fair
-{
-namespace mq
+namespace fair::mq
 {

 ValInfo ConvertVarValToValInfo(const po::variable_value& v)
@@ -79,7 +77,7 @@ ProgOptions::ProgOptions()
    fAllOptions.add_options()
        ("help,h",                                                      "Print help")
        ("version,v",                                                   "Print version")
-        ("severity",      po::value<string>()->default_value("debug"),  "Log severity level (console): trace, debug, info, state, warn, error, fatal, nolog")
+        ("severity",      po::value<string>()->default_value(""),       "Log severity level (console): trace, debug, info, state, warn, error, fatal, nolog.")
        ("file-severity", po::value<string>()->default_value("debug"),  "Log severity level (file): trace, debug, info, state, warn, error, fatal, nolog")
        ("verbosity",     po::value<string>()->default_value("medium"), "Log verbosity level: veryhigh, high, medium, low")
        ("color",         po::value<bool  >()->default_value(true),     "Log color (true/false)")
@@ -449,6 +447,4 @@ void ProgOptions::PrintOptionsRaw() const
    }
 }

-
-} // namespace mq
-} // namespace fair
+} // namespace fair::mq
--- a/fairmq/ProgOptions.h
+++ b/fairmq/ProgOptions.h
@@ -26,9 +26,7 @@
 #include <vector>
 #include <stdexcept>

-namespace fair
-{
-namespace mq
+namespace fair::mq
 {

 struct PropertyNotFoundError : std::runtime_error { using std::runtime_error::runtime_error; };
@@ -270,7 +268,6 @@ class ProgOptions
    mutable std::mutex fMtx;
 };

-} // namespace mq
-} // namespace fair
+} // namespace fair::mq

 #endif /* FAIR_MQ_PROGOPTIONS_H */
--- a/fairmq/ProgOptionsFwd.h
+++ b/fairmq/ProgOptionsFwd.h
@@ -9,13 +9,10 @@
 #ifndef FAIR_MQ_PROGOPTIONSFWD_H
 #define FAIR_MQ_PROGOPTIONSFWD_H

-namespace fair
-{
-namespace mq
+namespace fair::mq
 {
 class ProgOptions;
 }
-}

 using FairMQProgOptions = fair::mq::ProgOptions;

--- a/fairmq/Properties.cxx
+++ b/fairmq/Properties.cxx
@@ -7,17 +7,13 @@
 ********************************************************************************/

 #include <fairmq/Properties.h>
-#include <fairmq/Tools.h>

 #include <boost/filesystem.hpp>

 using namespace std;
-using namespace fair::mq::tools;
 using boost::any_cast;

-namespace fair
-{
-namespace mq
+namespace fair::mq
 {

 template<class T>
@@ -76,9 +72,11 @@ unordered_map<type_index, function<pair<string, string>(const Property&)>> Prope
    { type_index(typeid(const char*)),                     [](const Property& p) { return pair<string, string>{ string(any_cast<const char*>(p)), "string" }; } },
    { type_index(typeid(string)),                          [](const Property& p) { return pair<string, string>{ any_cast<string>(p), "string" }; } },
    { type_index(typeid(int)),                             [](const Property& p) { return getString<int>(p, "int"); } },
+    { type_index(typeid(short)),                           [](const Property& p) { return getString<short>(p, "short"); } },
    { type_index(typeid(long)),                            [](const Property& p) { return getString<long>(p, "long"); } },
    { type_index(typeid(long long)),                       [](const Property& p) { return getString<long long>(p, "long long"); } },
    { type_index(typeid(unsigned)),                        [](const Property& p) { return getString<unsigned>(p, "unsigned"); } },
+    { type_index(typeid(unsigned short)),                  [](const Property& p) { return getString<unsigned short>(p, "unsigned short"); } },
    { type_index(typeid(unsigned long)),                   [](const Property& p) { return getString<unsigned long>(p, "unsigned long"); } },
    { type_index(typeid(unsigned long long)),              [](const Property& p) { return getString<unsigned long long>(p, "unsigned long long"); } },
    { type_index(typeid(float)),                           [](const Property& p) { return getStringPair<float>(p, "float"); } },
@@ -92,9 +90,11 @@ unordered_map<type_index, function<pair<string, string>(const Property&)>> Prope
    { type_index(typeid(vector<unsigned char>)),           [](const Property& p) { return getStringPair<vector<unsigned char>>(p, "vector<unsigned char>"); } },
    { type_index(typeid(vector<string>)),                  [](const Property& p) { return getStringPair<vector<string>>(p, "vector<string>"); } },
    { type_index(typeid(vector<int>)),                     [](const Property& p) { return getStringPair<vector<int>>(p, "vector<int>"); } },
+    { type_index(typeid(vector<short>)),                   [](const Property& p) { return getStringPair<vector<short>>(p, "vector<short>"); } },
    { type_index(typeid(vector<long>)),                    [](const Property& p) { return getStringPair<vector<long>>(p, "vector<long>"); } },
    { type_index(typeid(vector<long long>)),               [](const Property& p) { return getStringPair<vector<long long>>(p, "vector<long long>"); } },
    { type_index(typeid(vector<unsigned>)),                [](const Property& p) { return getStringPair<vector<unsigned>>(p, "vector<unsigned>"); } },
+    { type_index(typeid(vector<unsigned short>)),          [](const Property& p) { return getStringPair<vector<unsigned short>>(p, "vector<unsigned short>"); } },
    { type_index(typeid(vector<unsigned long>)),           [](const Property& p) { return getStringPair<vector<unsigned long>>(p, "vector<unsigned long>"); } },
    { type_index(typeid(vector<unsigned long long>)),      [](const Property& p) { return getStringPair<vector<unsigned long long>>(p, "vector<unsigned long long>"); } },
    { type_index(typeid(vector<float>)),                   [](const Property& p) { return getStringPair<vector<float>>(p, "vector<float>"); } },
@@ -110,9 +110,11 @@ unordered_map<type_index, void(*)(const EventManager&, const string&, const Prop
    { type_index(typeid(const char*)),                     [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, string>(k, string(any_cast<const char*>(p))); } },
    { type_index(typeid(string)),                          [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, string>(k, any_cast<string>(p)); } },
    { type_index(typeid(int)),                             [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, int>(k, any_cast<int>(p)); } },
+    { type_index(typeid(short)),                           [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, short>(k, any_cast<short>(p)); } },
    { type_index(typeid(long)),                            [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, long>(k, any_cast<long>(p)); } },
    { type_index(typeid(long long)),                       [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, long long>(k, any_cast<long long>(p)); } },
    { type_index(typeid(unsigned)),                        [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, unsigned>(k, any_cast<unsigned>(p)); } },
+    { type_index(typeid(unsigned short)),                  [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, unsigned short>(k, any_cast<unsigned short>(p)); } },
    { type_index(typeid(unsigned long)),                   [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, unsigned long>(k, any_cast<unsigned long>(p)); } },
    { type_index(typeid(unsigned long long)),              [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, unsigned long long>(k, any_cast<unsigned long long>(p)); } },
    { type_index(typeid(float)),                           [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, float>(k, any_cast<float>(p)); } },
@@ -126,9 +128,11 @@ unordered_map<type_index, void(*)(const EventManager&, const string&, const Prop
    { type_index(typeid(vector<unsigned char>)),           [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, vector<unsigned char>>(k, any_cast<vector<unsigned char>>(p)); } },
    { type_index(typeid(vector<string>)),                  [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, vector<string>>(k, any_cast<vector<string>>(p)); } },
    { type_index(typeid(vector<int>)),                     [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, vector<int>>(k, any_cast<vector<int>>(p)); } },
+    { type_index(typeid(vector<short>)),                   [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, vector<short>>(k, any_cast<vector<short>>(p)); } },
    { type_index(typeid(vector<long>)),                    [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, vector<long>>(k, any_cast<vector<long>>(p)); } },
    { type_index(typeid(vector<long long>)),               [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, vector<long long>>(k, any_cast<vector<long long>>(p)); } },
    { type_index(typeid(vector<unsigned>)),                [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, vector<unsigned>>(k, any_cast<vector<unsigned>>(p)); } },
+    { type_index(typeid(vector<unsigned short>)),          [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, vector<unsigned short>>(k, any_cast<vector<unsigned short>>(p)); } },
    { type_index(typeid(vector<unsigned long>)),           [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, vector<unsigned long>>(k, any_cast<vector<unsigned long>>(p)); } },
    { type_index(typeid(vector<unsigned long long>)),      [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, vector<unsigned long long>>(k, any_cast<vector<unsigned long long>>(p)); } },
    { type_index(typeid(vector<float>)),                   [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, vector<float>>(k, any_cast<vector<float>>(p)); } },
@@ -137,5 +141,4 @@ unordered_map<type_index, void(*)(const EventManager&, const string&, const Prop
    { type_index(typeid(vector<boost::filesystem::path>)), [](const EventManager& em, const string& k, const Property& p) { em.Emit<PropertyChange, vector<boost::filesystem::path>>(k, any_cast<vector<boost::filesystem::path>>(p)); } },
 };

-} // namespace mq
-} // namespace fair
+} // namespace fair::mq
--- a/fairmq/Properties.h
+++ b/fairmq/Properties.h
@@ -22,9 +22,7 @@
 #include <typeinfo>
 #include <utility> // pair

-namespace fair
-{
-namespace mq
+namespace fair::mq
 {

 using Property = boost::any;
@@ -72,7 +70,6 @@ class PropertyHelper
    static std::unordered_map<std::type_index, std::function<std::pair<std::string, std::string>(const Property&)>> fTypeInfos;
 };

-}
 }

 #endif /* FAIR_MQ_PROPERTIES_H */
--- a/fairmq/StateMachine.cxx
+++ b/fairmq/StateMachine.cxx
@@ -35,9 +35,7 @@ using namespace boost::msm::front;
 using namespace boost::msm::back;
 namespace bmpl = boost::mpl;

-namespace fair
-{
-namespace mq
+namespace fair::mq
 {
 namespace fsm
 {
@@ -239,8 +237,7 @@ struct Machine_ : public state_machine_def<Machine_>
 using FairMQFSM = state_machine<Machine_>;

 } // namespace fsm
-} // namespace mq
-} // namespace fair
+} // namespace fair::mq

 using namespace fair::mq::fsm;
 using namespace fair::mq;
--- a/fairmq/StateMachine.h
+++ b/fairmq/StateMachine.h
@@ -16,9 +16,7 @@
 #include <functional>
 #include <stdexcept>

-namespace fair
-{
-namespace mq
+namespace fair::mq
 {

 class StateMachine
@@ -56,7 +54,6 @@ class StateMachine
    std::shared_ptr<void> fFsm;
 };

-} // namespace mq
-} // namespace fair
+} // namespace fair::mq

 #endif /* FAIRMQSTATEMACHINE_H_ */
--- a/fairmq/StateQueue.h
+++ b/fairmq/StateQueue.h
@@ -17,9 +17,7 @@
 #include <utility> // pair
 #include <condition_variable>

-namespace fair
-{
-namespace mq
+namespace fair::mq
 {

 class StateQueue
@@ -88,7 +86,6 @@ class StateQueue
    std::condition_variable fCV;
 };

-} // namespace mq
-} // namespace fair
+} // namespace fair::mq

-#endif /* FAIRMQSTATEQUEUE_H_ */
+#endif /* FAIRMQSTATEQUEUE_H_ */
--- a/fairmq/States.cxx
+++ b/fairmq/States.cxx
@@ -13,9 +13,7 @@

 using namespace std;

-namespace fair
-{
-namespace mq
+namespace fair::mq
 {

 array<string, 16> stateNames =
@@ -114,5 +112,4 @@ Transition GetTransition(const string& transition)
    return transitions.at(transition);
 }

-} // namespace mq
-} // namespace fair
+} // namespace fair::mq
--- a/fairmq/States.h
+++ b/fairmq/States.h
@@ -13,9 +13,7 @@
 #include <ostream>
 #include <stdexcept>

-namespace fair
-{
-namespace mq
+namespace fair::mq
 {

 enum class State : int
@@ -64,7 +62,6 @@ struct DeviceErrorState : std::runtime_error { using std::runtime_error::runtime
 inline std::ostream& operator<<(std::ostream& os, const State& state) { return os << GetStateName(state); }
 inline std::ostream& operator<<(std::ostream& os, const Transition& transition) { return os << GetTransitionName(transition); }

-} // namespace mq
-} // namespace fair
+} // namespace fair::mq

 #endif /* FAIRMQSTATES_H_ */
--- a/fairmq/SuboptParser.cxx
+++ b/fairmq/SuboptParser.cxx
@@ -1,5 +1,5 @@
 /********************************************************************************
- *    Copyright (C) 2017 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH    *
+ * Copyright (C) 2017-2021 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH  *
 *                                                                              *
 *              This software is distributed under the terms of the             *
 *              GNU Lesser General Public License (LGPL) version 3,             *
@@ -23,9 +23,7 @@
 using boost::property_tree::ptree;
 using namespace std;

-namespace fair
-{
-namespace mq
+namespace fair::mq
 {

 enum channelOptionKeyIds
@@ -86,6 +84,7 @@ Properties SuboptParser(const vector<string>& channelConfig, const string& devic
        char* subopts = &argString[0];
        char* value = nullptr;
        while (subopts && *subopts != 0 && *subopts != ' ') {
+            char* cur = subopts;
            int subopt = getsubopt(&subopts, (char**)channelOptionKeys, &value);
            if (subopt == NAME) {
                channelName = value;
@@ -96,6 +95,8 @@ Properties SuboptParser(const vector<string>& channelConfig, const string& devic
                socketsArray.push_back(make_pair("", socketProperties));
            } else if (subopt >= 0 && value != nullptr) {
                channelProperties.put(channelOptionKeys[subopt], value);
+            } else if (subopt == -1) {
+                LOG(warn) << "Ignoring unknown argument in --channel-config: " << cur;
            }
        }

@@ -120,4 +121,3 @@ Properties SuboptParser(const vector<string>& channelConfig, const string& devic
 }

 }
-}
--- a/fairmq/SuboptParser.h
+++ b/fairmq/SuboptParser.h
@@ -19,9 +19,7 @@
 #include <vector>
 #include <string>

-namespace fair
-{
-namespace mq
+namespace fair::mq
 {

 /**
@@ -43,7 +41,6 @@ namespace mq

 Properties SuboptParser(const std::vector<std::string>& channelConfig, const std::string& deviceId);

-}
 }

 #endif /* FAIR_MQ_SUBOPTPARSER_H */
--- a/fairmq/Transports.h
+++ b/fairmq/Transports.h
@@ -9,15 +9,14 @@
 #ifndef FAIR_MQ_TRANSPORTS_H
 #define FAIR_MQ_TRANSPORTS_H

-#include <fairmq/tools/CppSTL.h>
+#include <fairmq/tools/Strings.h>

 #include <memory>
+#include <stdexcept>
 #include <string>
 #include <unordered_map>

-namespace fair
-{
-namespace mq
+namespace fair::mq
 {

 enum class Transport
@@ -28,20 +27,11 @@ enum class Transport
    OFI
 };

-} /* namespace mq */
-} /* namespace fair */
+struct TransportError : std::runtime_error { using std::runtime_error::runtime_error; };

-namespace std
-{
+} // namespace fair::mq

-template<>
-struct hash<fair::mq::Transport> : fair::mq::tools::HashEnum<fair::mq::Transport> {};
-
-} /* namespace std */
-
-namespace fair
-{
-namespace mq
+namespace fair::mq
 {

 static std::unordered_map<std::string, Transport> TransportTypes {
@@ -58,7 +48,18 @@ static std::unordered_map<Transport, std::string> TransportNames {
    { Transport::OFI, "ofi" }
 };

-} /* namespace mq */
-} /* namespace fair */
+inline std::string TransportName(Transport transport)
+{
+    return TransportNames[transport];
+}
+
+inline Transport TransportType(const std::string& transport)
+try {
+    return TransportTypes.at(transport);
+} catch (std::out_of_range&) {
+    throw TransportError(tools::ToString("Unknown transport provided: ", transport));
+}
+
+} // namespace fair::mq

 #endif /* FAIR_MQ_TRANSPORTS_H */
--- a/fairmq/Version.h.in
+++ b/fairmq/Version.h.in
@@ -21,7 +21,7 @@
 #define FAIRMQ_GIT_DATE "@PROJECT_GIT_DATE@"
 #define FAIRMQ_REPO_URL "https://github.com/FairRootGroup/FairMQ"
 #define FAIRMQ_LICENSE "LGPL-3.0"
-#define FAIRMQ_COPYRIGHT "2012-2020 GSI"
+#define FAIRMQ_COPYRIGHT "2012-2021 GSI"
 #define FAIRMQ_BUILD_TYPE "@CMAKE_BUILD_TYPE@"

 #endif // FAIR_MQ_VERSION_H
--- a/fairmq/devices/FairMQBenchmarkSampler.h
+++ b/fairmq/devices/FairMQBenchmarkSampler.h
@@ -13,7 +13,6 @@
 #include "FairMQDevice.h"
 #include "tools/RateLimit.h"

-#include <atomic>
 #include <chrono>
 #include <cstddef>   // size_t
 #include <cstdint>   // uint64_t
@@ -106,15 +105,12 @@ class FairMQBenchmarkSampler : public FairMQDevice
        LOG(info) << "Done " << fNumIterations << " iterations in " << std::chrono::duration<double, std::milli>(tEnd - tStart).count() << "ms.";
    }

-    virtual ~FairMQBenchmarkSampler() {}
-
  protected:
    bool fMultipart;
    bool fMemSet;
    size_t fNumParts;
    size_t fMsgSize;
    size_t fMsgAlignment;
-    std::atomic<int> fMsgCounter;
    float fMsgRate;
    uint64_t fNumIterations;
    uint64_t fMaxIterations;
--- a/fairmq/devices/FairMQSink.h
+++ b/fairmq/devices/FairMQSink.h
@@ -17,19 +17,24 @@

 #include "../FairMQDevice.h"
 #include "../FairMQLogger.h"
+#include <fairmq/tools/Strings.h>

 #include <chrono>
 #include <string>
+#include <fstream>
+#include <stdexcept>

-// template<typename OutputPolicy>
-class FairMQSink : public FairMQDevice   //, public OutputPolicy
+class FairMQSink : public FairMQDevice
 {
  public:
    FairMQSink()
        : fMultipart(false)
        , fMaxIterations(0)
        , fNumIterations(0)
+        , fMaxFileSize(0)
+        , fBytesWritten(0)
        , fInChannelName()
+        , fOutFilename()
    {}

    ~FairMQSink() {}
@@ -38,13 +43,21 @@ class FairMQSink : public FairMQDevice   //, public OutputPolicy
    bool fMultipart;
    uint64_t fMaxIterations;
    uint64_t fNumIterations;
+    uint64_t fMaxFileSize;
+    uint64_t fBytesWritten;
    std::string fInChannelName;
+    std::string fOutFilename;
+    std::fstream fOutputFile;

    void InitTask() override
    {
-        fMultipart = fConfig->GetProperty<bool>("multipart");
+        fMultipart     = fConfig->GetProperty<bool>("multipart");
        fMaxIterations = fConfig->GetProperty<uint64_t>("max-iterations");
+        fMaxFileSize   = fConfig->GetProperty<uint64_t>("max-file-size");
        fInChannelName = fConfig->GetProperty<std::string>("in-channel");
+        fOutFilename   = fConfig->GetProperty<std::string>("out-filename");
+
+        fBytesWritten = 0;
    }

    void Run() override
@@ -52,41 +65,83 @@ class FairMQSink : public FairMQDevice   //, public OutputPolicy
        // store the channel reference to avoid traversing the map on every loop iteration
        FairMQChannel& dataInChannel = fChannels.at(fInChannelName).at(0);

-        LOG(info) << "Starting the benchmark and expecting to receive " << fMaxIterations << " messages.";
+        LOG(info) << "Starting sink and expecting to receive " << fMaxIterations << " messages.";
        auto tStart = std::chrono::high_resolution_clock::now();

+        if (!fOutFilename.empty()) {
+            LOG(debug) << "Incoming messages will be written to file: " << fOutFilename;
+            if (fMaxFileSize != 0) {
+                LOG(debug) << "File output will stop after " << fMaxFileSize << " bytes";
+            } else {
+                LOG(debug) << "ATTENTION: --max-file-size is 0 - output file will continue to grow until sink is stopped";
+            }
+
+            fOutputFile.open(fOutFilename, std::ios::out | std::ios::binary);
+            if (!fOutputFile) {
+                LOG(error) << "Could not open '" << fOutFilename;
+                throw std::runtime_error(fair::mq::tools::ToString("Could not open '", fOutFilename));
+            }
+        }
+
        while (!NewStatePending()) {
            if (fMultipart) {
                FairMQParts parts;
-
-                if (dataInChannel.Receive(parts) >= 0) {
-                    if (fMaxIterations > 0) {
-                        if (fNumIterations >= fMaxIterations) {
-                            LOG(info) << "Configured maximum number of iterations reached.";
-                            break;
-                        }
+                if (dataInChannel.Receive(parts) < 0) {
+                    continue;
+                }
+                if (fOutputFile.is_open()) {
+                    for (const auto& part : parts) {
+                        WriteToFile(static_cast<const char*>(part->GetData()), part->GetSize());
                    }
-                    fNumIterations++;
                }
            } else {
                FairMQMessagePtr msg(dataInChannel.NewMessage());
-
-                if (dataInChannel.Receive(msg) >= 0) {
-                    if (fMaxIterations > 0) {
-                        if (fNumIterations >= fMaxIterations) {
-                            LOG(info) << "Configured maximum number of iterations reached.";
-                            break;
-                        }
-                    }
-                    fNumIterations++;
+                if (dataInChannel.Receive(msg) < 0) {
+                    continue;
+                }
+                if (fOutputFile.is_open()) {
+                    WriteToFile(static_cast<const char*>(msg->GetData()), msg->GetSize());
                }
            }
+
+            if (fMaxFileSize > 0 && fBytesWritten >= fMaxFileSize) {
+                LOG(info) << "Written " << fBytesWritten << " bytes, stopping...";
+                break;
+            }
+            if (fMaxIterations > 0) {
+                if (fNumIterations >= fMaxIterations) {
+                    LOG(info) << "Configured maximum number of iterations reached.";
+                    break;
+                }
+            }
+            fNumIterations++;
+        }
+
+        if (fOutputFile.is_open()) {
+            fOutputFile.flush();
+            fOutputFile.close();
        }

        auto tEnd = std::chrono::high_resolution_clock::now();
+        auto ms = std::chrono::duration<double, std::milli>(tEnd - tStart).count();
+        LOG(info) << "Received " << fNumIterations << " messages in " << ms << "ms.";
+        if (!fOutFilename.empty()) {
+            auto sec = std::chrono::duration<double>(tEnd - tStart).count();
+            LOG(info) << "Closed '" << fOutFilename << "' after writing " << fBytesWritten << " bytes."
+                      << "(" << (fBytesWritten / (1000. * 1000.)) / sec << " MB/s)";
+        }

-        LOG(info) << "Leaving RUNNING state. Received " << fNumIterations << " messages in "
-                  << std::chrono::duration<double, std::milli>(tEnd - tStart).count() << "ms.";
+        LOG(info) << "Leaving RUNNING state.";
+    }
+
+    void WriteToFile(const char* ptr, size_t size)
+    {
+        fOutputFile.write(ptr, size);
+        if (fOutputFile.bad()) {
+            LOG(error) << "failed writing to file";
+            throw std::runtime_error("failed writing to file");
+        }
+        fBytesWritten += size;
    }
 };

--- a/fairmq/ofi/Context.cxx
+++ b/fairmq/ofi/Context.cxx
@@ -7,7 +7,7 @@
 ********************************************************************************/

 #include <fairmq/ofi/Context.h>
-#include <fairmq/Tools.h>
+#include <fairmq/tools/Strings.h>
 #include <FairMQLogger.h>

 #include <asiofi/version.hpp>
@@ -22,11 +22,7 @@
 #include <string.h>
 #include <sys/socket.h>

-namespace fair
-{
-namespace mq
-{
-namespace ofi
+namespace fair::mq::ofi
 {

 using namespace std;
@@ -134,6 +130,4 @@ auto Context::MakeSendMessage(size_t size) -> MessagePtr
    return fSendFactory.CreateMessage(size);
 }

-} /* namespace ofi */
-} /* namespace mq */
-} /* namespace fair */
+} // namespace fair::mq::ofi
--- a/fairmq/ofi/Context.h
+++ b/fairmq/ofi/Context.h
@@ -24,11 +24,7 @@
 #include <thread>
 #include <vector>

-namespace fair
-{
-namespace mq
-{
-namespace ofi
+namespace fair::mq::ofi
 {

 enum class ConnectionType : bool { Bind, Connect };
@@ -88,8 +84,6 @@ class Context

 struct ContextError : std::runtime_error { using std::runtime_error::runtime_error; };

-} /* namespace ofi */
-} /* namespace mq */
-} /* namespace fair */
+} // namespace fair::mq::ofi

 #endif /* FAIR_MQ_OFI_CONTEXT_H */
--- a/fairmq/ofi/ControlMessages.h
+++ b/fairmq/ofi/ControlMessages.h
@@ -17,8 +17,8 @@
 #include <memory>
 #include <type_traits>

-namespace boost {
-namespace asio {
+namespace boost::asio
+{

 template<typename PodType>
 auto buffer(const PodType& obj) -> boost::asio::const_buffer
@@ -26,12 +26,10 @@ auto buffer(const PodType& obj) -> boost::asio::const_buffer
    return boost::asio::const_buffer(static_cast<const void*>(&obj), sizeof(PodType));
 }

-}   // namespace asio
-}   // namespace boost
+} // namespace boost::asio

-namespace fair {
-namespace mq {
-namespace ofi {
+namespace fair::mq::ofi
+{

 enum class ControlMessageType
 {
@@ -109,8 +107,6 @@ auto MakeControlMessage(Args&&... args) -> ControlMessage
    return ctrl;
 }

-}   // namespace ofi
-}   // namespace mq
-}   // namespace fair
+} // namespace fair::mq::ofi

 #endif /* FAIR_MQ_OFI_CONTROLMESSAGES_H */ 
--- a/fairmq/ofi/Message.cxx
+++ b/fairmq/ofi/Message.cxx
@@ -7,7 +7,6 @@
 ********************************************************************************/

 #include <fairmq/ofi/Message.h>
-#include <fairmq/Tools.h>
 #include <FairMQLogger.h>

 #include <asiofi.hpp>
@@ -15,11 +14,7 @@
 #include <cstdlib>
 #include <zmq.h>

-namespace fair
-{
-namespace mq
-{
-namespace ofi
+namespace fair::mq::ofi
 {

 using namespace std;
@@ -110,6 +105,12 @@ auto Message::Rebuild() -> void
    fHint = nullptr;
 }

+auto Message::Rebuild(Alignment /* alignment */) -> void
+{
+    // TODO: implement alignment
+    Rebuild();
+}
+
 auto Message::Rebuild(const size_t size) -> void
 {
    if (fFreeFunction) {
@@ -131,6 +132,12 @@ auto Message::Rebuild(const size_t size) -> void
    fHint = nullptr;
 }

+auto Message::Rebuild(const size_t size, Alignment /* alignment */) -> void
+{
+    // TODO: implement alignment
+    Rebuild(size);
+}
+
 auto Message::Rebuild(void* /*data*/, const size_t size, fairmq_free_fn* ffn, void* hint) -> void
 {
    if (fFreeFunction) {
@@ -190,6 +197,4 @@ Message::~Message()
    }
 }

-} /* namespace ofi */
-} /* namespace mq */
-} /* namespace fair */
+} // namespace fair::mq::ofi
--- a/fairmq/ofi/Message.h
+++ b/fairmq/ofi/Message.h
@@ -17,11 +17,7 @@
 #include <cstddef> // size_t
 #include <zmq.h>

-namespace fair
-{
-namespace mq
-{
-namespace ofi
+namespace fair::mq::ofi
 {

 /**
@@ -52,7 +48,9 @@ class Message final : public fair::mq::Message
    Message operator=(const Message&) = delete;

    auto Rebuild() -> void override;
+    auto Rebuild(Alignment alignment) -> void override;
    auto Rebuild(const size_t size) -> void override;
+    auto Rebuild(const size_t size, Alignment alignment) -> void override;
    auto Rebuild(void* data, const size_t size, fairmq_free_fn* ffn, void* hint = nullptr) -> void override;

    auto GetData() const -> void* override;
@@ -75,8 +73,6 @@ class Message final : public fair::mq::Message
    boost::container::pmr::memory_resource* fPmr;
 }; /* class Message */  

-} /* namespace ofi */
-} /* namespace mq */
-} /* namespace fair */
+} // namespace fair::mq::ofi

 #endif /* FAIR_MQ_OFI_MESSAGE_H */
--- a/fairmq/ofi/Poller.cxx
+++ b/fairmq/ofi/Poller.cxx
@@ -8,16 +8,12 @@

 #include <fairmq/ofi/Poller.h>
 #include <fairmq/ofi/Socket.h>
-#include <fairmq/Tools.h>
+#include <fairmq/tools/Strings.h>
 #include <FairMQLogger.h>

 #include <zmq.h>

-namespace fair
-{
-namespace mq
-{
-namespace ofi
+namespace fair::mq::ofi
 {

 using namespace std;
@@ -153,6 +149,4 @@ Poller::~Poller()
    delete[] fItems;
 }

-} /* namespace ofi */
-} /* namespace mq */
-} /* namespace fair */
+} // namespace fair::mq::ofi
--- a/fairmq/ofi/Poller.h
+++ b/fairmq/ofi/Poller.h
@@ -18,11 +18,7 @@

 #include <zmq.h>

-namespace fair
-{
-namespace mq
-{
-namespace ofi
+namespace fair::mq::ofi
 {

 class TransportFactory;
@@ -63,8 +59,6 @@ class Poller final : public FairMQPoller
    std::unordered_map<std::string, int> fOffsetMap;
 }; /* class Poller */

-} /* namespace ofi */
-} /* namespace mq */
-} /* namespace fair */
+} // namespace fair::mq::ofi

 #endif /* FAIR_MQ_OFI_POLLER_H */
--- a/fairmq/ofi/Socket.cxx
+++ b/fairmq/ofi/Socket.cxx
@@ -9,7 +9,7 @@
 #include <fairmq/ofi/ControlMessages.h>
 #include <fairmq/ofi/Socket.h>
 #include <fairmq/ofi/TransportFactory.h>
-#include <fairmq/Tools.h>
+#include <fairmq/tools/Strings.h>
 #include <FairMQLogger.h>

 #include <asiofi.hpp>
@@ -25,11 +25,7 @@
 #include <mutex>
 #include <queue>

-namespace fair
-{
-namespace mq
-{
-namespace ofi
+namespace fair::mq::ofi
 {

 using namespace std;
@@ -74,16 +70,16 @@ auto Socket::InitOfi(Address addr) -> void
          hints.set_provider("verbs");
      }
      if (fRemoteAddr == addr) {
-          fOfiInfo = tools::make_unique<asiofi::info>(addr.Ip.c_str(), std::to_string(addr.Port).c_str(), 0, hints);
+          fOfiInfo = make_unique<asiofi::info>(addr.Ip.c_str(), std::to_string(addr.Port).c_str(), 0, hints);
      } else {
-          fOfiInfo = tools::make_unique<asiofi::info>(addr.Ip.c_str(), std::to_string(addr.Port).c_str(), FI_SOURCE, hints);
+          fOfiInfo = make_unique<asiofi::info>(addr.Ip.c_str(), std::to_string(addr.Port).c_str(), FI_SOURCE, hints);
      }

      LOG(debug) << "OFI transport (" << fId << "): " << *fOfiInfo;

-      fOfiFabric = tools::make_unique<asiofi::fabric>(*fOfiInfo);
+      fOfiFabric = make_unique<asiofi::fabric>(*fOfiInfo);

-      fOfiDomain = tools::make_unique<asiofi::domain>(*fOfiFabric);
+      fOfiDomain = make_unique<asiofi::domain>(*fOfiFabric);
    }
 }

@@ -96,7 +92,7 @@ try {

    InitOfi(fLocalAddr);

-    fPassiveEndpoint = tools::make_unique<asiofi::passive_endpoint>(fContext.GetIoContext(), *fOfiFabric);
+    fPassiveEndpoint = make_unique<asiofi::passive_endpoint>(fContext.GetIoContext(), *fOfiFabric);
    //fPassiveEndpoint->set_local_address(Context::ConvertAddress(fLocalAddr));

    BindControlEndpoint();
@@ -128,7 +124,7 @@ auto Socket::BindControlEndpoint() -> void
    fPassiveEndpoint->listen([&](asiofi::info&& info) {
        LOG(debug) << "OFI transport (" << fId
                   << "): control band connection request received. Accepting ...";
-        fControlEndpoint = tools::make_unique<asiofi::connected_endpoint>(
+        fControlEndpoint = make_unique<asiofi::connected_endpoint>(
            fContext.GetIoContext(), *fOfiDomain, info);
        fControlEndpoint->enable();
        fControlEndpoint->accept([&]() {
@@ -148,7 +144,7 @@ auto Socket::BindDataEndpoint() -> void
    fPassiveEndpoint->listen([&](asiofi::info&& info) {
        LOG(debug) << "OFI transport (" << fId
                   << "): data band connection request received. Accepting ...";
-        fDataEndpoint = tools::make_unique<asiofi::connected_endpoint>(
+        fDataEndpoint = make_unique<asiofi::connected_endpoint>(
            fContext.GetIoContext(), *fOfiDomain, info);
        fDataEndpoint->enable();
        fDataEndpoint->accept([&]() {
@@ -215,7 +211,7 @@ auto Socket::ConnectEndpoint(std::unique_ptr<asiofi::connected_endpoint>& endpoi

    std::string band(type == Band::Control ? "control" : "data");

-    endpoint = tools::make_unique<asiofi::connected_endpoint>(fContext.GetIoContext(), *fOfiDomain);
+    endpoint = make_unique<asiofi::connected_endpoint>(fContext.GetIoContext(), *fOfiDomain);
    endpoint->enable();

    LOG(debug) << "OFI transport (" << fId << "): Sending " << band << " band connection request to " << fRemoteAddr;
@@ -254,7 +250,7 @@ auto Socket::ConnectEndpoint(std::unique_ptr<asiofi::connected_endpoint>& endpoi
    }
 }

-auto Socket::Send(MessagePtr& msg, const int /*timeout*/) -> int
+auto Socket::Send(MessagePtr& msg, const int /*timeout*/) -> int64_t
 {
    // timeout argument not yet implemented

@@ -284,7 +280,7 @@ try {
    return size;
 } catch (const std::exception& e) {
    LOG(error) << e.what();
-    return static_cast<int64_t>(TransferResult::error);
+    return static_cast<int64_t>(TransferCode::error);
 }

 auto Socket::SendQueueReader() -> void
@@ -412,7 +408,7 @@ auto Socket::SendQueueReaderStatic() -> void
    });
 }

-auto Socket::Receive(MessagePtr& msg, const int /*timeout*/) -> int
+auto Socket::Receive(MessagePtr& msg, const int /*timeout*/) -> int64_t
 try {
    // timeout argument not yet implemented

@@ -431,7 +427,7 @@ try {
    return size;
 } catch (const std::exception& e) {
    LOG(error) << e.what();
-    return static_cast<int>(TransferResult::error);
+    return static_cast<int>(TransferCode::error);
 }

 auto Socket::Receive(std::vector<MessagePtr>& msgVec, const int /*timeout*/) -> int64_t
@@ -456,7 +452,7 @@ try {
    return size;
 } catch (const std::exception& e) {
    LOG(error) << e.what();
-    return static_cast<int64_t>(TransferResult::error);
+    return static_cast<int64_t>(TransferCode::error);
 }

 auto Socket::RecvControlQueueReader() -> void
@@ -683,6 +679,4 @@ Socket::~Socket()
    }
 }

-} /* namespace ofi */
-} /* namespace mq */
-} /* namespace fair */
+} // namespace fair::mq::ofi
--- a/fairmq/ofi/Socket.h
+++ b/fairmq/ofi/Socket.h
@@ -23,11 +23,7 @@
 #include <mutex>


-namespace fair
-{
-namespace mq
-{
-namespace ofi
+namespace fair::mq::ofi
 {

 /**
@@ -49,8 +45,8 @@ class Socket final : public fair::mq::Socket
    auto Bind(const std::string& address) -> bool override;
    auto Connect(const std::string& address) -> bool override;

-    auto Send(MessagePtr& msg, int timeout = 0) -> int override;
-    auto Receive(MessagePtr& msg, int timeout = 0) -> int override;
+    auto Send(MessagePtr& msg, int timeout = 0) -> int64_t override;
+    auto Receive(MessagePtr& msg, int timeout = 0) -> int64_t override;
    auto Send(std::vector<MessagePtr>& msgVec, int timeout = 0) -> int64_t override;
    auto Receive(std::vector<MessagePtr>& msgVec, int timeout = 0) -> int64_t override;

@@ -120,8 +116,6 @@ class Socket final : public fair::mq::Socket

 struct SilentSocketError : SocketError { using SocketError::SocketError; };

-} /* namespace ofi */
-} /* namespace mq */
-} /* namespace fair */
+} // namespace fair::mq::ofi

 #endif /* FAIR_MQ_OFI_SOCKET_H */
--- a/fairmq/ofi/TransportFactory.cxx
+++ b/fairmq/ofi/TransportFactory.cxx
@@ -10,15 +10,10 @@
 #include <fairmq/ofi/Poller.h>
 #include <fairmq/ofi/Socket.h>
 #include <fairmq/ofi/TransportFactory.h>
-#include <fairmq/Tools.h>

 #include <stdexcept>

-namespace fair
-{
-namespace mq
-{
-namespace ofi
+namespace fair::mq::ofi
 {

 using namespace std;
@@ -122,6 +117,4 @@ auto TransportFactory::GetType() const -> Transport
    return Transport::OFI;
 }

-} /* namespace ofi */
-} /* namespace mq */
-} /* namespace fair */
+} // namespace fair::mq::ofi
--- a/fairmq/ofi/TransportFactory.h
+++ b/fairmq/ofi/TransportFactory.h
@@ -15,11 +15,7 @@

 #include <asiofi.hpp>

-namespace fair
-{
-namespace mq
-{
-namespace ofi
+namespace fair::mq::ofi
 {

 /**
@@ -69,8 +65,6 @@ class TransportFactory final : public FairMQTransportFactory
    asiofi::allocated_pool_resource fMemoryResource;
 }; /* class TransportFactory */  

-} /* namespace ofi */
-} /* namespace mq */
-} /* namespace fair */
+} // namespace fair::mq::ofi

 #endif /* FAIR_MQ_OFI_TRANSPORTFACTORY_H */
--- a/fairmq/plugins/Control.cxx
+++ b/fairmq/plugins/Control.cxx
@@ -8,14 +8,16 @@

 #include "Control.h"

-#include <termios.h> // for the interactive mode
-#include <poll.h> // for the interactive mode
+#include <atomic>
+#include <chrono>
 #include <csignal> // catching system signals
 #include <cstdlib>
 #include <functional>
-#include <atomic>
+#include <iostream>
 #include <thread>
-#include <chrono>
+
+#include <poll.h> // for the interactive mode
+#include <termios.h> // for the interactive mode

 using namespace std;

@@ -41,11 +43,7 @@ namespace
    }
 }

-namespace fair
-{
-namespace mq
-{
-namespace plugins
+namespace fair::mq::plugins
 {

 Control::Control(const string& name, const Plugin::Version version, const string& maintainer, const string& homepage, PluginServices* pluginServices)
@@ -473,6 +471,4 @@ Control::~Control()
    UnsubscribeFromDeviceStateChange();
 }

-} /* namespace plugins */
-} /* namespace mq */
-} /* namespace fair */
+} // namespace fair::mq::plugins
--- a/fairmq/plugins/Control.h
+++ b/fairmq/plugins/Control.h
@@ -21,11 +21,7 @@
 #include <atomic>
 #include <stdexcept>

-namespace fair
-{
-namespace mq
-{
-namespace plugins
+namespace fair::mq::plugins
 {

 class Control : public Plugin
@@ -68,8 +64,6 @@ REGISTER_FAIRMQ_PLUGIN(
                                  // boost::optional<boost::program_options::options_description>
 )

-} /* namespace plugins */
-} /* namespace mq */
-} /* namespace fair */
+} // namespace fair::mq::plugins

 #endif /* FAIR_MQ_PLUGINS_CONTROL */
--- a/fairmq/plugins/DDS/DDS.cxx
+++ b/fairmq/plugins/DDS/DDS.cxx
@@ -22,11 +22,7 @@
 using namespace std;
 using fair::mq::tools::ToString;

-namespace fair
-{
-namespace mq
-{
-namespace plugins
+namespace fair::mq::plugins
 {

 DDS::DDS(const string& name,
@@ -357,7 +353,7 @@ auto DDS::HandleCmd(const string& id, sdk::cmd::Cmd& cmd, const string& cond, ui
        } break;
        case Type::dump_config: {
            stringstream ss;
-            for (const auto pKey : GetPropertyKeys()) {
+            for (const auto& pKey : GetPropertyKeys()) {
                ss << id << ": " << pKey << " -> " << GetPropertyAsString(pKey) << "\n";
            }
            Cmds outCmds(make<Config>(id, ss.str()));
@@ -458,6 +454,4 @@ DDS::~DDS()
    }
 }

-} /* namespace plugins */
-} /* namespace mq */
-} /* namespace fair */
+} // namespace fair::mq::plugins
--- a/fairmq/plugins/DDS/DDS.h
+++ b/fairmq/plugins/DDS/DDS.h
@@ -32,11 +32,7 @@
 #include <utility> // pair
 #include <vector>

-namespace fair
-{
-namespace mq
-{
-namespace plugins
+namespace fair::mq::plugins
 {

 struct DDSConfig
@@ -196,8 +192,6 @@ REGISTER_FAIRMQ_PLUGIN(
    DDSProgramOptions                            // custom program options for the plugin
 )

-} /* namespace plugins */
-} /* namespace mq */
-} /* namespace fair */
+} // namespace fair::mq::plugins

 #endif /* FAIR_MQ_PLUGINS_DDS */
--- a/fairmq/plugins/PMIx/PMIxCommands.h
+++ b/fairmq/plugins/PMIx/PMIxCommands.h
@@ -13,7 +13,7 @@

 #include <FairMQLogger.h>
 #include <fairmq/tools/Semaphore.h>
-#include <fairmq/tools/CppSTL.h>
+#include <memory> // make_unique
 #include <string>

 namespace pmix
@@ -156,7 +156,7 @@ class Commands

    void Send(const std::string& msg, const std::vector<proc>& destination)
    {
-        std::unique_ptr<Holder> holder = fair::mq::tools::make_unique<Holder>();
+        std::unique_ptr<Holder> holder = std::make_unique<Holder>();

        PMIX_DATA_ARRAY_CREATE(holder->fData, destination.size(), PMIX_PROC);
        memcpy(holder->fData->array, destination.data(), destination.size() * sizeof(pmix_proc_t));
--- a/fairmq/plugins/PMIx/PMIxPlugin.cxx
+++ b/fairmq/plugins/PMIx/PMIxPlugin.cxx
@@ -9,7 +9,7 @@
 #include "PMIxPlugin.h"

 #include <fairmq/sdk/commands/Commands.h>
-#include <fairmq/Tools.h>
+#include <fairmq/tools/Strings.h>

 #include <sstream>
 #include <stdexcept>
@@ -18,11 +18,7 @@
 using namespace std;
 using namespace fair::mq::sdk::cmd;

-namespace fair
-{
-namespace mq
-{
-namespace plugins
+namespace fair::mq::plugins
 {

 PMIxPlugin::PMIxPlugin(const string& name,
@@ -304,6 +300,4 @@ auto PMIxPlugin::WaitForExitingAck() -> void
    });
 }

-} /* namespace plugins */
-} /* namespace mq */
-} /* namespace fair */
+} // namespace fair::mq::plugins
--- a/fairmq/plugins/PMIx/PMIxPlugin.h
+++ b/fairmq/plugins/PMIx/PMIxPlugin.h
@@ -24,11 +24,7 @@
 #include <unistd.h>
 #include <vector>

-namespace fair
-{
-namespace mq
-{
-namespace plugins
+namespace fair::mq::plugins
 {

 class PMIxPlugin : public Plugin
@@ -88,8 +84,6 @@ REGISTER_FAIRMQ_PLUGIN(
    PMIxProgramOptions                           // custom program options for the plugin
 )

-} /* namespace plugins */
-} /* namespace mq */
-} /* namespace fair */
+} // namespace fair::mq::plugins

 #endif /* FAIR_MQ_PLUGINS_PMIX */
--- a/fairmq/plugins/config/Config.cxx
+++ b/fairmq/plugins/config/Config.cxx
@@ -15,11 +15,7 @@

 using namespace std;

-namespace fair
-{
-namespace mq
-{
-namespace plugins
+namespace fair::mq::plugins
 {

 Config::Config(const string& name, const Plugin::Version version, const string& maintainer, const string& homepage, PluginServices* pluginServices)
@@ -89,6 +85,4 @@ Config::~Config()
    UnsubscribeFromDeviceStateChange();
 }

-} /* namespace plugins */
-} /* namespace mq */
-} /* namespace fair */
+} // namespace fair::mq::plugins
--- a/fairmq/plugins/config/Config.h
+++ b/fairmq/plugins/config/Config.h
@@ -14,11 +14,7 @@

 #include <string>

-namespace fair
-{
-namespace mq
-{
-namespace plugins
+namespace fair::mq::plugins
 {

 class Config : public Plugin
@@ -40,8 +36,6 @@ REGISTER_FAIRMQ_PLUGIN(
    ConfigPluginProgramOptions
 )

-} /* namespace plugins */
-} /* namespace mq */
-} /* namespace fair */
+} // namespace fair::mq::plugins

 #endif /* FAIR_MQ_PLUGINS_CONFIG */
--- a/fairmq/run/runSink.cxx
+++ b/fairmq/run/runSink.cxx
@@ -15,6 +15,8 @@ void addCustomOptions(bpo::options_description& options)
 {
    options.add_options()
        ("in-channel", bpo::value<std::string>()->default_value("data"), "Name of the input channel")
+        ("out-filename", bpo::value<std::string>()->default_value(""), "Write incoming message buffers to the specified file")
+        ("max-file-size", bpo::value<uint64_t>()->default_value(2000000000), "Maximum file size for the file output (0 - unlimited)")
        ("max-iterations", bpo::value<uint64_t>()->default_value(0), "Number of run iterations (0 - infinite)")
        ("multipart", bpo::value<bool>()->default_value(false), "Handle multipart payloads");
 }
--- a/fairmq/run/runUuidGenerator.cxx
+++ b/fairmq/run/runUuidGenerator.cxx
@@ -5,7 +5,7 @@
 *              GNU Lesser General Public Licence (LGPL) version 3,             *
 *                  copied verbatim in the file "LICENSE"                       *
 ********************************************************************************/
-#include <fairmq/Tools.h>
+#include <fairmq/tools/Unique.h>

 #include <boost/program_options.hpp>

--- a/fairmq/sdk/AsioAsyncOp.h
+++ b/fairmq/sdk/AsioAsyncOp.h
@@ -12,6 +12,7 @@
 #include <asio/associated_allocator.hpp>
 #include <asio/associated_executor.hpp>
 #include <asio/executor_work_guard.hpp>
+#include <asio/dispatch.hpp>
 #include <asio/system_executor.hpp>
 #include <chrono>
 #include <exception>
@@ -28,9 +29,8 @@
 #define FAIR_LOG LOG
 #endif /* ifndef FAIR_LOG */

-namespace fair {
-namespace mq {
-namespace sdk {
+namespace fair::mq::sdk
+{

 template<typename... SignatureArgTypes>
 struct AsioAsyncOpImplBase
@@ -69,17 +69,16 @@ struct AsioAsyncOpImpl : AsioAsyncOpImplBase<SignatureArgTypes...>
            throw RuntimeError("Async operation already completed");
        }

-        GetEx2().dispatch(
-            [=, handler = std::move(fHandler)]() mutable {
-                try {
-                    handler(ec, args...);
-                } catch (const std::exception& e) {
-                    FAIR_LOG(error) << "Uncaught exception in AsioAsyncOp completion handler: " << e.what();
-                } catch (...) {
-                    FAIR_LOG(error) << "Unknown uncaught exception in AsioAsyncOp completion handler.";
-                }
-            },
-            GetAlloc2());
+        asio::dispatch(GetEx2(),
+          [=, handler = std::move(fHandler)]() mutable {
+              try {
+                  handler(ec, args...);
+              } catch (const std::exception& e) {
+                  FAIR_LOG(error) << "Uncaught exception in AsioAsyncOp completion handler: " << e.what();
+              } catch (...) {
+                  FAIR_LOG(error) << "Unknown uncaught exception in AsioAsyncOp completion handler.";
+              }
+          });

        fWork1.reset();
        fWork2.reset();
@@ -219,9 +218,6 @@ struct AsioAsyncOp<Executor,
    }
 };

-} /* namespace sdk */
-} /* namespace mq */
-} /* namespace fair */
+} // namespace fair::mq::sdk

 #endif /* FAIR_MQ_SDK_ASIOASYNCOP_H */
-
--- a/fairmq/sdk/AsioBase.h
+++ b/fairmq/sdk/AsioBase.h
@@ -9,16 +9,15 @@
 #ifndef FAIR_MQ_SDK_ASIOBASE_H
 #define FAIR_MQ_SDK_ASIOBASE_H

-#include <asio/executor.hpp>
+#include <asio/any_io_executor.hpp>
 #include <fairmq/sdk/Traits.h>
 #include <memory>
 #include <utility>

-namespace fair {
-namespace mq {
-namespace sdk {
+namespace fair::mq::sdk
+{

-using DefaultExecutor = asio::executor;
+using DefaultExecutor = asio::any_io_executor;
 using DefaultAllocator = std::allocator<int>;

 /**
@@ -69,8 +68,6 @@ class AsioBase
    AllocatorType fAllocator;
 };

-} /* namespace sdk */
-} /* namespace mq */
-} /* namespace fair */
+} // namespace fair::mq::sdk

 #endif /* FAIR_MQ_SDK_ASIOBASE_H */
--- a/fairmq/sdk/DDSAgent.h
+++ b/fairmq/sdk/DDSAgent.h
@@ -16,9 +16,8 @@
 #include <chrono>
 #include <cstdint>

-namespace fair {
-namespace mq {
-namespace sdk {
+namespace fair::mq::sdk
+{

 /**
 * @class DDSAgent <fairmq/sdk/DDSAgent.h>
@@ -74,8 +73,6 @@ class DDSAgent
    std::string fUsername;
 };

-}   // namespace sdk
-}   // namespace mq
-}   // namespace fair
+} // namespace fair::mq::sdk

 #endif /* FAIR_MQ_SDK_DDSSAGENT_H */
--- a/fairmq/sdk/DDSCollection.h
+++ b/fairmq/sdk/DDSCollection.h
@@ -14,9 +14,8 @@
 #include <ostream>
 #include <cstdint>

-namespace fair {
-namespace mq {
-namespace sdk {
+namespace fair::mq::sdk
+{

 /**
 * @class DDSCollection <fairmq/sdk/DDSCollection.h>
@@ -42,8 +41,6 @@ class DDSCollection
    Id fId;
 };

-}   // namespace sdk
-}   // namespace mq
-}   // namespace fair
+} // namespace fair::mq::sdk

 #endif /* FAIR_MQ_SDK_DDSCOLLECTION_H */
--- a/fairmq/sdk/DDSEnvironment.cxx
+++ b/fairmq/sdk/DDSEnvironment.cxx
@@ -11,14 +11,13 @@
 #include <cstdlib>
 #include <dds/dds.h>
 #include <fairlogger/Logger.h>
-#include <fairmq/Tools.h>
+#include <fairmq/tools/InstanceLimit.h>
 #include <fairmq/sdk/DDSInfo.h>
 #include <sstream>
 #include <utility>

-namespace fair {
-namespace mq {
-namespace sdk {
+namespace fair::mq::sdk
+{

 struct DDSEnvironment::Impl
 {
@@ -133,6 +132,4 @@ auto operator<<(std::ostream& os, DDSEnvironment env) -> std::ostream&
              << "$DDS_CONFIG_HOME: " << env.GetConfigHome() / DDSEnvironment::Path(".DDS");
 }

-}   // namespace sdk
-}   // namespace mq
-}   // namespace fair
+} // namespace fair::mq::sdk
--- a/fairmq/sdk/DDSEnvironment.h
+++ b/fairmq/sdk/DDSEnvironment.h
@@ -13,9 +13,8 @@
 #include <memory>
 #include <ostream>

-namespace fair {
-namespace mq {
-namespace sdk {
+namespace fair::mq::sdk
+{

 /**
 * @class DDSEnvironment DDSSession.h <fairmq/sdk/DDSSession.h>
@@ -40,8 +39,6 @@ class DDSEnvironment

 using DDSEnv = DDSEnvironment;

-}   // namespace sdk
-}   // namespace mq
-}   // namespace fair
+} // namespace fair::mq::sdk

 #endif /* FAIR_MQ_SDK_DDSENVIRONMENT_H */
--- a/fairmq/sdk/DDSInfo.h.in
+++ b/fairmq/sdk/DDSInfo.h.in
@@ -11,23 +11,11 @@

 #include <string>

-namespace dds {
-namespace tools_api {
+namespace dds::tools_api { class CSession; }
+namespace dds::topology_api { class CTopology; }

-class CSession;
-
-}   // namespace tools_api
-
-namespace topology_api {
-
-class CTopology;
-
-}   // namespace topology_api
-}   // namespace dds
-
-namespace fair {
-namespace mq {
-namespace sdk {
+namespace fair::mq::sdk
+{

 const std::string DDSVersion("@DDS_VERSION@");
 const std::string DDSInstallPrefix("@DDS_INSTALL_PREFIX@");
@@ -36,8 +24,6 @@ const std::string DDSIncludeDir("@DDS_INCDIR@");
 const std::string DDSLibraryDir("@DDS_LIBDIR@");
 const std::string DDSPluginDir("@DDS_PLUGINDIR@");

-}   // namespace sdk
-}   // namespace mq
-}   // namespace fair
+} // namespace fair::mq::sdk

 #endif /* FAIR_MQ_SDK_DDSINFO_H */
--- a/fairmq/sdk/DDSSession.cxx
+++ b/fairmq/sdk/DDSSession.cxx
@@ -14,7 +14,8 @@
 #include <cstdlib>
 #include <dds/dds.h>
 #include <fairlogger/Logger.h>
-#include <fairmq/Tools.h>
+#include <fairmq/tools/Strings.h>
+#include <fairmq/tools/Semaphore.h>
 #include <fairmq/sdk/DDSAgent.h>
 #include <fairmq/sdk/DDSEnvironment.h>
 #include <fairmq/sdk/DDSTopology.h>
@@ -24,9 +25,8 @@
 #include <utility>
 #include <vector>

-namespace fair {
-namespace mq {
-namespace sdk {
+namespace fair::mq::sdk
+{

 auto operator<<(std::ostream& os, DDSRMSPlugin plugin) -> std::ostream&
 {
@@ -65,8 +65,6 @@ struct DDSSession::Impl
        , fId(to_string(fSession->create()))
        , fStopOnDestruction(false)
    {
-        setenv("DDS_SESSION_ID", fId.c_str(), 1);
-
        fDDSService.subscribeOnError([](const dds::intercom_api::EErrorCode errorCode, const std::string& msg) {
            std::cerr << "DDS error, error code: " << errorCode << ", error message: " << msg << std::endl;
        });
@@ -81,10 +79,6 @@ struct DDSSession::Impl
        , fStopOnDestruction(false)
    {
        fSession->attach(fId);
-        auto envId(std::getenv("DDS_SESSION_ID"));
-        if (envId != nullptr && std::string(envId) != fId) {
-            setenv("DDS_SESSION_ID", fId.c_str(), 1);
-        }

        fDDSService.subscribeOnError([](const dds::intercom_api::EErrorCode errorCode, const std::string& msg) {
            std::cerr << "DDS error, error code: " << errorCode << ", error message: " << msg << std::endl;
@@ -99,11 +93,6 @@ struct DDSSession::Impl
        , fId(to_string(fSession->getSessionID()))
        , fStopOnDestruction(false)
    {
-        auto envId(std::getenv("DDS_SESSION_ID"));
-        if (envId != nullptr && std::string(envId) != fId) {
-            setenv("DDS_SESSION_ID", fId.c_str(), 1);
-        }
-
        // Sanity check
        if (!fSession->IsRunning()) {
            throw std::runtime_error("Given CSession must be running");
@@ -123,10 +112,6 @@ struct DDSSession::Impl
    Impl(Impl&&) = delete;
    Impl& operator=(Impl&&) = delete;

-    struct Tag {};
-    friend auto operator<<(std::ostream& os, Tag) -> std::ostream& { return os << "DDSSession"; }
-    tools::InstanceLimiter<Tag, 1> fCount;
-
    DDSEnvironment fEnv;
    DDSRMSPlugin fRMSPlugin;
    Path fRMSConfig;
@@ -398,6 +383,4 @@ auto getMostRecentRunningDDSSession(DDSEnv env) -> DDSSession
    return DDSSession(DDSSession::Id(sessionId), std::move(env));
 }

-}   // namespace sdk
-}   // namespace mq
-}   // namespace fair
+} // namespace fair::mq::sdk
--- a/fairmq/sdk/DDSSession.h
+++ b/fairmq/sdk/DDSSession.h
@@ -24,9 +24,8 @@
 #include <functional>
 #include <vector>

-namespace fair {
-namespace mq {
-namespace sdk {
+namespace fair::mq::sdk
+{

 /**
 * @enum DDSRMSPlugin DDSSession.h <fairmq/sdk/DDSSession.h>
@@ -114,8 +113,6 @@ class DDSSession

 auto getMostRecentRunningDDSSession(DDSEnv env = {}) -> DDSSession;

-}   // namespace sdk
-}   // namespace mq
-}   // namespace fair
+} // namespace fair::mq::sdk

 #endif /* FAIR_MQ_SDK_DDSSESSION_H */
--- a/fairmq/sdk/DDSTask.h
+++ b/fairmq/sdk/DDSTask.h
@@ -14,9 +14,8 @@
 #include <ostream>
 #include <cstdint>

-namespace fair {
-namespace mq {
-namespace sdk {
+namespace fair::mq::sdk
+{

 /**
 * @class DDSTask <fairmq/sdk/DDSTask.h>
@@ -45,8 +44,6 @@ class DDSTask
    DDSCollection::Id fCollectionId;
 };

-}   // namespace sdk
-}   // namespace mq
-}   // namespace fair
+} // namespace fair::mq::sdk

 #endif /* FAIR_MQ_SDK_DDSTASK_H */
--- a/fairmq/sdk/DDSTopology.cxx
+++ b/fairmq/sdk/DDSTopology.cxx
@@ -11,16 +11,14 @@
 #include <boost/range/iterator_range.hpp>
 #include <dds/dds.h>
 #include <fairlogger/Logger.h>
-#include <fairmq/Tools.h>
 #include <fairmq/sdk/DDSEnvironment.h>
 #include <memory>
 #include <sstream>
 #include <stdexcept>
 #include <utility>

-namespace fair {
-namespace mq {
-namespace sdk {
+namespace fair::mq::sdk
+{

 struct DDSTopology::Impl
 {
@@ -113,6 +111,4 @@ try {
    return os << "DDS topology: " << t.GetName();
 }

-}   // namespace sdk
-}   // namespace mq
-}   // namespace fair
+} // namespace fair::mq::sdk
--- a/fairmq/sdk/DDSTopology.h
+++ b/fairmq/sdk/DDSTopology.h
@@ -18,9 +18,8 @@
 #include <string>
 #include <vector>

-namespace fair {
-namespace mq {
-namespace sdk {
+namespace fair::mq::sdk
+{

 /**
 * @class DDSTopology DDSTopology.h <fairmq/sdk/DDSTopology.h>
@@ -71,8 +70,6 @@ class DDSTopology

 using DDSTopo = DDSTopology;

-}   // namespace sdk
-}   // namespace mq
-}   // namespace fair
+} // namespace fair::mq::sdk

 #endif /* FAIR_MQ_SDK_DDSTOPOLOGY_H */
--- a/fairmq/sdk/Error.cxx
+++ b/fairmq/sdk/Error.cxx
@@ -8,8 +8,8 @@

 #include "Error.h"

-namespace fair {
-namespace mq {
+namespace fair::mq
+{

 const char* ErrorCategory::name() const noexcept
 {
@@ -40,5 +40,4 @@ const ErrorCategory errorCategory{};

 std::error_code MakeErrorCode(ErrorCode e) { return {static_cast<int>(e), errorCategory}; }

-}   // namespace mq
-}   // namespace fair
+} // namespace fair::mq
--- a/fairmq/sdk/Error.h
+++ b/fairmq/sdk/Error.h
@@ -13,9 +13,11 @@
 #include <stdexcept>
 #include <system_error>

-namespace fair {
-namespace mq {
-namespace sdk {
+namespace fair::mq
+{
+
+namespace sdk
+{

 struct RuntimeError : ::std::runtime_error
 {
@@ -45,15 +47,15 @@ struct ErrorCategory : std::error_category
  std::string message(int ev) const override;
 };

-} /* namespace mq */
-} /* namespace fair */
+} // namespace fair::mq

-namespace std {
+namespace std
+{

 template<>
 struct is_error_code_enum<fair::mq::ErrorCode> : true_type
 {};

-}   // namespace std
+} // namespace std

 #endif /* FAIR_MQ_SDK_ERROR_H */
--- a/fairmq/sdk/Topology.cxx
+++ b/fairmq/sdk/Topology.cxx
@@ -10,21 +10,20 @@

 #include <dds/dds.h>

-namespace fair {
-namespace mq {
-namespace sdk {
+namespace fair::mq::sdk
+{

 /// @brief Helper to (Re)Construct a FairMQ topology based on already existing native DDS API objects
 /// @param nativeSession Existing and initialized CSession (either via create() or attach())
 /// @param nativeTopo Existing CTopology that is activated on the given nativeSession
 /// @param env Optional DDSEnv (needed primarily for unit testing)
+/// @param blockUntilConnected if true, ctor will wait for all tasks to confirm subscriptions
 auto MakeTopology(dds::topology_api::CTopology nativeTopo,
                  std::shared_ptr<dds::tools_api::CSession> nativeSession,
-                  DDSEnv env) -> Topology
+                  DDSEnv env,
+                  bool blockUntilConnected) -> Topology
 {
-    return {DDSTopo(std::move(nativeTopo), env), DDSSession(std::move(nativeSession), env)};
+    return {DDSTopo(std::move(nativeTopo), env), DDSSession(std::move(nativeSession), env), blockUntilConnected};
 }

-}   // namespace sdk
-}   // namespace mq
-}   // namespace fair
+} // namespace fair::mq::sdk
--- a/fairmq/sdk/Topology.h
+++ b/fairmq/sdk/Topology.h
@@ -48,9 +48,8 @@
 #include <utility>
 #include <vector>

-namespace fair {
-namespace mq {
-namespace sdk {
+namespace fair::mq::sdk
+{

 using DeviceId = std::string;
 using DeviceState = fair::mq::State;
@@ -216,24 +215,30 @@ class BasicTopology : public AsioBase<Executor, Allocator>
    /// @brief (Re)Construct a FairMQ topology from an existing DDS topology
    /// @param topo DDSTopology
    /// @param session DDSSession
-    BasicTopology(DDSTopology topo, DDSSession session)
-        : BasicTopology<Executor, Allocator>(asio::system_executor(), std::move(topo), std::move(session))
+    /// @param blockUntilConnected if true, ctor will wait for all tasks to confirm subscriptions
+    BasicTopology(DDSTopology topo, DDSSession session, bool blockUntilConnected = false)
+        : BasicTopology<Executor, Allocator>(asio::system_executor(), std::move(topo), std::move(session), blockUntilConnected)
    {}

    /// @brief (Re)Construct a FairMQ topology from an existing DDS topology
    /// @param ex I/O executor to be associated
    /// @param topo DDSTopology
    /// @param session DDSSession
+    /// @param blockUntilConnected if true, ctor will wait for all tasks to confirm subscriptions
    /// @throws RuntimeError
    BasicTopology(const Executor& ex,
                  DDSTopology topo,
                  DDSSession session,
+                  bool blockUntilConnected = false,
                  Allocator alloc = DefaultAllocator())
        : AsioBase<Executor, Allocator>(ex, std::move(alloc))
        , fDDSSession(std::move(session))
        , fDDSTopo(std::move(topo))
        , fStateData()
        , fStateIndex()
+        , fMtx(std::make_unique<std::mutex>())
+        , fStateChangeSubscriptionsCV(std::make_unique<std::condition_variable>())
+        , fNumStateChangePublishers(0)
        , fHeartbeatsTimer(asio::system_executor())
        , fHeartbeatInterval(600000)
    {
@@ -249,6 +254,9 @@ class BasicTopology : public AsioBase<Executor, Allocator>

        fDDSSession.StartDDSService();
        SubscribeToStateChanges();
+        if (blockUntilConnected) {
+            WaitForPublisherCount(fStateIndex.size());
+        }
    }

    /// not copyable
@@ -263,7 +271,7 @@ class BasicTopology : public AsioBase<Executor, Allocator>
    {
        UnsubscribeFromStateChanges();

-        std::lock_guard<std::mutex> lk(fMtx);
+        std::lock_guard<std::mutex> lk(*fMtx);
        fDDSSession.UnsubscribeFromCommands();
        try {
            for (auto& op : fChangeStateOps) {
@@ -282,6 +290,14 @@ class BasicTopology : public AsioBase<Executor, Allocator>
        fHeartbeatsTimer.async_wait(std::bind(&BasicTopology::SendSubscriptionHeartbeats, this, std::placeholders::_1));
    }

+    void WaitForPublisherCount(unsigned int number)
+    {
+        std::unique_lock<std::mutex> lk(*fMtx);
+        fStateChangeSubscriptionsCV->wait(lk, [&](){
+            return fNumStateChangePublishers == number;
+        });
+    }
+
    void SendSubscriptionHeartbeats(const std::error_code& ec)
    {
        if (!ec) {
@@ -306,13 +322,7 @@ class BasicTopology : public AsioBase<Executor, Allocator>
        fDDSSession.SendCommand(cmd::Cmds(cmd::make<cmd::UnsubscribeFromStateChange>()).Serialize());

        // wait for all tasks to confirm unsubscription
-        std::unique_lock<std::mutex> lk(fMtx);
-        fStateChangeUnsubscriptionCV.wait(lk, [&](){
-            unsigned int count = std::count_if(fStateIndex.cbegin(), fStateIndex.cend(), [=](const auto& s) {
-                return fStateData.at(s.second).subscribed_to_state_changes == false;
-            });
-            return count == fStateIndex.size();
-        });
+        WaitForPublisherCount(0);
    }

    void SubscribeToCommands()
@@ -358,11 +368,19 @@ class BasicTopology : public AsioBase<Executor, Allocator>
            DDSTask::Id taskId(cmd.GetTaskId());

            try {
-                std::lock_guard<std::mutex> lk(fMtx);
+                std::unique_lock<std::mutex> lk(*fMtx);
                DeviceStatus& task = fStateData.at(fStateIndex.at(taskId));
-                task.subscribed_to_state_changes = true;
+                if (!task.subscribed_to_state_changes) {
+                    task.subscribed_to_state_changes = true;
+                    ++fNumStateChangePublishers;
+                } else {
+                    FAIR_LOG(warn) << "Task '" << task.taskId << "' sent subscription confirmation more than once";
+                }
+                lk.unlock();
+                fStateChangeSubscriptionsCV->notify_one();
            } catch (const std::exception& e) {
                FAIR_LOG(error) << "Exception in HandleCmd(cmd::StateChangeSubscription const&): " << e.what();
+                FAIR_LOG(error) << "Possibly no task with id '" << taskId << "'?";
            }
        } else {
            FAIR_LOG(error) << "State change subscription failed for device: " << cmd.GetDeviceId() << ", task id: " << cmd.GetTaskId();
@@ -375,11 +393,16 @@ class BasicTopology : public AsioBase<Executor, Allocator>
            DDSTask::Id taskId(cmd.GetTaskId());

            try {
-                std::unique_lock<std::mutex> lk(fMtx);
+                std::unique_lock<std::mutex> lk(*fMtx);
                DeviceStatus& task = fStateData.at(fStateIndex.at(taskId));
-                task.subscribed_to_state_changes = false;
+                if (task.subscribed_to_state_changes) {
+                    task.subscribed_to_state_changes = false;
+                    --fNumStateChangePublishers;
+                } else {
+                    FAIR_LOG(warn) << "Task '" << task.taskId << "' sent unsubscription confirmation more than once";
+                }
                lk.unlock();
-                fStateChangeUnsubscriptionCV.notify_one();
+                fStateChangeSubscriptionsCV->notify_one();
            } catch (const std::exception& e) {
                FAIR_LOG(error) << "Exception in HandleCmd(cmd::StateChangeUnsubscription const&): " << e.what();
            }
@@ -397,13 +420,14 @@ class BasicTopology : public AsioBase<Executor, Allocator>
        DDSTask::Id taskId(cmd.GetTaskId());

        try {
-            std::lock_guard<std::mutex> lk(fMtx);
+            std::lock_guard<std::mutex> lk(*fMtx);
            DeviceStatus& task = fStateData.at(fStateIndex.at(taskId));
            task.lastState = cmd.GetLastState();
            task.state = cmd.GetCurrentState();
            // if the task is exiting, it will not respond to unsubscription request anymore, set it to false now.
            if (task.state == DeviceState::Exiting) {
                task.subscribed_to_state_changes = false;
+                --fNumStateChangePublishers;
            }
            // FAIR_LOG(debug) << "Updated state entry: taskId=" << taskId << ", state=" << state;

@@ -422,7 +446,7 @@ class BasicTopology : public AsioBase<Executor, Allocator>
    {
        if (cmd.GetResult() != cmd::Result::Ok) {
            DDSTask::Id taskId(cmd.GetTaskId());
-            std::lock_guard<std::mutex> lk(fMtx);
+            std::lock_guard<std::mutex> lk(*fMtx);
            for (auto& op : fChangeStateOps) {
                if (!op.second.IsCompleted() && op.second.ContainsTask(taskId)) {
                    if (fStateData.at(fStateIndex.at(taskId)).state != op.second.GetTargetState()) {
@@ -438,7 +462,7 @@ class BasicTopology : public AsioBase<Executor, Allocator>

    auto HandleCmd(cmd::Properties const& cmd) -> void
    {
-        std::unique_lock<std::mutex> lk(fMtx);
+        std::unique_lock<std::mutex> lk(*fMtx);
        try {
            auto& op(fGetPropertiesOps.at(cmd.GetRequestId()));
            lk.unlock();
@@ -452,7 +476,7 @@ class BasicTopology : public AsioBase<Executor, Allocator>

    auto HandleCmd(cmd::PropertiesSet const& cmd) -> void
    {
-        std::unique_lock<std::mutex> lk(fMtx);
+        std::unique_lock<std::mutex> lk(*fMtx);
        try {
            auto& op(fSetPropertiesOps.at(cmd.GetRequestId()));
            lk.unlock();
@@ -659,7 +683,7 @@ class BasicTopology : public AsioBase<Executor, Allocator>
        return asio::async_initiate<CompletionToken, ChangeStateCompletionSignature>([&](auto handler) {
            typename ChangeStateOp::Id const id(tools::UuidHash());

-            std::lock_guard<std::mutex> lk(fMtx);
+            std::lock_guard<std::mutex> lk(*fMtx);

            for (auto it = begin(fChangeStateOps); it != end(fChangeStateOps);) {
                if (it->second.IsCompleted()) {
@@ -677,7 +701,7 @@ class BasicTopology : public AsioBase<Executor, Allocator>
                                      fDDSTopo.GetTasks(path),
                                      fStateData,
                                      timeout,
-                                      fMtx,
+                                      *fMtx,
                                      AsioBase<Executor, Allocator>::GetExecutor(),
                                      AsioBase<Executor, Allocator>::GetAllocator(),
                                      std::move(handler)));
@@ -762,7 +786,7 @@ class BasicTopology : public AsioBase<Executor, Allocator>
    /// @return map of id : DeviceStatus
    auto GetCurrentState() const -> TopologyState
    {
-        std::lock_guard<std::mutex> lk(fMtx);
+        std::lock_guard<std::mutex> lk(*fMtx);
        return fStateData;
    }

@@ -890,7 +914,7 @@ class BasicTopology : public AsioBase<Executor, Allocator>
        return asio::async_initiate<CompletionToken, WaitForStateCompletionSignature>([&](auto handler) {
            typename GetPropertiesOp::Id const id(tools::UuidHash());

-            std::lock_guard<std::mutex> lk(fMtx);
+            std::lock_guard<std::mutex> lk(*fMtx);

            for (auto it = begin(fWaitForStateOps); it != end(fWaitForStateOps);) {
                if (it->second.IsCompleted()) {
@@ -908,7 +932,7 @@ class BasicTopology : public AsioBase<Executor, Allocator>
                                      targetCurrentState,
                                      fDDSTopo.GetTasks(path),
                                      timeout,
-                                      fMtx,
+                                      *fMtx,
                                      AsioBase<Executor, Allocator>::GetExecutor(),
                                      AsioBase<Executor, Allocator>::GetAllocator(),
                                      std::move(handler)));
@@ -1071,7 +1095,7 @@ class BasicTopology : public AsioBase<Executor, Allocator>
            [&](auto handler) {
                typename GetPropertiesOp::Id const id(tools::UuidHash());

-                std::lock_guard<std::mutex> lk(fMtx);
+                std::lock_guard<std::mutex> lk(*fMtx);

                for (auto it = begin(fGetPropertiesOps); it != end(fGetPropertiesOps);) {
                    if (it->second.IsCompleted()) {
@@ -1087,7 +1111,7 @@ class BasicTopology : public AsioBase<Executor, Allocator>
                    std::forward_as_tuple(id,
                                          fDDSTopo.GetTasks(path).size(),
                                          timeout,
-                                          fMtx,
+                                          *fMtx,
                                          AsioBase<Executor, Allocator>::GetExecutor(),
                                          AsioBase<Executor, Allocator>::GetAllocator(),
                                          std::move(handler)));
@@ -1227,7 +1251,7 @@ class BasicTopology : public AsioBase<Executor, Allocator>
            [&](auto handler) {
                typename SetPropertiesOp::Id const id(tools::UuidHash());

-                std::lock_guard<std::mutex> lk(fMtx);
+                std::lock_guard<std::mutex> lk(*fMtx);

                for (auto it = begin(fGetPropertiesOps); it != end(fGetPropertiesOps);) {
                    if (it->second.IsCompleted()) {
@@ -1243,7 +1267,7 @@ class BasicTopology : public AsioBase<Executor, Allocator>
                    std::forward_as_tuple(id,
                                          fDDSTopo.GetTasks(path).size(),
                                          timeout,
-                                          fMtx,
+                                          *fMtx,
                                          AsioBase<Executor, Allocator>::GetExecutor(),
                                          AsioBase<Executor, Allocator>::GetAllocator(),
                                          std::move(handler)));
@@ -1296,9 +1320,10 @@ class BasicTopology : public AsioBase<Executor, Allocator>
    TopologyState fStateData;
    TopologyStateIndex fStateIndex;

-    mutable std::mutex fMtx;
+    mutable std::unique_ptr<std::mutex> fMtx;

-    std::condition_variable fStateChangeUnsubscriptionCV;
+    std::unique_ptr<std::condition_variable> fStateChangeSubscriptionsCV;
+    unsigned int fNumStateChangePublishers;
    asio::steady_timer fHeartbeatsTimer;
    Duration fHeartbeatInterval;

@@ -1334,12 +1359,12 @@ using Topo = Topology;
 /// @param nativeSession Existing and initialized CSession (either via create() or attach())
 /// @param nativeTopo Existing CTopology that is activated on the given nativeSession
 /// @param env Optional DDSEnv (needed primarily for unit testing)
+/// @param blockUntilConnected if true, ctor will wait for all tasks to confirm subscriptions
 auto MakeTopology(dds::topology_api::CTopology nativeTopo,
                  std::shared_ptr<dds::tools_api::CSession> nativeSession,
-                  DDSEnv env = {}) -> Topology;
+                  DDSEnv env = {},
+                  bool blockUntilConnected = false) -> Topology;

-}   // namespace sdk
-}   // namespace mq
-}   // namespace fair
+} // namespace fair::mq::sdk

 #endif /* FAIR_MQ_SDK_TOPOLOGY_H */
--- a/fairmq/sdk/Traits.h
+++ b/fairmq/sdk/Traits.h
@@ -13,8 +13,7 @@
 #include <asio/associated_executor.hpp>
 #include <type_traits>

-namespace asio {
-namespace detail {
+namespace asio::detail {

 /// Specialize to match our coding conventions
 template<typename T, typename Executor>
@@ -44,7 +43,6 @@ struct associated_allocator_impl<T,
    }
 };

-} /* namespace detail */
-} /* namespace asio */
+} /* namespace asio::detail */

 #endif /* FAIR_MQ_SDK_TRAITS_H */
--- a/fairmq/sdk/commands/Commands.cxx
+++ b/fairmq/sdk/commands/Commands.cxx
@@ -17,10 +17,8 @@

 using namespace std;

-namespace fair {
-namespace mq {
-namespace sdk {
-namespace cmd {
+namespace fair::mq::sdk::cmd
+{

 array<Result, 2> fbResultToResult =
 {
@@ -219,37 +217,37 @@ string Cmds::Serialize(const Format type) const

        switch (cmd->GetType()) {
            case Type::check_state: {
-                cmdBuilder = tools::make_unique<FBCommandBuilder>(fbb);
+                cmdBuilder = make_unique<FBCommandBuilder>(fbb);
            }
            break;
            case Type::change_state: {
-                cmdBuilder = tools::make_unique<FBCommandBuilder>(fbb);
+                cmdBuilder = make_unique<FBCommandBuilder>(fbb);
                cmdBuilder->add_transition(GetFBTransition(static_cast<ChangeState&>(*cmd).GetTransition()));
            }
            break;
            case Type::dump_config: {
-                cmdBuilder = tools::make_unique<FBCommandBuilder>(fbb);
+                cmdBuilder = make_unique<FBCommandBuilder>(fbb);
            }
            break;
            break;
            case Type::subscribe_to_state_change: {
                auto _cmd = static_cast<SubscribeToStateChange&>(*cmd);
-                cmdBuilder = tools::make_unique<FBCommandBuilder>(fbb);
+                cmdBuilder = make_unique<FBCommandBuilder>(fbb);
                cmdBuilder->add_interval(_cmd.GetInterval());
            }
            break;
            case Type::unsubscribe_from_state_change: {
-                cmdBuilder = tools::make_unique<FBCommandBuilder>(fbb);
+                cmdBuilder = make_unique<FBCommandBuilder>(fbb);
            }
            break;
            case Type::state_change_exiting_received: {
-                cmdBuilder = tools::make_unique<FBCommandBuilder>(fbb);
+                cmdBuilder = make_unique<FBCommandBuilder>(fbb);
            }
            break;
            case Type::get_properties: {
                auto _cmd = static_cast<GetProperties&>(*cmd);
                auto query = fbb.CreateString(_cmd.GetQuery());
-                cmdBuilder = tools::make_unique<FBCommandBuilder>(fbb);
+                cmdBuilder = make_unique<FBCommandBuilder>(fbb);
                cmdBuilder->add_request_id(_cmd.GetRequestId());
                cmdBuilder->add_property_query(query);
            }
@@ -263,21 +261,21 @@ string Cmds::Serialize(const Format type) const
                    propsVector.push_back(CreateFBProperty(fbb, key, val));
                }
                auto props = fbb.CreateVector(propsVector);
-                cmdBuilder = tools::make_unique<FBCommandBuilder>(fbb);
+                cmdBuilder = make_unique<FBCommandBuilder>(fbb);
                cmdBuilder->add_request_id(_cmd.GetRequestId());
                cmdBuilder->add_properties(props);
            }
            break;
            case Type::subscription_heartbeat: {
                auto _cmd = static_cast<SubscriptionHeartbeat&>(*cmd);
-                cmdBuilder = tools::make_unique<FBCommandBuilder>(fbb);
+                cmdBuilder = make_unique<FBCommandBuilder>(fbb);
                cmdBuilder->add_interval(_cmd.GetInterval());
            }
            break;
            case Type::current_state: {
                auto _cmd = static_cast<CurrentState&>(*cmd);
                auto deviceId = fbb.CreateString(_cmd.GetDeviceId());
-                cmdBuilder = tools::make_unique<FBCommandBuilder>(fbb);
+                cmdBuilder = make_unique<FBCommandBuilder>(fbb);
                cmdBuilder->add_device_id(deviceId);
                cmdBuilder->add_current_state(GetFBState(_cmd.GetCurrentState()));
            }
@@ -285,7 +283,7 @@ string Cmds::Serialize(const Format type) const
            case Type::transition_status: {
                auto _cmd = static_cast<TransitionStatus&>(*cmd);
                auto deviceId = fbb.CreateString(_cmd.GetDeviceId());
-                cmdBuilder = tools::make_unique<FBCommandBuilder>(fbb);
+                cmdBuilder = make_unique<FBCommandBuilder>(fbb);
                cmdBuilder->add_device_id(deviceId);
                cmdBuilder->add_task_id(_cmd.GetTaskId());
                cmdBuilder->add_result(GetFBResult(_cmd.GetResult()));
@@ -297,7 +295,7 @@ string Cmds::Serialize(const Format type) const
                auto _cmd = static_cast<Config&>(*cmd);
                auto deviceId = fbb.CreateString(_cmd.GetDeviceId());
                auto config = fbb.CreateString(_cmd.GetConfig());
-                cmdBuilder = tools::make_unique<FBCommandBuilder>(fbb);
+                cmdBuilder = make_unique<FBCommandBuilder>(fbb);
                cmdBuilder->add_device_id(deviceId);
                cmdBuilder->add_config_string(config);
            }
@@ -305,7 +303,7 @@ string Cmds::Serialize(const Format type) const
            case Type::state_change_subscription: {
                auto _cmd = static_cast<StateChangeSubscription&>(*cmd);
                auto deviceId = fbb.CreateString(_cmd.GetDeviceId());
-                cmdBuilder = tools::make_unique<FBCommandBuilder>(fbb);
+                cmdBuilder = make_unique<FBCommandBuilder>(fbb);
                cmdBuilder->add_device_id(deviceId);
                cmdBuilder->add_task_id(_cmd.GetTaskId());
                cmdBuilder->add_result(GetFBResult(_cmd.GetResult()));
@@ -314,7 +312,7 @@ string Cmds::Serialize(const Format type) const
            case Type::state_change_unsubscription: {
                auto _cmd = static_cast<StateChangeUnsubscription&>(*cmd);
                auto deviceId = fbb.CreateString(_cmd.GetDeviceId());
-                cmdBuilder = tools::make_unique<FBCommandBuilder>(fbb);
+                cmdBuilder = make_unique<FBCommandBuilder>(fbb);
                cmdBuilder->add_device_id(deviceId);
                cmdBuilder->add_task_id(_cmd.GetTaskId());
                cmdBuilder->add_result(GetFBResult(_cmd.GetResult()));
@@ -323,7 +321,7 @@ string Cmds::Serialize(const Format type) const
            case Type::state_change: {
                auto _cmd = static_cast<StateChange&>(*cmd);
                auto deviceId = fbb.CreateString(_cmd.GetDeviceId());
-                cmdBuilder = tools::make_unique<FBCommandBuilder>(fbb);
+                cmdBuilder = make_unique<FBCommandBuilder>(fbb);
                cmdBuilder->add_device_id(deviceId);
                cmdBuilder->add_task_id(_cmd.GetTaskId());
                cmdBuilder->add_last_state(GetFBState(_cmd.GetLastState()));
@@ -342,7 +340,7 @@ string Cmds::Serialize(const Format type) const
                    propsVector.push_back(prop);
                }
                auto props = fbb.CreateVector(propsVector);
-                cmdBuilder = tools::make_unique<FBCommandBuilder>(fbb);
+                cmdBuilder = make_unique<FBCommandBuilder>(fbb);
                cmdBuilder->add_device_id(deviceId);
                cmdBuilder->add_request_id(_cmd.GetRequestId());
                cmdBuilder->add_result(GetFBResult(_cmd.GetResult()));
@@ -352,7 +350,7 @@ string Cmds::Serialize(const Format type) const
            case Type::properties_set: {
                auto _cmd = static_cast<PropertiesSet&>(*cmd);
                auto deviceId = fbb.CreateString(_cmd.GetDeviceId());
-                cmdBuilder = tools::make_unique<FBCommandBuilder>(fbb);
+                cmdBuilder = make_unique<FBCommandBuilder>(fbb);
                cmdBuilder->add_device_id(deviceId);
                cmdBuilder->add_request_id(_cmd.GetRequestId());
                cmdBuilder->add_result(GetFBResult(_cmd.GetResult()));
@@ -478,7 +476,4 @@ void Cmds::Deserialize(const string& str, const Format type)
    }
 }

-}   // namespace cmd
-}   // namespace sdk
-}   // namespace mq
-}   // namespace fair
+} // namespace fair::mq::sdk::cmd
--- a/fairmq/sdk/commands/Commands.h
+++ b/fairmq/sdk/commands/Commands.h
@@ -10,7 +10,6 @@
 #define FAIR_MQ_SDK_COMMANDFACTORY

 #include <fairmq/States.h>
-#include <fairmq/tools/CppSTL.h>

 #include <vector>
 #include <string>
@@ -18,13 +17,7 @@
 #include <type_traits>
 #include <stdexcept>

-namespace fair
-{
-namespace mq
-{
-namespace sdk
-{
-namespace cmd
+namespace fair::mq::sdk::cmd
 {

 enum class Format : int {
@@ -354,7 +347,7 @@ struct PropertiesSet : Cmd {
 template<typename C, typename... Args>
 std::unique_ptr<Cmd> make(Args&&... args)
 {
-    return fair::mq::tools::make_unique<C>(std::forward<Args>(args)...);
+    return std::make_unique<C>(std::forward<Args>(args)...);
 }

 struct Cmds
@@ -415,9 +408,6 @@ std::string GetTypeName(const Type type);
 inline std::ostream& operator<<(std::ostream& os, const Result& result) { return os << GetResultName(result); }
 inline std::ostream& operator<<(std::ostream& os, const Type& type) { return os << GetTypeName(type); }

-} /* namespace cmd */
-} /* namespace sdk */
-} /* namespace mq */
-} /* namespace fair */
+} // namespace fair::mq::sdk::cmd

 #endif /* FAIR_MQ_SDK_COMMANDFACTORY */
--- a/fairmq/sdk/commands/CommandsFormatDef.h.in
+++ b/fairmq/sdk/commands/CommandsFormatDef.h.in
@@ -8,14 +8,11 @@

 #include <string>

-namespace fair {
-namespace mq {
-namespace sdk {
+namespace fair::mq::sdk
+{
 namespace cmd {

 constexpr auto commandsFormatDefFbs = R"(@commands_format_def_fbs@)";

 }   // namespace cmd
-}   // namespace sdk
-}   // namespace mq
-}   // namespace fair
+} // namespace fair::mq::sdk
--- a/fairmq/sdk/runDDSCommandUI.cxx
+++ b/fairmq/sdk/runDDSCommandUI.cxx
@@ -9,6 +9,7 @@
 #include <fairmq/sdk/commands/Commands.h>
 #include <fairmq/States.h>
 #include <fairmq/SDK.h>
+#include <fairmq/tools/Strings.h>

 #include <boost/program_options.hpp>

@@ -63,14 +64,25 @@ void handleCommand(const string& command, const string& path, unsigned int timeo
    if (command == "c") {
        cout << "> checking state of the devices" << endl;
        auto const result = topo.GetCurrentState();
+        bool error = false;
        for (const auto& d : result) {
            cout << d.taskId << " : " << d.state << endl;
+            if (d.state == sdk::DeviceState::Error) {
+                error = true;
+            }
+        }
+        if (error) {
+            throw runtime_error("Some of the devices are in the Error state");
        }
        return;
    } else if (command == "o") {
        cout << "> dumping config of " << (path == "" ? "all" : path) << endl;
        // TODO: extend this regex to return all properties, once command size limitation is removed.
        auto const result = topo.GetProperties("^(session|id)$", path, std::chrono::milliseconds(timeout));
+        if (result.first != std::error_code()) {
+            cout << "ERROR: GetProperties failed for '" << path << "': " << result.first.message() << endl;
+            throw runtime_error(tools::ToString("GetProperties failed for '", path, "': ", result.first.message()));
+        }
        for (const auto& d : result.second.devices) {
            for (auto const& p : d.second.props) {
                cout << d.first << ": " << p.first << " : " << p.second << endl;
@@ -80,11 +92,15 @@ void handleCommand(const string& command, const string& path, unsigned int timeo
    } else if (command == "p") {
        if (pKey == "" || pVal == "") {
            cout << "cannot send property with empty key and/or value! given key: '" << pKey << "', value: '" << pVal << "'." << endl;
-            return;
+            throw runtime_error(tools::ToString("cannot send property with empty key and/or value! given key: '", pKey, "', value: '", pVal, "'."));
        }
        const DeviceProperties props{{pKey, pVal}};
        cout << "> setting properties --> " << (path == "" ? "all" : path) << endl;
-        topo.SetProperties(props, path);
+        auto const result = topo.SetProperties(props, path);
+        if (result.first != std::error_code()) {
+            cout << "ERROR: SetProperties failed for '" << path << "': " << result.first.message() << endl;
+            throw runtime_error(tools::ToString("SetProperties failed for '", path, "': ", result.first.message()));
+        }
        // give dds time to complete request
        this_thread::sleep_for(chrono::milliseconds(100));
        return;
@@ -125,10 +141,11 @@ void handleCommand(const string& command, const string& path, unsigned int timeo
    } else {
        cout << "\033[01;32mInvalid input: [" << command << "]\033[0m" << endl;
        printControlsHelp();
-        return;
+        throw runtime_error(tools::ToString("\033[01;32mInvalid input: [", command, "]\033[0m"));
    }
    if (changeStateResult.first != std::error_code()) {
        cout << "ERROR: ChangeState failed for '" << path << "': " << changeStateResult.first.message() << endl;
+        throw runtime_error(tools::ToString("ERROR: ChangeState failed for '", path, "': ", changeStateResult.first.message()));
    }
 }

@@ -148,7 +165,11 @@ void sendCommand(const string& commandIn, const string& path, unsigned int timeo
    command = c;

    while (true) {
-        handleCommand(command, path, timeout, topo, pKey, pVal);
+        try {
+            handleCommand(command, path, timeout, topo, pKey, pVal);
+        } catch(exception& e) {
+            cout << "Error: " << e.what() << endl;
+        }
        cin >> c;
        command = c;
    }
@@ -209,7 +230,7 @@ try {
    DDSSession session(sessionID, env);
    DDSTopology ddsTopo(DDSTopology::Path(topoFile), env);

-    Topology topo(ddsTopo, session);
+    Topology topo(ddsTopo, session, true);

    if (targetState != "") {
        if (command != "") {
--- a/fairmq/shmem/Common.h
+++ b/fairmq/shmem/Common.h
@@ -28,11 +28,7 @@
 #include <unistd.h>
 #include <sys/types.h>

-namespace fair
-{
-namespace mq
-{
-namespace shmem
+namespace fair::mq::shmem
 {

 struct SharedMemoryError : std::runtime_error { using std::runtime_error::runtime_error; };
@@ -267,9 +263,8 @@ struct SegmentAllocateAligned : public boost::static_visitor<void*>

 struct SegmentBufferShrink : public boost::static_visitor<char*>
 {
-    SegmentBufferShrink(const size_t _old_size, const size_t _new_size, char* _local_ptr)
-        : old_size(_old_size)
-        , new_size(_new_size)
+    SegmentBufferShrink(const size_t _new_size, char* _local_ptr)
+        : new_size(_new_size)
        , local_ptr(_local_ptr)
    {}

@@ -277,10 +272,9 @@ struct SegmentBufferShrink : public boost::static_visitor<char*>
    char* operator()(S& s) const
    {
        boost::interprocess::managed_shared_memory::size_type shrunk_size = new_size;
-        return s.template allocation_command<char>(boost::interprocess::shrink_in_place, old_size + 128, shrunk_size, local_ptr);
+        return s.template allocation_command<char>(boost::interprocess::shrink_in_place, new_size + 128, shrunk_size, local_ptr);
    }

-    const size_t old_size;
    const size_t new_size;
    mutable char* local_ptr;
 };
@@ -295,8 +289,6 @@ struct SegmentDeallocate : public boost::static_visitor<>
    void* ptr;
 };

-} // namespace shmem
-} // namespace mq
-} // namespace fair
+} // namespace fair::mq::shmem

 #endif /* FAIR_MQ_SHMEM_COMMON_H_ */
--- a/fairmq/shmem/Manager.h
+++ b/fairmq/shmem/Manager.h
@@ -22,7 +22,6 @@
 #include <FairMQLogger.h>
 #include <FairMQMessage.h>
 #include <fairmq/ProgOptions.h>
-#include <fairmq/tools/CppSTL.h>
 #include <fairmq/tools/Strings.h>

 #include <boost/date_time/posix_time/posix_time.hpp>
@@ -36,6 +35,7 @@

 #include <cstdlib> // getenv
 #include <condition_variable>
+#include <memory> // make_unique
 #include <mutex>
 #include <set>
 #include <sstream>
@@ -48,11 +48,7 @@

 #include <sys/mman.h> // mlock

-namespace fair
-{
-namespace mq
-{
-namespace shmem
+namespace fair::mq::shmem
 {

 class Manager
@@ -143,23 +139,19 @@ class Manager
            } catch(interprocess_exception& bie) {
                LOG(error) << "something went wrong: " << bie.what();
            }
-        }

-        if (mlockSegment) {
-            LOG(debug) << "Locking the managed segment memory pages...";
-            if (mlock(boost::apply_visitor(SegmentAddress{}, fSegments.at(fSegmentId)), boost::apply_visitor(SegmentSize{}, fSegments.at(fSegmentId))) == -1) {
-                LOG(error) << "Could not lock the managed segment memory. Code: " << errno << ", reason: " << strerror(errno);
+            if (mlockSegment) {
+                LOG(debug) << "Locking the managed segment memory pages...";
+                if (mlock(boost::apply_visitor(SegmentAddress{}, fSegments.at(fSegmentId)), boost::apply_visitor(SegmentSize{}, fSegments.at(fSegmentId))) == -1) {
+                    LOG(error) << "Could not lock the managed segment memory. Code: " << errno << ", reason: " << strerror(errno);
+                }
+                LOG(debug) << "Successfully locked the managed segment memory pages.";
+            }
+            if (zeroSegment) {
+                LOG(debug) << "Zeroing the managed segment free memory...";
+                boost::apply_visitor(SegmentMemoryZeroer{}, fSegments.at(fSegmentId));
+                LOG(debug) << "Successfully zeroed the managed segment free memory.";
            }
-            LOG(debug) << "Successfully locked the managed segment memory pages.";
-        }
-        if (zeroSegment) {
-            LOG(debug) << "Zeroing the managed segment free memory...";
-            boost::apply_visitor(SegmentMemoryZeroer{}, fSegments.at(fSegmentId));
-            LOG(debug) << "Successfully zeroed the managed segment free memory.";
-        }
-
-        {
-            boost::interprocess::scoped_lock<boost::interprocess::named_mutex> lock(fShmMtx);

            fShmRegions = fManagementSegment.find_or_construct<Uint16RegionInfoHashMap>(unique_instance)(fShmVoidAlloc);

@@ -278,7 +270,7 @@ class Manager
                // create region info
                fShmRegions->emplace(id, RegionInfo(path.c_str(), flags, userFlags, fShmVoidAlloc));

-                auto r = fRegions.emplace(id, tools::make_unique<Region>(fShmId, id, size, false, callback, bulkCallback, path, flags));
+                auto r = fRegions.emplace(id, std::make_unique<Region>(fShmId, id, size, false, callback, bulkCallback, path, flags));
                // LOG(debug) << "Created region with id '" << id << "', path: '" << path << "', flags: '" << flags << "'";

                r.first->second->StartReceivingAcks();
@@ -316,7 +308,7 @@ class Manager
                int flags = regionInfo.fFlags;
                // LOG(debug) << "Located remote region with id '" << id << "', path: '" << path << "', flags: '" << flags << "'";

-                auto r = fRegions.emplace(id, tools::make_unique<Region>(fShmId, id, 0, true, nullptr, nullptr, path, flags));
+                auto r = fRegions.emplace(id, std::make_unique<Region>(fShmId, id, 0, true, nullptr, nullptr, path, flags));
                return r.first->second.get();
            } catch (std::out_of_range& oor) {
                LOG(error) << "Could not get remote region with id '" << id << "'. Does the region creator run with the same session id?";
@@ -367,13 +359,20 @@ class Manager
        }

        for (const auto& e : *fShmSegments) {
-            fair::mq::RegionInfo info;
-            info.managed = true;
-            info.id = e.first;
-            info.event = RegionEvent::created;
-            info.ptr = boost::apply_visitor(SegmentAddress{}, fSegments.at(e.first));
-            info.size = boost::apply_visitor(SegmentSize{}, fSegments.at(e.first));
-            result.push_back(info);
+            // make sure any segments in the session are found
+            GetSegment(e.first);
+            try {
+                fair::mq::RegionInfo info;
+                info.managed = true;
+                info.id = e.first;
+                info.event = RegionEvent::created;
+                info.ptr = boost::apply_visitor(SegmentAddress{}, fSegments.at(e.first));
+                info.size = boost::apply_visitor(SegmentSize{}, fSegments.at(e.first));
+                result.push_back(info);
+            } catch (const std::out_of_range& oor) {
+                LOG(error) << "could not find segment with id " << e.first;
+                LOG(error) << oor.what();
+            }
        }

        return result;
@@ -474,7 +473,7 @@ class Manager
            try {
                // get region info
                SegmentInfo segmentInfo = fShmSegments->at(id);
-                LOG(info) << "LOCATED SEGMENT WITH ID '" << id << "'";
+                LOG(debug) << "Located segment with id '" << id << "'";

                using namespace boost::interprocess;

@@ -562,9 +561,9 @@ class Manager
 #endif
    }

-    char* ShrinkInPlace(size_t oldSize, size_t newSize, char* localPtr, uint16_t segmentId)
+    char* ShrinkInPlace(size_t newSize, char* localPtr, uint16_t segmentId)
    {
-        return boost::apply_visitor(SegmentBufferShrink{oldSize, newSize, localPtr}, fSegments.at(segmentId));
+        return boost::apply_visitor(SegmentBufferShrink{newSize, localPtr}, fSegments.at(segmentId));
    }

    uint16_t GetSegmentId() const { return fSegmentId; }
@@ -640,8 +639,6 @@ class Manager
    bool fThrowOnBadAlloc;
 };

-} // namespace shmem
-} // namespace mq
-} // namespace fair
+} // namespace fair::mq::shmem

 #endif /* FAIR_MQ_SHMEM_MANAGER_H_ */
--- a/fairmq/shmem/Message.h
+++ b/fairmq/shmem/Message.h
@@ -12,7 +12,6 @@
 #include "Manager.h"
 #include "Region.h"
 #include "UnmanagedRegion.h"
-#include <fairmq/Tools.h>
 #include <FairMQLogger.h>
 #include <FairMQMessage.h>
 #include <FairMQUnmanagedRegion.h>
@@ -25,11 +24,7 @@
 #include <sys/types.h> // getpid
 #include <unistd.h> // pid_t

-namespace fair
-{
-namespace mq
-{
-namespace shmem
+namespace fair::mq::shmem
 {

 class Socket;
@@ -50,11 +45,12 @@ class Message final : public fair::mq::Message
        fManager.IncrementMsgCounter();
    }

-    Message(Manager& manager, Alignment /* alignment */, FairMQTransportFactory* factory = nullptr)
+    Message(Manager& manager, Alignment alignment, FairMQTransportFactory* factory = nullptr)
        : fair::mq::Message(factory)
        , fManager(manager)
        , fQueued(false)
        , fMeta{0, 0, 0, fManager.GetSegmentId(), -1}
+        , fAlignment(alignment.alignment)
        , fRegionPtr(nullptr)
        , fLocalPtr(nullptr)
    {
@@ -78,10 +74,11 @@ class Message final : public fair::mq::Message
        , fManager(manager)
        , fQueued(false)
        , fMeta{0, 0, 0, fManager.GetSegmentId(), -1}
+        , fAlignment(alignment.alignment)
        , fRegionPtr(nullptr)
        , fLocalPtr(nullptr)
    {
-        InitializeChunk(size, static_cast<size_t>(alignment));
+        InitializeChunk(size, fAlignment);
        fManager.IncrementMsgCounter();
    }

@@ -142,6 +139,13 @@ class Message final : public fair::mq::Message
        fQueued = false;
    }

+    void Rebuild(Alignment alignment) override
+    {
+        CloseMessage();
+        fQueued = false;
+        fAlignment = alignment.alignment;
+    }
+
    void Rebuild(const size_t size) override
    {
        CloseMessage();
@@ -149,6 +153,14 @@ class Message final : public fair::mq::Message
        InitializeChunk(size);
    }

+    void Rebuild(const size_t size, Alignment alignment) override
+    {
+        CloseMessage();
+        fQueued = false;
+        fAlignment = alignment.alignment;
+        InitializeChunk(size, fAlignment);
+    }
+
    void Rebuild(void* data, const size_t size, fairmq_free_fn* ffn, void* hint = nullptr) override
    {
        CloseMessage();
@@ -194,9 +206,12 @@ class Message final : public fair::mq::Message
    {
        if (newSize == fMeta.fSize) {
            return true;
+        } else if (newSize == 0) {
+            Deallocate();
+            return true;
        } else if (newSize <= fMeta.fSize) {
            try {
-                fLocalPtr = fManager.ShrinkInPlace(fMeta.fSize, newSize, fLocalPtr, fMeta.fSegmentId);
+                fLocalPtr = fManager.ShrinkInPlace(newSize, fLocalPtr, fMeta.fSegmentId);
                fMeta.fSize = newSize;
                return true;
            } catch (boost::interprocess::interprocess_exception& e) {
@@ -242,6 +257,7 @@ class Message final : public fair::mq::Message
    Manager& fManager;
    bool fQueued;
    MetaHeader fMeta;
+    size_t fAlignment; // TODO: put this to debug mode
    mutable Region* fRegionPtr;
    mutable char* fLocalPtr;

@@ -255,7 +271,7 @@ class Message final : public fair::mq::Message
        return fLocalPtr;
    }

-    void CloseMessage()
+    void Deallocate()
    {
        if (fMeta.fHandle >= 0 && !fQueued) {
            if (fMeta.fRegionId == 0) {
@@ -276,13 +292,17 @@ class Message final : public fair::mq::Message
        }
        fLocalPtr = nullptr;
        fMeta.fSize = 0;
+    }

-        fManager.DecrementMsgCounter();
+    void CloseMessage()
+    {
+        Deallocate();
+        fAlignment = 0;
+
+        fManager.DecrementMsgCounter(); // TODO: put this to debug mode
    }
 };

-}
-}
-}
+} // namespace fair::mq::shmem

 #endif /* FAIR_MQ_SHMEM_MESSAGE_H_ */
--- a/fairmq/shmem/Monitor.cxx
+++ b/fairmq/shmem/Monitor.cxx
@@ -9,7 +9,7 @@
 #include "Monitor.h"
 #include "Common.h"

-#include <fairmq/Tools.h>
+#include <fairmq/tools/Strings.h>
 #include <fairlogger/Logger.h>

 #include <boost/interprocess/managed_shared_memory.hpp>
@@ -42,12 +42,29 @@ namespace
    volatile sig_atomic_t gSignalStatus = 0;
 }

-namespace fair
+namespace fair::mq::shmem
 {
-namespace mq
-{
-namespace shmem
+
+struct TerminalConfig
 {
+    TerminalConfig()
+    {
+        termios t;
+        tcgetattr(STDIN_FILENO, &t); // get the current terminal I/O structure
+        t.c_lflag &= ~ICANON; // disable canonical input
+        t.c_lflag &= ~ECHO; // do not echo input chars
+        tcsetattr(STDIN_FILENO, TCSANOW, &t); // apply the new settings
+    }
+
+    ~TerminalConfig()
+    {
+        termios t;
+        tcgetattr(STDIN_FILENO, &t); // get the current terminal I/O structure
+        t.c_lflag |= ICANON; // re-enable canonical input
+        t.c_lflag |= ECHO; // echo input chars
+        tcsetattr(STDIN_FILENO, TCSANOW, &t); // apply the new settings
+    }
+};

 void signalHandler(int signal)
 {
@@ -119,6 +136,8 @@ void Monitor::Run()

    if (fInteractive) {
        Interactive();
+    } else if (fViewOnly) {
+        CheckSegment();
    } else {
        while (!fTerminating) {
            this_thread::sleep_for(chrono::milliseconds(fIntervalInMS));
@@ -158,27 +177,6 @@ void Monitor::MonitorHeartbeats()
    RemoveQueue(fControlQueueName);
 }

-struct TerminalConfig
-{
-    TerminalConfig()
-    {
-        termios t;
-        tcgetattr(STDIN_FILENO, &t); // get the current terminal I/O structure
-        t.c_lflag &= ~ICANON; // disable canonical input
-        t.c_lflag &= ~ECHO; // do not echo input chars
-        tcsetattr(STDIN_FILENO, TCSANOW, &t); // apply the new settings
-    }
-
-    ~TerminalConfig()
-    {
-        termios t;
-        tcgetattr(STDIN_FILENO, &t); // get the current terminal I/O structure
-        t.c_lflag |= ICANON; // re-enable canonical input
-        t.c_lflag |= ECHO; // echo input chars
-        tcsetattr(STDIN_FILENO, TCSANOW, &t); // apply the new settings
-    }
-};
-
 void Monitor::Interactive()
 {
    char c;
@@ -575,6 +573,4 @@ Monitor::~Monitor()
    }
 }

-} // namespace shmem
-} // namespace mq
-} // namespace fair
+} // namespace fair::mq::shmem
--- a/fairmq/shmem/Monitor.h
+++ b/fairmq/shmem/Monitor.h
@@ -17,11 +17,7 @@
 #include <utility> // pair
 #include <vector>

-namespace fair
-{
-namespace mq
-{
-namespace shmem
+namespace fair::mq::shmem
 {

 struct SessionId
@@ -120,8 +116,6 @@ class Monitor
    std::unordered_map<std::string, std::chrono::high_resolution_clock::time_point> fDeviceHeartbeats;
 };

-} // namespace shmem
-} // namespace mq
-} // namespace fair
+} // namespace fair::mq::shmem

 #endif /* FAIR_MQ_SHMEM_MONITOR_H_ */
--- a/fairmq/shmem/Poller.h
+++ b/fairmq/shmem/Poller.h
@@ -9,7 +9,7 @@
 #define FAIR_MQ_SHMEM_POLLER_H_

 #include "Socket.h"
-#include <fairmq/Tools.h>
+#include <fairmq/tools/Strings.h>
 #include <FairMQChannel.h>
 #include <FairMQLogger.h>
 #include <FairMQPoller.h>
@@ -21,9 +21,8 @@

 class FairMQChannel;

-namespace fair {
-namespace mq {
-namespace shmem {
+namespace fair::mq::shmem
+{

 class Poller final : public fair::mq::Poller
 {
@@ -201,8 +200,6 @@ class Poller final : public fair::mq::Poller
    std::unordered_map<std::string, int> fOffsetMap;
 };

-}   // namespace shmem
-}   // namespace mq
-}   // namespace fair
+} // namespace fair::mq::shmem

 #endif /* FAIR_MQ_SHMEM_POLLER_H_ */
--- a/fairmq/shmem/Region.h
+++ b/fairmq/shmem/Region.h
@@ -19,7 +19,6 @@

 #include <FairMQLogger.h>
 #include <FairMQUnmanagedRegion.h>
-#include <fairmq/tools/CppSTL.h>
 #include <fairmq/tools/Strings.h>

 #include <boost/filesystem.hpp>
@@ -32,6 +31,7 @@
 #include <algorithm> // min
 #include <atomic>
 #include <thread>
+#include <memory> // make_unique
 #include <mutex>
 #include <condition_variable>
 #include <unordered_map>
@@ -39,11 +39,7 @@
 #include <chrono>
 #include <ios>

-namespace fair
-{
-namespace mq
-{
-namespace shmem
+namespace fair::mq::shmem
 {

 struct Region
@@ -113,9 +109,9 @@ struct Region
        using namespace boost::interprocess;

        if (fRemote) {
-            fQueue = tools::make_unique<message_queue>(open_only, fQueueName.c_str());
+            fQueue = std::make_unique<message_queue>(open_only, fQueueName.c_str());
        } else {
-            fQueue = tools::make_unique<message_queue>(create_only, fQueueName.c_str(), 1024, fAckBunchSize * sizeof(RegionBlock));
+            fQueue = std::make_unique<message_queue>(create_only, fQueueName.c_str(), 1024, fAckBunchSize * sizeof(RegionBlock));
        }
        LOG(debug) << "shmem: initialized region queue: " << fQueueName;
    }
@@ -123,7 +119,7 @@ struct Region
    void StartSendingAcks() { fAcksSender = std::thread(&Region::SendAcks, this); }
    void SendAcks()
    {
-        std::unique_ptr<RegionBlock[]> blocks = tools::make_unique<RegionBlock[]>(fAckBunchSize);
+        std::unique_ptr<RegionBlock[]> blocks = std::make_unique<RegionBlock[]>(fAckBunchSize);
        size_t blocksToSend = 0;

        while (true) {
@@ -165,7 +161,7 @@ struct Region
    {
        unsigned int priority;
        boost::interprocess::message_queue::size_type recvdSize;
-        std::unique_ptr<RegionBlock[]> blocks = tools::make_unique<RegionBlock[]>(fAckBunchSize);
+        std::unique_ptr<RegionBlock[]> blocks = std::make_unique<RegionBlock[]>(fAckBunchSize);
        std::vector<fair::mq::RegionBlock> result;
        result.reserve(fAckBunchSize);

@@ -276,8 +272,6 @@ struct Region
    RegionBulkCallback fBulkCallback;
 };

-} // namespace shmem
-} // namespace mq
-} // namespace fair
+} // namespace fair::mq::shmem

 #endif /* FAIR_MQ_SHMEM_REGION_H_ */
--- a/fairmq/shmem/Socket.h
+++ b/fairmq/shmem/Socket.h
@@ -15,19 +15,16 @@
 #include <FairMQSocket.h>
 #include <FairMQMessage.h>
 #include <FairMQLogger.h>
-#include <fairmq/Tools.h>
+#include <fairmq/tools/Strings.h>

 #include <zmq.h>

 #include <atomic>
+#include <memory> // make_unique

 class FairMQTransportFactory;

-namespace fair
-{
-namespace mq
-{
-namespace shmem
+namespace fair::mq::shmem
 {

 struct ZMsg
@@ -58,6 +55,12 @@ class Socket final : public fair::mq::Socket
        , fTimeout(100)
    {
        assert(context);
+
+        if (type == "sub" || type == "pub") {
+            LOG(error) << "PUB/SUB socket type is not supported for shared memory transport";
+            throw SocketError("PUB/SUB socket type is not supported for shared memory transport");
+        }
+
        fSocket = zmq_socket(context, GetConstant(type));

        if (fSocket == nullptr) {
@@ -91,11 +94,6 @@ class Socket final : public fair::mq::Socket
        //         LOG(error) << "Failed setting ZMQ_SUBSCRIBE socket option, reason: " << zmq_strerror(errno);
        //     }
        // }
-
-        if (type == "sub" || type == "pub") {
-            LOG(error) << "PUB/SUB socket type is not supported for shared memory transport";
-            throw SocketError("PUB/SUB socket type is not supported for shared memory transport");
-        }
        LOG(debug) << "Created socket " << GetId();
    }

@@ -147,14 +145,14 @@ class Socket final : public fair::mq::Socket
    {
        if (zmq_errno() == ETERM) {
            LOG(debug) << "Terminating socket " << fId;
-            return static_cast<int>(TransferResult::error);
+            return static_cast<int>(TransferCode::error);
        } else {
            LOG(error) << "Failed transfer on socket " << fId << ", reason: " << zmq_strerror(errno);
-            return static_cast<int>(TransferResult::error);
+            return static_cast<int>(TransferCode::error);
        }
    }

-    int Send(MessagePtr& msg, const int timeout = -1) override
+    int64_t Send(MessagePtr& msg, const int timeout = -1) override
    {
        int flags = 0;
        if (timeout == 0) {
@@ -176,21 +174,21 @@ class Socket final : public fair::mq::Socket
                return size;
            } else if (zmq_errno() == EAGAIN || zmq_errno() == EINTR) {
                if (fManager.Interrupted()) {
-                    return static_cast<int>(TransferResult::interrupted);
+                    return static_cast<int>(TransferCode::interrupted);
                } else if (ShouldRetry(flags, timeout, elapsed)) {
                    continue;
                } else {
-                    return static_cast<int>(TransferResult::timeout);
+                    return static_cast<int>(TransferCode::timeout);
                }
            } else {
                return HandleErrors();
            }
        }

-        return static_cast<int>(TransferResult::error);
+        return static_cast<int>(TransferCode::error);
    }

-    int Receive(MessagePtr& msg, const int timeout = -1) override
+    int64_t Receive(MessagePtr& msg, const int timeout = -1) override
    {
        int flags = 0;
        if (timeout == 0) {
@@ -221,11 +219,11 @@ class Socket final : public fair::mq::Socket
                return size;
            } else if (zmq_errno() == EAGAIN || zmq_errno() == EINTR) {
                if (fManager.Interrupted()) {
-                    return static_cast<int>(TransferResult::interrupted);
+                    return static_cast<int>(TransferCode::interrupted);
                } else if (ShouldRetry(flags, timeout, elapsed)) {
                    continue;
                } else {
-                    return static_cast<int>(TransferResult::timeout);
+                    return static_cast<int>(TransferCode::timeout);
                }
            } else {
                return HandleErrors();
@@ -272,18 +270,18 @@ class Socket final : public fair::mq::Socket
                return totalSize;
            } else if (zmq_errno() == EAGAIN || zmq_errno() == EINTR) {
                if (fManager.Interrupted()) {
-                    return static_cast<int>(TransferResult::interrupted);
+                    return static_cast<int>(TransferCode::interrupted);
                } else if (ShouldRetry(flags, timeout, elapsed)) {
                    continue;
                } else {
-                    return static_cast<int>(TransferResult::timeout);
+                    return static_cast<int>(TransferCode::timeout);
                }
            } else {
                return HandleErrors();
            }
        }

-        return static_cast<int>(TransferResult::error);
+        return static_cast<int>(TransferCode::error);
    }

    int64_t Receive(std::vector<MessagePtr>& msgVec, const int timeout = -1) override
@@ -316,7 +314,7 @@ class Socket final : public fair::mq::Socket

                for (size_t m = 0; m < numMessages; m++) {
                    // create new message (part)
-                    msgVec.emplace_back(tools::make_unique<Message>(fManager, hdrVec[m], GetTransport()));
+                    msgVec.emplace_back(std::make_unique<Message>(fManager, hdrVec[m], GetTransport()));
                    Message* shmMsg = static_cast<Message*>(msgVec.back().get());
                    totalSize += shmMsg->GetSize();
                }
@@ -328,18 +326,18 @@ class Socket final : public fair::mq::Socket
                return totalSize;
            } else if (zmq_errno() == EAGAIN || zmq_errno() == EINTR) {
                if (fManager.Interrupted()) {
-                    return static_cast<int>(TransferResult::interrupted);
+                    return static_cast<int>(TransferCode::interrupted);
                } else if (ShouldRetry(flags, timeout, elapsed)) {
                    continue;
                } else {
-                    return static_cast<int>(TransferResult::timeout);
+                    return static_cast<int>(TransferCode::timeout);
                }
            } else {
                return HandleErrors();
            }
        }

-        return static_cast<int>(TransferResult::error);
+        return static_cast<int>(TransferCode::error);
    }

    void* GetSocket() const { return fSocket; }
@@ -384,8 +382,7 @@ class Socket final : public fair::mq::Socket
    {
        size_t eventsSize = sizeof(uint32_t);
        if (zmq_getsockopt(fSocket, ZMQ_EVENTS, events, &eventsSize) < 0) {
-            throw SocketError(
-                tools::ToString("failed setting ZMQ_EVENTS, reason: ", zmq_strerror(errno)));
+            throw SocketError(tools::ToString("failed setting ZMQ_EVENTS, reason: ", zmq_strerror(errno)));
        }
    }

@@ -523,8 +520,6 @@ class Socket final : public fair::mq::Socket
    int fTimeout;
 };

-}
-}
-}
+} // namespace fair::mq::shmem

 #endif /* FAIR_MQ_SHMEM_SOCKET_H_ */
--- a/fairmq/shmem/TransportFactory.h
+++ b/fairmq/shmem/TransportFactory.h
@@ -19,21 +19,17 @@
 #include <FairMQTransportFactory.h>
 #include <fairmq/ProgOptions.h>
 #include <FairMQLogger.h>
-#include <fairmq/Tools.h>
+#include <fairmq/tools/Strings.h>

 #include <boost/version.hpp>

 #include <zmq.h>

-#include <memory> // unique_ptr
+#include <memory> // unique_ptr, make_unique
 #include <string>
 #include <vector>

-namespace fair
-{
-namespace mq
-{
-namespace shmem
+namespace fair::mq::shmem
 {

 class TransportFactory final : public fair::mq::TransportFactory
@@ -86,7 +82,7 @@ class TransportFactory final : public fair::mq::TransportFactory
                LOG(error) << "failed configuring context, reason: " << zmq_strerror(errno);
            }

-            fManager = tools::make_unique<Manager>(fShmId, fDeviceId, segmentSize, config);
+            fManager = std::make_unique<Manager>(fShmId, fDeviceId, segmentSize, config);
        } catch (boost::interprocess::interprocess_exception& e) {
            LOG(error) << "Could not initialize shared memory transport: " << e.what();
            throw std::runtime_error(tools::ToString("Could not initialize shared memory transport: ", e.what()));
@@ -98,52 +94,52 @@ class TransportFactory final : public fair::mq::TransportFactory

    MessagePtr CreateMessage() override
    {
-        return tools::make_unique<Message>(*fManager, this);
+        return std::make_unique<Message>(*fManager, this);
    }

    MessagePtr CreateMessage(Alignment alignment) override
    {
-        return tools::make_unique<Message>(*fManager, alignment, this);
+        return std::make_unique<Message>(*fManager, alignment, this);
    }

    MessagePtr CreateMessage(const size_t size) override
    {
-        return tools::make_unique<Message>(*fManager, size, this);
+        return std::make_unique<Message>(*fManager, size, this);
    }

    MessagePtr CreateMessage(const size_t size, Alignment alignment) override
    {
-        return tools::make_unique<Message>(*fManager, size, alignment, this);
+        return std::make_unique<Message>(*fManager, size, alignment, this);
    }

    MessagePtr CreateMessage(void* data, const size_t size, fairmq_free_fn* ffn, void* hint = nullptr) override
    {
-        return tools::make_unique<Message>(*fManager, data, size, ffn, hint, this);
+        return std::make_unique<Message>(*fManager, data, size, ffn, hint, this);
    }

    MessagePtr CreateMessage(UnmanagedRegionPtr& region, void* data, const size_t size, void* hint = 0) override
    {
-        return tools::make_unique<Message>(*fManager, region, data, size, hint, this);
+        return std::make_unique<Message>(*fManager, region, data, size, hint, this);
    }

    SocketPtr CreateSocket(const std::string& type, const std::string& name) override
    {
-        return tools::make_unique<Socket>(*fManager, type, name, GetId(), fZmqCtx, this);
+        return std::make_unique<Socket>(*fManager, type, name, GetId(), fZmqCtx, this);
    }

    PollerPtr CreatePoller(const std::vector<FairMQChannel>& channels) const override
    {
-        return tools::make_unique<Poller>(channels);
+        return std::make_unique<Poller>(channels);
    }

    PollerPtr CreatePoller(const std::vector<FairMQChannel*>& channels) const override
    {
-        return tools::make_unique<Poller>(channels);
+        return std::make_unique<Poller>(channels);
    }

    PollerPtr CreatePoller(const std::unordered_map<std::string, std::vector<FairMQChannel>>& channelsMap, const std::vector<std::string>& channelList) const override
    {
-        return tools::make_unique<Poller>(channelsMap, channelList);
+        return std::make_unique<Poller>(channelsMap, channelList);
    }

    UnmanagedRegionPtr CreateUnmanagedRegion(const size_t size, RegionCallback callback = nullptr, const std::string& path = "", int flags = 0) override
@@ -168,7 +164,7 @@ class TransportFactory final : public fair::mq::TransportFactory

    UnmanagedRegionPtr CreateUnmanagedRegion(const size_t size, int64_t userFlags, RegionCallback callback, RegionBulkCallback bulkCallback, const std::string& path, int flags)
    {
-        return tools::make_unique<UnmanagedRegion>(*fManager, size, userFlags, callback, bulkCallback, path, flags, this);
+        return std::make_unique<UnmanagedRegion>(*fManager, size, userFlags, callback, bulkCallback, path, flags, this);
    }

    void SubscribeToRegionEvents(RegionEventCallback callback) override { fManager->SubscribeToRegionEvents(callback); }
@@ -210,8 +206,6 @@ class TransportFactory final : public fair::mq::TransportFactory
    std::unique_ptr<Manager> fManager;
 };

-} // namespace shmem
-} // namespace mq
-} // namespace fair
+} // namespace fair::mq::shmem

 #endif /* FAIR_MQ_SHMEM_TRANSPORTFACTORY_H_ */
--- a/fairmq/shmem/UnmanagedRegion.h
+++ b/fairmq/shmem/UnmanagedRegion.h
@@ -20,11 +20,7 @@
 #include <cstddef> // size_t
 #include <string>

-namespace fair
-{
-namespace mq
-{
-namespace shmem
+namespace fair::mq::shmem
 {

 class Message;
@@ -68,8 +64,6 @@ class UnmanagedRegion final : public fair::mq::UnmanagedRegion
    uint16_t fRegionId;
 };

-}
-}
-}
+} // namespace fair::mq::shmem

 #endif /* FAIR_MQ_SHMEM_UNMANAGEDREGION_H_ */
--- a/fairmq/shmem/runMonitor.cxx
+++ b/fairmq/shmem/runMonitor.cxx
@@ -125,13 +125,12 @@ int main(int argc, char** argv)
        }

        cout << "Starting shared memory monitor for session: \"" << sessionName << "\" (shmId: " << shmId << ")..." << endl;
-        if (viewOnly && !interactive) {
-            cout << "running in non-interactive view-only mode, outputting with interval of " << intervalInMS << "ms. (change with --interval), press ctrl+C to exit." << endl;
-        }

        Monitor monitor(shmId, selfDestruct, interactive, viewOnly, timeoutInMS, intervalInMS, runAsDaemon, cleanOnExit);

-        monitor.CatchSignals();
+        if (interactive || !viewOnly) {
+            monitor.CatchSignals();
+        }
        monitor.Run();
    } catch (Monitor::DaemonPresent& dp) {
        return 0;
--- a/fairmq/tools/CppSTL.h
+++ b/fairmq/tools/CppSTL.h
@@ -9,45 +9,11 @@
 #ifndef FAIR_MQ_TOOLS_CPPSTL_H
 #define FAIR_MQ_TOOLS_CPPSTL_H

-#include <functional>
-#include <memory>
-#include <type_traits>
-
-namespace fair
-{
-namespace mq
-{
-namespace tools
+namespace fair::mq::tools
 {

-// make_unique implementation, until C++14 is default
-template<typename T, typename ...Args>
-std::unique_ptr<T> make_unique(Args&& ...args)
-{
-    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
-}

-// make_unique implementation (array variant), until C++14 is default
-template<typename T>
-std::unique_ptr<T> make_unique(std::size_t size)
-{
-    return std::unique_ptr<T>(new typename std::remove_extent<T>::type[size]());
-}

-// provide an enum hasher to compensate std::hash not supporting enums in C++11
-template<typename Enum>
-struct HashEnum
-{
-    auto operator()(const Enum& e) const noexcept
-    -> typename std::enable_if<std::is_enum<Enum>::value, std::size_t>::type
-    {
-        using _type = typename std::underlying_type<Enum>::type;
-        return std::hash<_type>{}(static_cast<_type>(e));
-    }
-};
-
-} /* namespace tools */
-} /* namespace mq */
-} /* namespace fair */
+} // namespace fair::mq::tools

 #endif /* FAIR_MQ_TOOLS_CPPSTL_H */
--- a/fairmq/tools/InstanceLimit.h
+++ b/fairmq/tools/InstanceLimit.h
@@ -11,9 +11,8 @@

 #include "Strings.h"

-namespace fair {
-namespace mq {
-namespace tools {
+namespace fair::mq::tools
+{

 template<typename Tag, int Max>
 struct InstanceLimiter
@@ -50,8 +49,6 @@ struct InstanceLimiter
 template<typename Tag, int Max>
 int InstanceLimiter<Tag, Max>::fCount(0);

-} /* namespace tools */
-} /* namespace mq */
-} /* namespace fair */
+} // namespace fair::mq::tools

 #endif /* FAIR_MQ_TOOLS_INSTANCELIMIT_H */
--- a/fairmq/tools/Network.cxx
+++ b/fairmq/tools/Network.cxx
@@ -33,11 +33,7 @@

 using namespace std;

-namespace fair
-{
-namespace mq
-{
-namespace tools
+namespace fair::mq::tools
 {

 // returns a map with network interface names as keys and their IP addresses as values
@@ -184,6 +180,4 @@ string getIpFromHostname(const string& hostname, boost::asio::io_service& ios)
    }
 }

-} /* namespace tools */
-} /* namespace mq */
-} /* namespace fair */
+} // namespace fair::mq::tools
--- a/fairmq/tools/Network.h
+++ b/fairmq/tools/Network.h
@@ -25,11 +25,7 @@ using io_service = class io_context;
 } // namespace asio
 } // namespace boost

-namespace fair
-{
-namespace mq
-{
-namespace tools
+namespace fair::mq::tools
 {

 struct DefaultRouteDetectionError : std::runtime_error { using std::runtime_error::runtime_error; };
@@ -47,8 +43,6 @@ std::string getIpFromHostname(const std::string& hostname);

 std::string getIpFromHostname(const std::string& hostname, boost::asio::io_service& ios);

-} /* namespace tools */
-} /* namespace mq */
-} /* namespace fair */
+} // namespace fair::mq::tools

 #endif /* FAIR_MQ_TOOLS_NETWORK_H */
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Alexey Rybalchenko	bbc1dd4600	Add optional file output to FairMQSink	2021-03-01 15:33:45 +01:00
Dennis Klein	8327810942	Warn on unknown --channel-config args	2021-03-01 08:37:57 +01:00
Dennis Klein	c37742e3b4	Update Copyright string	2021-03-01 08:37:57 +01:00
Alexey Rybalchenko	93dff3c5a7	Fix regression in shmmonitor	2021-02-19 09:54:29 +01:00
Alexey Rybalchenko	2b3e38d9a4	shmmonitor: non-interactive mode checks and quits	2021-02-10 10:36:08 +01:00
Alexey Rybalchenko	c6b13cd3a1	Fix shmem::Message::SetUsedSize(0)	2021-01-25 13:46:40 +01:00
Alexey Rybalchenko	c5487a11ed	Remove custom implementation for enum hashing	2021-01-25 13:46:40 +01:00
Alexey Rybalchenko	4a09154a91	17-ify namespaces	2021-01-25 13:46:40 +01:00
Alexey Rybalchenko	d9a5e82160	Cleanup tools includes	2021-01-25 13:46:40 +01:00
Alexey Rybalchenko	751c53171c	Replace tools::make_unique with std::make_unique	2021-01-25 13:46:40 +01:00
Alexey Rybalchenko	6815c9c172	zmq: implement alignment	2021-01-13 12:36:32 +01:00
Alexey Rybalchenko	02a3980343	Remove useless parameter from implementation	2021-01-13 12:36:32 +01:00
Alexey Rybalchenko	38b34785e0	format & remove unused variable	2021-01-13 12:36:32 +01:00
Alexey Rybalchenko	be94ceb7a7	zmq: simplify SetUsedSize implementation	2021-01-13 12:36:32 +01:00
Alexey Rybalchenko	afadbb53e4	zmq: correct accounting for msg size > 2GB	2021-01-13 12:36:32 +01:00
Alexey Rybalchenko	749d28a3b5	DeviceRunner: check FAIRMQ_SEVERITY env var for severity	2021-01-13 12:36:32 +01:00
Alexey Rybalchenko	29f45fa77d	Rename TransferResult to TransferCode	2021-01-13 12:36:32 +01:00
Alexey Rybalchenko	ea746b17d0	Remove deprecated methods	2021-01-13 12:36:32 +01:00
Alexey Rybalchenko	636846fcdb	Bump C++ standard requirement to C++17	2021-01-13 12:36:32 +01:00
Alexey Rybalchenko	f46d446d52	shm: do mlock/zeroing under shmem lock	2020-12-04 13:27:45 +01:00
Alexey Rybalchenko	db0937f339	shm: ensure local segments are complete for region subscriptions	2020-11-25 13:41:23 +01:00
Alexey Rybalchenko	bb1ce794b6	Let single message methods also return int64_t	2020-11-17 14:04:20 +01:00
Dennis Klein	9e2373b55d	extern/asio: Bump to 1.18.0	2020-11-13 15:55:52 +01:00
Dennis Klein	c51e88e114	CI: Do not run unstable tests on macOS 10.14 hosts	2020-11-13 02:58:09 +01:00
Dennis Klein	f9219dab65	CI: Remove old options	2020-11-13 02:58:09 +01:00
Alexey Rybalchenko	0806720f61	Bump DDS version to 3.5.3 (multiple sessions support)	2020-11-13 02:58:09 +01:00
Alexey Rybalchenko	e39d17d09e	Apply suggestions from -Wrange-loop-analysis	2020-11-13 02:58:09 +01:00
Alexey Rybalchenko	a14502242f	DDS command UI: return EXIT_FAILURE on errors	2020-11-13 02:58:09 +01:00
Alexey Rybalchenko	d3697ec97b	SDK: add WaitForPublisherCount() and related ctor arg	2020-11-13 02:58:09 +01:00
Dennis Klein	73377c5100	CI: Update macOS builds	2020-11-05 15:12:02 +01:00
Alexey Rybalchenko	49d8a1b4dd	DeviceRunner: Set log severity only if one was provided	2020-10-19 10:23:08 +02:00
Alexey Rybalchenko	f14f507584	SDK: Remove instance limit from DDSSession	2020-10-09 13:35:55 +02:00
Alexey Rybalchenko	8dd0b25c06	Make BasicTopology actually movable	2020-10-09 13:35:55 +02:00
Christian Tacke	7edf436919	Improve PMIx Package Finding on Debian Debian's libpmix-dev package installs everything below /usr/lib/ARCH-TRIPLET/pmix2. For some reasoning behind this, see: https://bugs.debian.org/882033 CMake does not search there by default, so help it. Also add myself to CONTRIBUTORS.	2020-10-08 17:27:12 +02:00
Alexey Rybalchenko	0e5978b160	Properties: add output support for shorts	2020-10-06 16:17:37 +02:00
Alexey Rybalchenko	71b1866d7b	small includes cleanup	2020-10-06 16:17:37 +02:00
Alexey Rybalchenko	6699711e17	FairMQChannel: Refactor, moving short methods to header	2020-10-06 16:17:37 +02:00
Alexey Rybalchenko	120760da0a	FairMQChannel: avoid copy when iterating over endpoints	2020-10-06 16:17:37 +02:00
Alexey Rybalchenko	d03a504ccd	shmem: fail earlier if given an unsupported socket type	2020-10-06 16:17:37 +02:00
Alexey Rybalchenko	cf004f69b2	FairMQChannel: replace ResetChannel() with Invalidate()	2020-10-06 16:17:37 +02:00
Alexey Rybalchenko	cfa18ccfce	FairMQChannel: remove artifacts from no longer used optimizations	2020-10-06 16:17:37 +02:00
Alexey Rybalchenko	e332e20dbd	Remove thread-safety from channel methods	2020-10-06 16:17:37 +02:00
Alexey Rybalchenko	3ab10ced7a	FairMQChannel: remove deprecated methods	2020-10-06 16:17:37 +02:00