Merge pull request #7137 from vespa-engine/balder/use-smart-pointers-in-slobrok

Balder/use smart pointers in slobrok

27 files changed, 502 insertions, 686 deletions

diff --git a/slobrok/src/apps/check_slobrok/check_slobrok.cpp b/slobrok/src/apps/check_slobrok/check_slobrok.cpp
index 744a64b89cd..ed72c459e44 100644
--- a/slobrok/src/apps/check_slobrok/check_slobrok.cpp
+++ b/slobrok/src/apps/check_slobrok/check_slobrok.cpp
@@ -13,14 +13,14 @@ LOG_SETUP("check_slobrok");
 class Slobrok_Checker : public FastOS_Application
 {
 private:
-    FRT_Supervisor *_supervisor;
-    FRT_Target     *_target;
+    std::unique_ptr<FRT_Supervisor>  _supervisor;
+    FRT_Target                      *_target;
 
     Slobrok_Checker(const Slobrok_Checker &);
     Slobrok_Checker &operator=(const Slobrok_Checker &);
 
 public:
-    Slobrok_Checker() : _supervisor(NULL), _target(NULL) {}
+    Slobrok_Checker() : _supervisor(), _target(nullptr) {}
     virtual ~Slobrok_Checker();
     int usage();
     void initRPC(const char *spec);
@@ -30,8 +30,8 @@ public:
 
 Slobrok_Checker::~Slobrok_Checker()
 {
-    LOG_ASSERT(_supervisor == NULL);
-    LOG_ASSERT(_target == NULL);
+    LOG_ASSERT( !_supervisor);
+    LOG_ASSERT(_target == nullptr);
 }
 
 
@@ -46,7 +46,7 @@ Slobrok_Checker::usage()
 void
 Slobrok_Checker::initRPC(const char *spec)
 {
-    _supervisor = new FRT_Supervisor();
+    _supervisor = std::make_unique<FRT_Supervisor>();
     _target     = _supervisor->GetTarget(spec);
     _supervisor->Start();
 }
@@ -55,14 +55,13 @@ Slobrok_Checker::initRPC(const char *spec)
 void
 Slobrok_Checker::finiRPC()
 {
-    if (_target != NULL) {
+    if (_target != nullptr) {
         _target->SubRef();
-        _target = NULL;
+        _target = nullptr;
     }
-    if (_supervisor != NULL) {
+    if (_supervisor) {
         _supervisor->ShutDown(true);
-        delete _supervisor;
-        _supervisor = NULL;
+        _supervisor.reset();
     }
 }
 
diff --git a/slobrok/src/apps/sbcmd/sbcmd.cpp b/slobrok/src/apps/sbcmd/sbcmd.cpp
index 30aaa6a1406..c4b76bd7ed0 100644
--- a/slobrok/src/apps/sbcmd/sbcmd.cpp
+++ b/slobrok/src/apps/sbcmd/sbcmd.cpp
@@ -12,14 +12,14 @@ LOG_SETUP("vespa-slobrok-cmd");
 class Slobrok_CMD : public FastOS_Application
 {
 private:
-    FRT_Supervisor *_supervisor;
+    std::unique_ptr<FRT_Supervisor> _supervisor;
     FRT_Target     *_target;
 
     Slobrok_CMD(const Slobrok_CMD &);
     Slobrok_CMD &operator=(const Slobrok_CMD &);
 
 public:
-    Slobrok_CMD() : _supervisor(NULL), _target(NULL) {}
+    Slobrok_CMD() : _supervisor(), _target(nullptr) {}
     virtual ~Slobrok_CMD();
     int usage();
     void initRPC(const char *spec);
@@ -29,8 +29,8 @@ public:
 
 Slobrok_CMD::~Slobrok_CMD()
 {
-    LOG_ASSERT(_supervisor == NULL);
-    LOG_ASSERT(_target == NULL);
+    LOG_ASSERT(! _supervisor);
+    LOG_ASSERT(_target == nullptr);
 }
 
 int
@@ -56,7 +56,7 @@ Slobrok_CMD::usage()
 void
 Slobrok_CMD::initRPC(const char *spec)
 {
-    _supervisor = new FRT_Supervisor();
+    _supervisor = std::make_unique<FRT_Supervisor>();
     _target     = _supervisor->GetTarget(spec);
     _supervisor->Start();
 }
@@ -65,14 +65,13 @@ Slobrok_CMD::initRPC(const char *spec)
 void
 Slobrok_CMD::finiRPC()
 {
-    if (_target != NULL) {
+    if (_target != nullptr) {
         _target->SubRef();
-        _target = NULL;
+        _target = nullptr;
     }
-    if (_supervisor != NULL) {
+    if (_supervisor) {
         _supervisor->ShutDown(true);
-        delete _supervisor;
-        _supervisor = NULL;
+        _supervisor.reset();
     }
 }
 
@@ -165,7 +164,7 @@ Slobrok_CMD::Main()
         } else {
             fprintf(stderr, "vespa-slobrok-cmd OK, returntypes '%s'\n", atypes);
             uint32_t idx = 0;
-            while (atypes != NULL && *atypes != '\0') {
+            while (atypes != nullptr && *atypes != '\0') {
                 switch (*atypes) {
                 case 's':
                     printf("    string = '%s'\n", answer[idx]._string._str);
diff --git a/slobrok/src/vespa/slobrok/server/cmd.cpp b/slobrok/src/vespa/slobrok/server/cmd.cpp
index 6ba4f9a6e98..e728c8f80ad 100644
--- a/slobrok/src/vespa/slobrok/server/cmd.cpp
+++ b/slobrok/src/vespa/slobrok/server/cmd.cpp
@@ -30,27 +30,33 @@ public:
     const std::string      spec;
     FRT_RPCRequest * const registerRequest;
 
-    RegRpcSrvData(SBEnv &e, const char *n, const char *s, FRT_RPCRequest *r)
+    RegRpcSrvData(SBEnv &e, const std::string &n, const std::string &s, FRT_RPCRequest *r)
         : _state(RDC_INIT), env(e), name(n), spec(s), registerRequest(r)
     {}
 };
 
+RegRpcSrvCommand::RegRpcSrvCommand(std::unique_ptr<RegRpcSrvData> data)
+    : _data(std::move(data))
+{}
+
+RegRpcSrvCommand::RegRpcSrvCommand(RegRpcSrvCommand &&) = default;
+RegRpcSrvCommand & RegRpcSrvCommand::operator =(RegRpcSrvCommand &&) = default;
+RegRpcSrvCommand::~RegRpcSrvCommand() = default;
+
 RegRpcSrvCommand
 RegRpcSrvCommand::makeRegRpcSrvCmd(SBEnv &env,
-                                   const char *name, const char *spec,
+                                   const std::string &name, const std::string &spec,
                                    FRT_RPCRequest *req)
 {
-    RegRpcSrvData *data = new RegRpcSrvData(env, name, spec, req);
-    return RegRpcSrvCommand(data);
+    return RegRpcSrvCommand(std::make_unique<RegRpcSrvData>(env, name, spec, req));
 }
 
 RegRpcSrvCommand
-RegRpcSrvCommand::makeRemRemCmd(SBEnv &env,
-                                const char *name, const char *spec)
+RegRpcSrvCommand::makeRemRemCmd(SBEnv &env, const std::string & name, const std::string &spec)
 {
-    RegRpcSrvData *data = new RegRpcSrvData(env, name, spec, NULL);
+    auto data = std::make_unique<RegRpcSrvData>(env, name, spec, nullptr);
     data->_state = RegRpcSrvData::XCH_IGNORE;
-    return RegRpcSrvCommand(data);
+    return RegRpcSrvCommand(std::move(data));
 }
 
 
@@ -62,66 +68,61 @@ RegRpcSrvCommand::doRequest()
 }
 
 void
-RegRpcSrvCommand::cleanupReservation()
+RegRpcSrvCommand::cleanupReservation(RegRpcSrvData & data)
 {
-    RpcServerMap &map = _data->env._rpcsrvmap;
-    ReservedName *rsvp = map.getReservation(_data->name.c_str());
-    if (rsvp != NULL && rsvp->isLocal) {
-        map.removeReservation(_data->name.c_str());
+    RpcServerMap &map = data.env._rpcsrvmap;
+    const ReservedName *rsvp = map.getReservation(data.name.c_str());
+    if (rsvp != nullptr && rsvp->isLocal) {
+        map.removeReservation(data.name.c_str());
     }
 }
 
 void
 RegRpcSrvCommand::doneHandler(OkState result)
 {
-    LOG_ASSERT(_data != NULL);
-
+    LOG_ASSERT(_data != nullptr);
+    std::unique_ptr<RegRpcSrvData> dataUP = std::move(_data);
+    RegRpcSrvData & data = *dataUP;
     if (result.failed()) {
-        LOG(warning, "failed in state %d: %s",
-            _data->_state, result.errorMsg.c_str());
-        cleanupReservation();
+        LOG(warning, "failed in state %d: %s", data._state, result.errorMsg.c_str());
+        cleanupReservation(data);
         // XXX should handle different state errors differently?
-        if (_data->registerRequest != NULL) {
-            _data->registerRequest->SetError(FRTE_RPC_METHOD_FAILED,
-                                             result.errorMsg.c_str());
-            _data->registerRequest->Return();
+        if (data.registerRequest != nullptr) {
+            data.registerRequest->SetError(FRTE_RPC_METHOD_FAILED, result.errorMsg.c_str());
+            data.registerRequest->Return();
         } else {
             LOG(warning, "ignored: %s", result.errorMsg.c_str());
         }
         goto alldone;
     }
-    if (_data->_state == RegRpcSrvData::RDC_INIT) {
-        LOG(spam, "phase wantAdd(%s,%s)",
-            _data->name.c_str(), _data->spec.c_str());
-        _data->_state = RegRpcSrvData::XCH_WANTADD;
-        _data->env._exchanger.wantAdd(_data->name.c_str(), _data->spec.c_str(), *this);
+    if (data._state == RegRpcSrvData::RDC_INIT) {
+        LOG(spam, "phase wantAdd(%s,%s)", data.name.c_str(), data.spec.c_str());
+        data._state = RegRpcSrvData::XCH_WANTADD;
+        data.env._exchanger.wantAdd(data.name.c_str(), data.spec.c_str(), std::move(dataUP));
         return;
-    } else if (_data->_state == RegRpcSrvData::XCH_WANTADD) {
-        LOG(spam, "phase addManaged(%s,%s)",
-            _data->name.c_str(), _data->spec.c_str());
-        _data->_state = RegRpcSrvData::CHK_RPCSRV;
-        _data->env._rpcsrvmanager.addManaged(_data->name.c_str(), _data->spec.c_str(), *this);
+    } else if (data._state == RegRpcSrvData::XCH_WANTADD) {
+        LOG(spam, "phase addManaged(%s,%s)", data.name.c_str(), data.spec.c_str());
+        data._state = RegRpcSrvData::CHK_RPCSRV;
+        data.env._rpcsrvmanager.addManaged(data.name, data.spec.c_str(), std::move(dataUP));
         return;
-    } else if (_data->_state == RegRpcSrvData::CHK_RPCSRV) {
-        LOG(spam, "phase doAdd(%s,%s)", _data->name.c_str(), _data->spec.c_str());
-        _data->_state = RegRpcSrvData::XCH_DOADD;
-        _data->env._exchanger.doAdd(_data->name.c_str(), _data->spec.c_str(), *this);
+    } else if (data._state == RegRpcSrvData::CHK_RPCSRV) {
+        LOG(spam, "phase doAdd(%s,%s)", data.name.c_str(), data.spec.c_str());
+        data._state = RegRpcSrvData::XCH_DOADD;
+        data.env._exchanger.doAdd(data.name.c_str(), data.spec.c_str(), std::move(dataUP));
         return;
-    } else if (_data->_state == RegRpcSrvData::XCH_DOADD) {
-        LOG(debug, "done doAdd(%s,%s)", _data->name.c_str(), _data->spec.c_str());
-        _data->_state = RegRpcSrvData::RDC_INVAL;
+    } else if (data._state == RegRpcSrvData::XCH_DOADD) {
+        LOG(debug, "done doAdd(%s,%s)", data.name.c_str(), data.spec.c_str());
+        data._state = RegRpcSrvData::RDC_INVAL;
         // all OK
-        _data->registerRequest->Return();
+        data.registerRequest->Return();
         goto alldone;
-    } else if (_data->_state == RegRpcSrvData::XCH_IGNORE) {
+    } else if (data._state == RegRpcSrvData::XCH_IGNORE) {
         goto alldone;
     }
     // no other state should be possible
     LOG_ABORT("should not be reached");
  alldone:
-    cleanupReservation();
-    delete _data;
-    _data = NULL;
+    cleanupReservation(data);
 }
 
 //-----------------------------------------------------------------------------
diff --git a/slobrok/src/vespa/slobrok/server/cmd.h b/slobrok/src/vespa/slobrok/server/cmd.h
index 744d874eed0..07b3d3ee0ba 100644
--- a/slobrok/src/vespa/slobrok/server/cmd.h
+++ b/slobrok/src/vespa/slobrok/server/cmd.h
@@ -2,6 +2,7 @@
 #pragma once
 
 #include "ok_state.h"
+#include <memory>
 
 class FRT_RPCRequest;
 
@@ -20,33 +21,19 @@ struct RegRpcSrvData;
 class RegRpcSrvCommand
 {
 private:
-    RegRpcSrvData *_data;
-    RegRpcSrvCommand(RegRpcSrvData *data) : _data(data) {}
-    void cleanupReservation();
+    std::unique_ptr<RegRpcSrvData> _data;
+    static void cleanupReservation(RegRpcSrvData &);
+    RegRpcSrvCommand(std::unique_ptr<RegRpcSrvData> data);
 public:
     virtual void doneHandler(OkState result);
     void doRequest();
 
-    RegRpcSrvCommand(const RegRpcSrvCommand &rhs)
-        : _data(rhs._data)
-    {
-    }
-
-    virtual ~RegRpcSrvCommand() {}
-
-    RegRpcSrvCommand& operator=(const RegRpcSrvCommand &rhs)
-    {
-        _data = rhs._data;
-        return *this;
-    }
-
-    static RegRpcSrvCommand makeRegRpcSrvCmd(SBEnv &env,
-                                             const char *name,
-                                             const char *spec,
-                                             FRT_RPCRequest *req);
-    static RegRpcSrvCommand makeRemRemCmd(SBEnv &env,
-                                          const char *name,
-                                          const char *spec);
+    RegRpcSrvCommand(RegRpcSrvCommand &&);
+    RegRpcSrvCommand & operator=(RegRpcSrvCommand &&);
+    virtual ~RegRpcSrvCommand();
+
+    static RegRpcSrvCommand makeRegRpcSrvCmd(SBEnv &env, const std::string &name, const std::string &spec, FRT_RPCRequest *req);
+    static RegRpcSrvCommand makeRemRemCmd(SBEnv &env, const std::string &name, const std::string &spec);
 };
 
 //-----------------------------------------------------------------------------
diff --git a/slobrok/src/vespa/slobrok/server/exchange_manager.cpp b/slobrok/src/vespa/slobrok/server/exchange_manager.cpp
index f3e06d83282..e74724803e8 100644
--- a/slobrok/src/vespa/slobrok/server/exchange_manager.cpp
+++ b/slobrok/src/vespa/slobrok/server/exchange_manager.cpp
@@ -13,23 +13,23 @@ namespace slobrok {
 //-----------------------------------------------------------------------------
 
 ExchangeManager::ExchangeManager(SBEnv &env, RpcServerMap &rpcsrvmap)
-    : _partners(NULL),
+    : _partners(),
       _env(env),
       _rpcsrvmanager(env._rpcsrvmanager),
       _rpcsrvmap(rpcsrvmap)
 {
 }
 
+ExchangeManager::~ExchangeManager() = default;
 
 OkState
-ExchangeManager::addPartner(const char *name, const char *spec)
+ExchangeManager::addPartner(const std::string & name, const std::string & spec)
 {
-    RemoteSlobrok *oldremote = _partners[name];
-    if (oldremote != NULL) {
+    RemoteSlobrok *oldremote = lookupPartner(name);
+    if (oldremote != nullptr) {
         // already a partner, should be OK
-        if (strcmp(spec, oldremote->getSpec()) != 0) {
-            return OkState(FRTE_RPC_METHOD_FAILED,
-                           "name already partner with different spec");
+        if (spec != oldremote->getSpec()) {
+            return OkState(FRTE_RPC_METHOD_FAILED, "name already partner with different spec");
         }
         // this is probably a good time to try connecting again
         if (! oldremote->isConnected()) {
@@ -38,100 +38,81 @@ ExchangeManager::addPartner(const char *name, const char *spec)
         return OkState();
     }
 
-    RemoteSlobrok *partner = new RemoteSlobrok(name, spec, *this);
-    LOG_ASSERT(_partners.isSet(name) == false);
-    _partners.set(name, partner);
-    partner->tryConnect();
+    LOG_ASSERT(_partners.find(name) == _partners.end());
+    auto newPartner = std::make_unique<RemoteSlobrok>(name, spec, *this);
+    RemoteSlobrok & partner = *newPartner;
+    _partners.emplace(name, std::move(newPartner));
+    partner.tryConnect();
     return OkState();
 }
 
-
 void
-ExchangeManager::removePartner(const char *name)
+ExchangeManager::removePartner(const std::string & name)
 {
     // assuming checks already done
-    RemoteSlobrok *oldremote = _partners.remove(name);
-    LOG_ASSERT(oldremote != NULL);
-    delete oldremote;
+    auto oldremote = std::move(_partners[name]);
+    LOG_ASSERT(oldremote);
+    _partners.erase(name);
 }
 
-
 std::vector<std::string>
 ExchangeManager::getPartnerList()
 {
     std::vector<std::string> partnerList;
-    HashMap<RemoteSlobrok *>::Iterator itr =  _partners.iterator();
-    for (; itr.valid(); itr.next()) {
-        partnerList.push_back(std::string(itr.value()->getSpec()));
+    for (const auto & entry : _partners) {
+        partnerList.push_back(entry.second->getSpec());
     }
     return partnerList;
 }
 
 
 void
-ExchangeManager::forwardRemove(const char *name, const char *spec)
+ExchangeManager::forwardRemove(const std::string & name, const std::string & spec)
 {
-    RegRpcSrvCommand remremhandler
-        = RegRpcSrvCommand::makeRemRemCmd(_env, name, spec);
-    WorkPackage *package = new WorkPackage(WorkPackage::OP_REMOVE,
-                                           name, spec, *this,
-                                           remremhandler);
-    HashMap<RemoteSlobrok *>::Iterator it = _partners.iterator();
-    while (it.valid()) {
-        RemoteSlobrok *partner = it.value();
-        package->addItem(partner);
-        it.next();
+    WorkPackage *package = new WorkPackage(WorkPackage::OP_REMOVE, name, spec, *this,
+                                           RegRpcSrvCommand::makeRemRemCmd(_env, name, spec));
+    for (const auto & entry : _partners) {
+        package->addItem(entry.second.get());
     }
     package->expedite();
 }
 
 void
-ExchangeManager::doAdd(const char *name, const char *spec,
-                       RegRpcSrvCommand rdc)
+ExchangeManager::doAdd(const std::string &name, const std::string &spec, RegRpcSrvCommand rdc)
 {
-    HashMap<RemoteSlobrok *>::Iterator it =
-        _partners.iterator();
+    WorkPackage *package = new WorkPackage(WorkPackage::OP_DOADD, name, spec, *this, std::move(rdc));
 
-    WorkPackage *package =
-        new WorkPackage(WorkPackage::OP_DOADD, name, spec, *this, rdc);
-
-    while (it.valid()) {
-        RemoteSlobrok *partner = it.value();
-        package->addItem(partner);
-        it.next();
+    for (const auto & entry : _partners) {
+        package->addItem(entry.second.get());
     }
     package->expedite();
 }
 
 
 void
-ExchangeManager::wantAdd(const char *name, const char *spec,
-                         RegRpcSrvCommand rdc)
+ExchangeManager::wantAdd(const std::string &name, const std::string &spec, RegRpcSrvCommand rdc)
 {
-    WorkPackage *package =
-        new WorkPackage(WorkPackage::OP_WANTADD, name, spec, *this, rdc);
-    HashMap<RemoteSlobrok *>::Iterator it = _partners.iterator();
-    while (it.valid()) {
-        RemoteSlobrok *partner = it.value();
-        package->addItem(partner);
-        it.next();
+    WorkPackage *package = new WorkPackage(WorkPackage::OP_WANTADD, name, spec, *this, std::move(rdc));
+    for (const auto & entry : _partners) {
+        package->addItem(entry.second.get());
     }
     package->expedite();
 }
 
+RemoteSlobrok *
+ExchangeManager::lookupPartner(const std::string & name) const {
+    auto found = _partners.find(name);
+    return (found == _partners.end()) ? nullptr : found->second.get();
+}
 
 void
 ExchangeManager::healthCheck()
 {
-    int i=0;
-    HashMap<RemoteSlobrok *>::Iterator it = _partners.iterator();
-    while (it.valid()) {
-        RemoteSlobrok *partner = it.value();
+    for (const auto & entry : _partners) {
+        RemoteSlobrok *partner = entry.second.get();
         partner->healthCheck();
-        it.next();
-        i++;
     }
-    LOG(debug, "ExchangeManager::healthCheck for %d partners", i);
+    LOG(debug, "ExchangeManager::healthCheck for %ld partners", _partners.size());
 }
 
 //-----------------------------------------------------------------------------
@@ -152,8 +133,7 @@ ExchangeManager::WorkPackage::WorkItem::RequestDone(FRT_RPCRequest *req)
 
     if (!req->IsError() && strcmp(answer.GetTypeString(), "is") == 0) {
         if (answer[0]._intval32 != 0) {
-            LOG(warning, "request denied: %s [%d]",
-                answer[1]._string._str, answer[0]._intval32);
+            LOG(warning, "request denied: %s [%d]", answer[1]._string._str, answer[0]._intval32);
             denied = true;
         } else {
             LOG(spam, "request approved");
@@ -163,7 +143,7 @@ ExchangeManager::WorkPackage::WorkItem::RequestDone(FRT_RPCRequest *req)
         // XXX tell remslob?
     }
     req->SubRef();
-    _pendingReq = NULL;
+    _pendingReq = nullptr;
     _pkg.doneItem(denied);
 }
 
@@ -175,21 +155,19 @@ ExchangeManager::WorkPackage::WorkItem::expedite()
 
 ExchangeManager::WorkPackage::WorkItem::~WorkItem()
 {
-    if (_pendingReq != NULL) {
+    if (_pendingReq != nullptr) {
         _pendingReq->Abort();
-        LOG_ASSERT(_pendingReq == NULL);
+        LOG_ASSERT(_pendingReq == nullptr);
     }
 }
 
 
-ExchangeManager::WorkPackage::WorkPackage(op_type op,
-                                          const char *name, const char *spec,
-                                          ExchangeManager &exchanger,
-                                          RegRpcSrvCommand donehandler)
+ExchangeManager::WorkPackage::WorkPackage(op_type op, const std::string & name, const std::string & spec,
+                                          ExchangeManager &exchanger, RegRpcSrvCommand donehandler)
     : _work(),
       _doneCnt(0),
       _numDenied(0),
-      _donehandler(donehandler),
+      _donehandler(std::move(donehandler)),
       _exchanger(exchanger),
       _optype(op),
       _name(name),
@@ -197,13 +175,7 @@ ExchangeManager::WorkPackage::WorkPackage(op_type op,
 {
 }
 
-ExchangeManager::WorkPackage::~WorkPackage()
-{
-    for (size_t i = 0; i < _work.size(); i++) {
-        delete _work[i];
-        _work[i] = NULL;
-    }
-}
+ExchangeManager::WorkPackage::~WorkPackage() = default;
 
 void
 ExchangeManager::WorkPackage::doneItem(bool denied)
@@ -240,15 +212,14 @@ ExchangeManager::WorkPackage::addItem(RemoteSlobrok *partner)
     } else if (_optype == OP_DOADD) {
         r->SetMethodName("slobrok.internal.doAdd");
     }
-    r->GetParams()->AddString(_exchanger._env.mySpec());
+    r->GetParams()->AddString(_exchanger._env.mySpec().c_str());
     r->GetParams()->AddString(_name.c_str());
     r->GetParams()->AddString(_spec.c_str());
 
-    WorkItem *item = new WorkItem(*this, partner, r);
-    _work.push_back(item);
+    _work.push_back(std::make_unique<WorkItem>(*this, partner, r));
     LOG(spam, "added %s(%s,%s,%s) for %s to workpackage",
-        r->GetMethodName(), _exchanger._env.mySpec(),
-        _name.c_str(), _spec.c_str(), partner->getName());
+        r->GetMethodName(), _exchanger._env.mySpec().c_str(),
+        _name.c_str(), _spec.c_str(), partner->getName().c_str());
 }
 
 
diff --git a/slobrok/src/vespa/slobrok/server/exchange_manager.h b/slobrok/src/vespa/slobrok/server/exchange_manager.h
index 4d7bf4cff15..ea335cbb3c0 100644
--- a/slobrok/src/vespa/slobrok/server/exchange_manager.h
+++ b/slobrok/src/vespa/slobrok/server/exchange_manager.h
@@ -1,14 +1,14 @@
 // Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 #pragma once
 
-#include <deque>
-#include <string>
-
-#include <vespa/vespalib/util/hashmap.h>
 #include "ok_state.h"
 #include "cmd.h"
 #include "remote_slobrok.h"
 
+#include <deque>
+#include <string>
+#include <unordered_map>
+
 namespace slobrok {
 
 //-----------------------------------------------------------------------------
@@ -17,8 +17,6 @@ class SBEnv;
 class RpcServerMap;
 class RpcServerManager;
 
-using vespalib::HashMap;
-
 //-----------------------------------------------------------------------------
 
 /**
@@ -31,10 +29,8 @@ using vespalib::HashMap;
 class ExchangeManager
 {
 private:
-    ExchangeManager(const ExchangeManager &);            // Not used
-    ExchangeManager &operator=(const ExchangeManager &); // Not used
-
-    HashMap<RemoteSlobrok *> _partners;
+    using PartnerMap = std::unordered_map<std::string, std::unique_ptr<RemoteSlobrok>>;
+    PartnerMap _partners;
 
     class WorkPackage;
 
@@ -48,27 +44,21 @@ private:
     class WorkPackage
     {
     private:
-        WorkPackage(const WorkPackage&); // not used
-        WorkPackage& operator= (const WorkPackage&); // not used
-
         class WorkItem: public FRT_IRequestWait
         {
         private:
             WorkPackage    &_pkg;
             FRT_RPCRequest *_pendingReq;
             RemoteSlobrok  *_remslob;
-
-            WorkItem(const WorkItem&); // not used
-            WorkItem& operator= (const WorkItem&); // not used
         public:
             void expedite();
             void RequestDone(FRT_RPCRequest *req) override;
-            WorkItem(WorkPackage &pkg,
-                     RemoteSlobrok *rem,
-                     FRT_RPCRequest *req);
+            WorkItem(WorkPackage &pkg, RemoteSlobrok *rem, FRT_RPCRequest *req);
+            WorkItem(const WorkItem&) = delete;
+            WorkItem& operator= (const WorkItem&) = delete;
             ~WorkItem();
         };
-        std::vector<WorkItem *> _work;
+        std::vector<std::unique_ptr<WorkItem>> _work;
         size_t                  _doneCnt;
         size_t                  _numDenied;
         RegRpcSrvCommand        _donehandler;
@@ -81,41 +71,36 @@ private:
         void addItem(RemoteSlobrok *partner);
         void doneItem(bool denied);
         void expedite();
-        WorkPackage(op_type op,
-                    const char *name, const char *spec,
-                    ExchangeManager &exchanger,
-                    RegRpcSrvCommand  donehandler);
+        WorkPackage(const WorkPackage&) = delete;
+        WorkPackage& operator= (const WorkPackage&) = delete;
+        WorkPackage(op_type op, const std::string & name, const std::string & spec,
+                    ExchangeManager &exchanger, RegRpcSrvCommand  donehandler);
         ~WorkPackage();
     };
 
 public:
+    ExchangeManager(const ExchangeManager &) = delete;
+    ExchangeManager &operator=(const ExchangeManager &) = delete;
     ExchangeManager(SBEnv &env, RpcServerMap &rpcsrvmap);
-    ~ExchangeManager() {}
+    ~ExchangeManager();
 
     SBEnv             &_env;
     RpcServerManager  &_rpcsrvmanager;
     RpcServerMap      &_rpcsrvmap;
 
-    OkState addPartner(const char *name, const char *spec);
-    void removePartner(const char *name);
+    OkState addPartner(const std::string & name, const std::string & spec);
+    void removePartner(const std::string & name);
     std::vector<std::string> getPartnerList();
 
-    void registerFrom(RemoteSlobrok *partner);
-    void reregisterTo(RemoteSlobrok *partner);
+    void forwardRemove(const std::string & name, const std::string & spec);
 
-    void forwardRemove(const char *name, const char *spec);
-
-    void wantAdd(const char *name, const char *spec, RegRpcSrvCommand rdc);
-    void doAdd(const char *name, const char *spec, RegRpcSrvCommand rdc);
-
-    RemoteSlobrok *lookupPartner(const char *name) const {
-        return _partners[name];
-    }
+    void wantAdd(const std::string & name, const std::string & spec, RegRpcSrvCommand rdc);
+    void doAdd(const std::string & name, const std::string & spec, RegRpcSrvCommand rdc);
 
+    RemoteSlobrok *lookupPartner(const std::string & name) const;
     void healthCheck();
 };
 
 //-----------------------------------------------------------------------------
 
 } // namespace slobrok
-
diff --git a/slobrok/src/vespa/slobrok/server/history.cpp b/slobrok/src/vespa/slobrok/server/history.cpp
index 9b4fcedba8b..f23b0cbb757 100644
--- a/slobrok/src/vespa/slobrok/server/history.cpp
+++ b/slobrok/src/vespa/slobrok/server/history.cpp
@@ -22,7 +22,7 @@ History::verify() const
 }
 
 void
-History::add(const char *name, vespalib::GenCnt gen)
+History::add(const std::string &name, vespalib::GenCnt gen)
 {
     HistoryEntry h;
     _entries.push_back(h);
diff --git a/slobrok/src/vespa/slobrok/server/history.h b/slobrok/src/vespa/slobrok/server/history.h
index 2790d467b1a..ca90c927dc0 100644
--- a/slobrok/src/vespa/slobrok/server/history.h
+++ b/slobrok/src/vespa/slobrok/server/history.h
@@ -18,12 +18,11 @@ private:
 
     std::vector<HistoryEntry> _entries;
 
-    typedef std::vector<HistoryEntry>::iterator        iter_t;
     typedef std::vector<HistoryEntry>::const_iterator citer_t;
 
     void verify() const;
 public:
-    void add(const char *name, vespalib::GenCnt gen);
+    void add(const std::string &name, vespalib::GenCnt gen);
 
     bool has(vespalib::GenCnt gen) const;
 
diff --git a/slobrok/src/vespa/slobrok/server/managed_rpc_server.cpp b/slobrok/src/vespa/slobrok/server/managed_rpc_server.cpp
index 925df0e9f57..065dac04304 100644
--- a/slobrok/src/vespa/slobrok/server/managed_rpc_server.cpp
+++ b/slobrok/src/vespa/slobrok/server/managed_rpc_server.cpp
@@ -12,14 +12,14 @@ namespace slobrok {
 
 //-----------------------------------------------------------------------------
 
-ManagedRpcServer::ManagedRpcServer(const char *name,
-                                   const char *spec,
+ManagedRpcServer::ManagedRpcServer(const std::string & name,
+                                   const std::string & spec,
                                    IRpcServerManager &manager)
     : NamedService(name, spec),
       _mmanager(manager),
       _monitor(*this, *manager.getSupervisor()),
-      _monitoredServer(NULL),
-      _checkServerReq(NULL)
+      _monitoredServer(nullptr),
+      _checkServerReq(nullptr)
 {
 }
 
@@ -27,10 +27,10 @@ ManagedRpcServer::ManagedRpcServer(const char *name,
 void
 ManagedRpcServer::healthCheck()
 {
-    if (_monitoredServer == NULL) {
+    if (_monitoredServer == nullptr) {
         _monitoredServer = _mmanager.getSupervisor()->GetTarget(_spec.c_str());
     }
-    if (_checkServerReq == NULL) {
+    if (_checkServerReq == nullptr) {
         _checkServerReq = _mmanager.getSupervisor()->AllocRPCRequest();
         _checkServerReq->SetMethodName("slobrok.callback.listNamesServed");
         _monitoredServer->InvokeAsync(_checkServerReq, 25.0, this);
@@ -49,14 +49,14 @@ void
 ManagedRpcServer::cleanupMonitor()
 {
     _monitor.disable();
-    if (_monitoredServer != NULL) {
+    if (_monitoredServer != nullptr) {
         _monitoredServer->SubRef();
-        _monitoredServer = NULL;
+        _monitoredServer = nullptr;
     }
-    if (_checkServerReq != NULL) {
+    if (_checkServerReq != nullptr) {
         _checkServerReq->Abort();
         // _checkServerReq cleared by RequestDone Method
-        LOG_ASSERT(_checkServerReq == NULL);
+        LOG_ASSERT(_checkServerReq == nullptr);
     }
 }
 
@@ -90,9 +90,9 @@ ManagedRpcServer::RequestDone(FRT_RPCRequest *req)
     FRT_Values &answer = *(req->GetReturn());
 
     if (req->GetErrorCode() == FRTE_RPC_ABORT) {
-        LOG(debug, "rpcserver[%s].check aborted", getName());
+        LOG(debug, "rpcserver[%s].check aborted", getName().c_str());
         req->SubRef();
-        _checkServerReq = NULL;
+        _checkServerReq = nullptr;
         return;
     }
 
@@ -111,18 +111,18 @@ ManagedRpcServer::RequestDone(FRT_RPCRequest *req)
             errmsg = "checkServer failed validation";
         }
         req->SubRef();
-        _checkServerReq = NULL;
+        _checkServerReq = nullptr;
         cleanupMonitor();
         _mmanager.notifyFailedRpcSrv(this, errmsg);
         return;
     }
 
     // start monitoring connection to server
-    LOG_ASSERT(_monitoredServer != NULL);
+    LOG_ASSERT(_monitoredServer != nullptr);
     _monitor.enable(_monitoredServer);
 
     req->SubRef();
-    _checkServerReq = NULL;
+    _checkServerReq = nullptr;
     _mmanager.notifyOkRpcSrv(this);
 }
 
diff --git a/slobrok/src/vespa/slobrok/server/managed_rpc_server.h b/slobrok/src/vespa/slobrok/server/managed_rpc_server.h
index e8bb8b6e2d8..072aebd7850 100644
--- a/slobrok/src/vespa/slobrok/server/managed_rpc_server.h
+++ b/slobrok/src/vespa/slobrok/server/managed_rpc_server.h
@@ -25,14 +25,10 @@ class ManagedRpcServer: public NamedService,
                         public FRT_IRequestWait,
                         public IMonitoredServer
 {
-private:
-    ManagedRpcServer(const ManagedRpcServer&);            // Not used
-    ManagedRpcServer& operator=(const ManagedRpcServer&); // Not used
-
 public:
-    ManagedRpcServer(const char *name,
-                     const char *spec,
-                     IRpcServerManager &manager);
+    ManagedRpcServer(const ManagedRpcServer&) = delete;
+    ManagedRpcServer& operator=(const ManagedRpcServer&) = delete;
+    ManagedRpcServer(const std::string & name, const std::string & spec, IRpcServerManager &manager);
     ~ManagedRpcServer();
 
     void healthCheck();
diff --git a/slobrok/src/vespa/slobrok/server/named_service.cpp b/slobrok/src/vespa/slobrok/server/named_service.cpp
index 59c2c31dbdc..c1aeb83a8a5 100644
--- a/slobrok/src/vespa/slobrok/server/named_service.cpp
+++ b/slobrok/src/vespa/slobrok/server/named_service.cpp
@@ -9,8 +9,7 @@ namespace slobrok {
 
 //-----------------------------------------------------------------------------
 
-NamedService::NamedService(const char *name,
-                     const char *spec)
+NamedService::NamedService(const std::string & name, const std::string & spec)
     : _name(name),
       _spec(spec)
 {
diff --git a/slobrok/src/vespa/slobrok/server/named_service.h b/slobrok/src/vespa/slobrok/server/named_service.h
index d08b5079ef2..712e340400c 100644
--- a/slobrok/src/vespa/slobrok/server/named_service.h
+++ b/slobrok/src/vespa/slobrok/server/named_service.h
@@ -25,11 +25,11 @@ public:
     NamedService(const NamedService &) = delete;
     NamedService &operator=(const NamedService &) = delete;
 
-    NamedService(const char *name, const char *spec);
+    NamedService(const std::string & name, const std::string & spec);
     virtual ~NamedService();
 
-    const char *getName() const { return _name.c_str(); }
-    const char *getSpec() const { return _spec.c_str(); }
+    const std::string & getName() const { return _name; }
+    const std::string & getSpec() const { return _spec; }
 };
 
 //-----------------------------------------------------------------------------
diff --git a/slobrok/src/vespa/slobrok/server/remote_slobrok.cpp b/slobrok/src/vespa/slobrok/server/remote_slobrok.cpp
index bc33fc900ec..e8569bbae28 100644
--- a/slobrok/src/vespa/slobrok/server/remote_slobrok.cpp
+++ b/slobrok/src/vespa/slobrok/server/remote_slobrok.cpp
@@ -12,57 +12,45 @@
 LOG_SETUP(".rpcserver");
 
 namespace slobrok {
-namespace {
-
-class IgnoreReqDone: public FRT_IRequestWait
-{
-    void RequestDone(FRT_RPCRequest *req) override {
-        req->SubRef();
-    }
-};
-
-} // namespace slobrok::<unnamed>
 
 //-----------------------------------------------------------------------------
 
-RemoteSlobrok::RemoteSlobrok(const char *name, const char *spec,
+RemoteSlobrok::RemoteSlobrok(const std::string &name, const std::string &spec,
                              ExchangeManager &manager)
     : _exchanger(manager),
       _rpcsrvmanager(manager._rpcsrvmanager),
-      _remote(NULL),
+      _remote(nullptr),
       _rpcserver(name, spec, *this),
       _reconnecter(getSupervisor()->GetScheduler(), *this),
       _failCnt(0),
-      _remAddPeerReq(NULL),
-      _remListReq(NULL),
-      _remAddReq(NULL),
-      _remRemReq(NULL),
+      _remAddPeerReq(nullptr),
+      _remListReq(nullptr),
+      _remAddReq(nullptr),
+      _remRemReq(nullptr),
       _pending()
 {
     _rpcserver.healthCheck();
 }
 
-static IgnoreReqDone ignorer;
-
 RemoteSlobrok::~RemoteSlobrok()
 {
     _reconnecter.disable();
 
-    if (_remote != NULL) {
+    if (_remote != nullptr) {
         _remote->SubRef();
-        _remote = NULL;
+        _remote = nullptr;
     }
 
-    if (_remAddPeerReq != NULL) {
+    if (_remAddPeerReq != nullptr) {
         _remAddPeerReq->Abort();
     }
-    if (_remListReq != NULL) {
+    if (_remListReq != nullptr) {
         _remListReq->Abort();
     }
-    if (_remAddReq != NULL) {
+    if (_remAddReq != nullptr) {
         _remAddReq->Abort();
     }
-    if (_remRemReq != NULL) {
+    if (_remRemReq != nullptr) {
         _remRemReq->Abort();
     }
     // _rpcserver destructor called automatically
@@ -72,32 +60,31 @@ RemoteSlobrok::~RemoteSlobrok()
 void
 RemoteSlobrok::doPending()
 {
-    LOG_ASSERT(_remAddReq == NULL);
-    LOG_ASSERT(_remRemReq == NULL);
+    LOG_ASSERT(_remAddReq == nullptr);
+    LOG_ASSERT(_remRemReq == nullptr);
 
-    if (_pending.size() > 0) {
-        NamedService *todo = _pending.front();
+    if ( ! _pending.empty() ) {
+        std::unique_ptr<NamedService> todo = std::move(_pending.front());
         _pending.pop_front();
 
-        NamedService *rpcsrv = _exchanger._rpcsrvmap.lookup(todo->getName());
+        const NamedService *rpcsrv = _exchanger._rpcsrvmap.lookup(todo->getName());
 
-        if (rpcsrv == NULL) {
+        if (rpcsrv == nullptr) {
             _remRemReq = getSupervisor()->AllocRPCRequest();
             _remRemReq->SetMethodName("slobrok.internal.doRemove");
-            _remRemReq->GetParams()->AddString(_exchanger._env.mySpec());
-            _remRemReq->GetParams()->AddString(todo->getName());
-            _remRemReq->GetParams()->AddString(todo->getSpec());
+            _remRemReq->GetParams()->AddString(_exchanger._env.mySpec().c_str());
+            _remRemReq->GetParams()->AddString(todo->getName().c_str());
+            _remRemReq->GetParams()->AddString(todo->getSpec().c_str());
             _remote->InvokeAsync(_remRemReq, 2.0, this);
         } else {
             _remAddReq = getSupervisor()->AllocRPCRequest();
             _remAddReq->SetMethodName("slobrok.internal.doAdd");
-            _remAddReq->GetParams()->AddString(_exchanger._env.mySpec());
-            _remAddReq->GetParams()->AddString(todo->getName());
-            _remAddReq->GetParams()->AddString(rpcsrv->getSpec());
+            _remAddReq->GetParams()->AddString(_exchanger._env.mySpec().c_str());
+            _remAddReq->GetParams()->AddString(todo->getName().c_str());
+            _remAddReq->GetParams()->AddString(rpcsrv->getSpec().c_str());
             _remote->InvokeAsync(_remAddReq, 2.0, this);
         }
         // XXX should save this and pick up on RequestDone()
-        delete todo;
     }
 
 }
@@ -110,8 +97,7 @@ RemoteSlobrok::pushMine()
     while (mine.size() > 0) {
         const NamedService *now = mine.back();
         mine.pop_back();
-        NamedService *copy = new NamedService(now->getName(), now->getSpec());
-        _pending.push_back(copy);
+        _pending.push_back(std::make_unique<NamedService>(now->getName(), now->getSpec()));
     }
     doPending();
 }
@@ -127,19 +113,18 @@ RemoteSlobrok::RequestDone(FRT_RPCRequest *req)
             const char *myname     = args[0]._string._str;
             const char *myspec     = args[1]._string._str;
             LOG(error, "addPeer(%s, %s) on remote slobrok %s at %s: %s",
-                myname, myspec, getName(), getSpec(),
-                req->GetErrorMessage());
+                myname, myspec, getName().c_str(), getSpec().c_str(), req->GetErrorMessage());
             req->SubRef();
-            _remAddPeerReq = NULL;
+            _remAddPeerReq = nullptr;
             goto retrylater;
         }
         req->SubRef();
-        _remAddPeerReq = NULL;
+        _remAddPeerReq = nullptr;
         // next step is to ask the remote to send its list of managed names:
-        LOG_ASSERT(_remListReq == NULL);
+        LOG_ASSERT(_remListReq == nullptr);
         _remListReq = getSupervisor()->AllocRPCRequest();
         _remListReq->SetMethodName("slobrok.internal.listManagedRpcServers");
-        if (_remote != NULL) {
+        if (_remote != nullptr) {
             _remote->InvokeAsync(_remListReq, 3.0, this);
         }
         // when _remListReq is returned, our managed list is added
@@ -149,19 +134,18 @@ RemoteSlobrok::RequestDone(FRT_RPCRequest *req)
             || strcmp(answer.GetTypeString(), "SS") != 0)
         {
             LOG(error, "error listing remote slobrok %s at %s: %s",
-                getName(), getSpec(), req->GetErrorMessage());
+                getName().c_str(), getSpec().c_str(), req->GetErrorMessage());
             req->SubRef();
-            _remListReq = NULL;
+            _remListReq = nullptr;
             goto retrylater;
         }
         uint32_t numNames = answer.GetValue(0)._string_array._len;
         uint32_t numSpecs = answer.GetValue(1)._string_array._len;
 
         if (numNames != numSpecs) {
-            LOG(error, "inconsistent array lengths from %s at %s",
-                getName(), getSpec());
+            LOG(error, "inconsistent array lengths from %s at %s", getName().c_str(), getSpec().c_str());
             req->SubRef();
-            _remListReq = NULL;
+            _remListReq = nullptr;
             goto retrylater;
         }
         FRT_StringValue *names = answer.GetValue(0)._string_array._pt;
@@ -171,7 +155,7 @@ RemoteSlobrok::RequestDone(FRT_RPCRequest *req)
             _rpcsrvmanager.addRemote(names[idx]._str, specs[idx]._str);
         }
         req->SubRef();
-        _remListReq = NULL;
+        _remListReq = nullptr;
 
         // next step is to push the ones I own:
         pushMine();
@@ -180,10 +164,9 @@ RemoteSlobrok::RequestDone(FRT_RPCRequest *req)
         if (req->IsError() && (req->GetErrorCode() == FRTE_RPC_CONNECTION ||
                                req->GetErrorCode() == FRTE_RPC_TIMEOUT))
         {
-            LOG(error, "connection error adding to remote slobrok: %s",
-                req->GetErrorMessage());
+            LOG(error, "connection error adding to remote slobrok: %s", req->GetErrorMessage());
             req->SubRef();
-            _remAddReq = NULL;
+            _remAddReq = nullptr;
             goto retrylater;
         }
         if (req->IsError()) {
@@ -195,29 +178,27 @@ RemoteSlobrok::RequestDone(FRT_RPCRequest *req)
             _rpcsrvmanager.removeLocal(rpcsrvname, rpcsrvspec);
         }
         req->SubRef();
-        _remAddReq = NULL;
+        _remAddReq = nullptr;
         doPending();
     } else if (req == _remRemReq) {
         // handle response after pushing some remove we had pending:
         if (req->IsError() && (req->GetErrorCode() == FRTE_RPC_CONNECTION ||
                                req->GetErrorCode() == FRTE_RPC_TIMEOUT))
         {
-            LOG(error, "connection error adding to remote slobrok: %s",
-                req->GetErrorMessage());
+            LOG(error, "connection error adding to remote slobrok: %s", req->GetErrorMessage());
             req->SubRef();
-            _remRemReq = NULL;
+            _remRemReq = nullptr;
             goto retrylater;
         }
         if (req->IsError()) {
-            LOG(warning, "error removing on remote slobrok: %s",
-                req->GetErrorMessage());
+            LOG(warning, "error removing on remote slobrok: %s", req->GetErrorMessage());
         }
         req->SubRef();
-        _remRemReq = NULL;
+        _remRemReq = nullptr;
         doPending();
     } else {
         LOG(error, "got unknown request back in RequestDone()");
-        LOG_ASSERT(req == NULL);
+        LOG_ASSERT(req == nullptr);
     }
 
     return;
@@ -232,10 +213,10 @@ RemoteSlobrok::notifyFailedRpcSrv(ManagedRpcServer *rpcsrv, std::string errmsg)
 {
     if (++_failCnt > 10) {
         LOG(warning, "remote location broker at %s failed: %s",
-            rpcsrv->getSpec(), errmsg.c_str());
+            rpcsrv->getSpec().c_str(), errmsg.c_str());
     } else {
         LOG(debug, "remote location broker at %s failed: %s",
-            rpcsrv->getSpec(), errmsg.c_str());
+            rpcsrv->getSpec().c_str(), errmsg.c_str());
     }
     LOG_ASSERT(rpcsrv == &_rpcserver);
     fail();
@@ -246,9 +227,9 @@ void
 RemoteSlobrok::fail()
 {
     // disconnect
-    if (_remote != NULL) {
+    if (_remote != nullptr) {
         _remote->SubRef();
-        _remote = NULL;
+        _remote = nullptr;
     }
     // schedule reconnect attempt
     _reconnecter.scheduleTryConnect();
@@ -258,13 +239,13 @@ RemoteSlobrok::fail()
 void
 RemoteSlobrok::healthCheck()
 {
-    if (_remote != NULL &&
-        _remAddPeerReq == NULL &&
-        _remListReq == NULL &&
-        _remAddReq == NULL &&
-        _remRemReq == NULL)
+    if (_remote != nullptr &&
+        _remAddPeerReq == nullptr &&
+        _remListReq == nullptr &&
+        _remAddReq == nullptr &&
+        _remRemReq == nullptr)
     {
-        LOG(debug, "spamming remote at %s with my names", getName());
+        LOG(debug, "spamming remote at %s with my names", getName().c_str());
         pushMine();
     } else {
         LOG(debug, "not pushing mine, as we have: remote %p r.a.p.r=%p r.l.r=%p r.a.r=%p r.r.r=%p",
@@ -282,8 +263,8 @@ RemoteSlobrok::notifyOkRpcSrv(ManagedRpcServer *rpcsrv)
     // connection was OK, so disable any pending reconnect
     _reconnecter.disable();
 
-    if (_remote == NULL) {
-        _remote = getSupervisor()->GetTarget(getSpec());
+    if (_remote == nullptr) {
+        _remote = getSupervisor()->GetTarget(getSpec().c_str());
     }
 
     // at this point, we will do (in sequence):
@@ -294,8 +275,8 @@ RemoteSlobrok::notifyOkRpcSrv(ManagedRpcServer *rpcsrv)
 
     _remAddPeerReq = getSupervisor()->AllocRPCRequest();
     _remAddPeerReq->SetMethodName("slobrok.admin.addPeer");
-    _remAddPeerReq->GetParams()->AddString(_exchanger._env.mySpec());
-    _remAddPeerReq->GetParams()->AddString(_exchanger._env.mySpec());
+    _remAddPeerReq->GetParams()->AddString(_exchanger._env.mySpec().c_str());
+    _remAddPeerReq->GetParams()->AddString(_exchanger._env.mySpec().c_str());
     _remote->InvokeAsync(_remAddPeerReq, 3.0, this);
     // when _remAddPeerReq is returned, our managed list is added via doAdd()
 }
diff --git a/slobrok/src/vespa/slobrok/server/remote_slobrok.h b/slobrok/src/vespa/slobrok/server/remote_slobrok.h
index 1851e57c93c..a5d17e0452b 100644
--- a/slobrok/src/vespa/slobrok/server/remote_slobrok.h
+++ b/slobrok/src/vespa/slobrok/server/remote_slobrok.h
@@ -26,9 +26,6 @@ class RemoteSlobrok: public IRpcServerManager,
                      public FRT_IRequestWait
 {
 private:
-    RemoteSlobrok(const RemoteSlobrok&); // not used
-    RemoteSlobrok& operator= (const RemoteSlobrok&); // not used
-
     class Reconnecter : public FNET_Task
     {
     private:
@@ -38,13 +35,12 @@ private:
         Reconnecter &operator=(const Reconnecter &); // not used
     public:
         explicit Reconnecter(FNET_Scheduler *sched, RemoteSlobrok &owner);
-        ~Reconnecter();
+        ~Reconnecter() override;
         void scheduleTryConnect();
         void disable();
         void PerformTask() override;
     };
 
-private:
     ExchangeManager     &_exchanger;
     RpcServerManager    &_rpcsrvmanager;
     FRT_Target          *_remote;
@@ -57,24 +53,23 @@ private:
     FRT_RPCRequest      *_remAddReq;
     FRT_RPCRequest      *_remRemReq;
 
-    std::deque<NamedService *> _pending;
+    std::deque<std::unique_ptr<NamedService>> _pending;
     void pushMine();
     void doPending();
 
 public:
-    RemoteSlobrok(const char *name, const char *spec,
-                  ExchangeManager &manager);
-    ~RemoteSlobrok();
+    RemoteSlobrok(const RemoteSlobrok&) = delete;
+    RemoteSlobrok& operator= (const RemoteSlobrok&) = delete;
+    RemoteSlobrok(const std::string &name, const std::string &spec, ExchangeManager &manager);
+    ~RemoteSlobrok() override;
 
     void fail();
-    bool isConnected() const { return (_remote != NULL); }
+    bool isConnected() const { return (_remote != nullptr); }
     void tryConnect();
     void healthCheck();
-    void invokeAsync(FRT_RPCRequest *req,
-                     double timeout,
-                     FRT_IRequestWait *rwaiter);
-    const char *getName() const { return _rpcserver.getName(); }
-    const char *getSpec() const { return _rpcserver.getSpec(); }
+    void invokeAsync(FRT_RPCRequest *req, double timeout, FRT_IRequestWait *rwaiter);
+    const std::string & getName() const { return _rpcserver.getName(); }
+    const std::string & getSpec() const { return _rpcserver.getSpec(); }
 
     // interfaces implemented:
     void notifyFailedRpcSrv(ManagedRpcServer *rpcsrv, std::string errmsg) override;
diff --git a/slobrok/src/vespa/slobrok/server/reserved_name.h b/slobrok/src/vespa/slobrok/server/reserved_name.h
index 7761dc37918..1ebed4b94dc 100644
--- a/slobrok/src/vespa/slobrok/server/reserved_name.h
+++ b/slobrok/src/vespa/slobrok/server/reserved_name.h
@@ -22,15 +22,15 @@ private:
 public:
     const bool isLocal;
 
-    ReservedName(const char *name, const char *spec, bool local)
+    ReservedName(const std::string &name, const std::string &spec, bool local)
         : NamedService(name, spec), _reservedTime(), isLocal(local)
     {
         _reservedTime.SetNow();
     }
-    bool stillReserved() {
+    bool stillReserved() const {
         return (_reservedTime.MilliSecsToNow() < 15000);
     }
-    int seconds() { return _reservedTime.MilliSecsToNow() / 1000; }
+    int seconds() const { return _reservedTime.MilliSecsToNow() / 1000; }
 };
 
 //-----------------------------------------------------------------------------
diff --git a/slobrok/src/vespa/slobrok/server/rpc_server_manager.cpp b/slobrok/src/vespa/slobrok/server/rpc_server_manager.cpp
index 293975cc82a..e63efd8089a 100644
--- a/slobrok/src/vespa/slobrok/server/rpc_server_manager.cpp
+++ b/slobrok/src/vespa/slobrok/server/rpc_server_manager.cpp
@@ -24,15 +24,15 @@ RpcServerManager::RpcServerManager(SBEnv &sbenv)
 }
 
 static OkState
-validateName(const char *rpcsrvname)
+validateName(const std::string & rpcsrvname)
 {
-    const char *p = rpcsrvname;
+    const char *p = rpcsrvname.c_str();
     while (*p != '\0') {
         // important: disallow '*'
         if (strchr("+,-./:=@[]_{}~<>"
                    "0123456789"
                    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-                   "abcdefghijklmnopqrstuvwxyz", *p) == NULL)
+                   "abcdefghijklmnopqrstuvwxyz", *p) == nullptr)
         {
             std::ostringstream tmp;
             tmp << "Illegal character '" << *p << "' (";
@@ -49,22 +49,20 @@ validateName(const char *rpcsrvname)
 
 
 OkState
-RpcServerManager::checkPartner(const char *remslobrok)
+RpcServerManager::checkPartner(const std::string & remslobrok)
 {
-    if (strcmp(remslobrok, _env.mySpec()) == 0) {
+    if (remslobrok == _env.mySpec()) {
         return OkState(13, "remote slobrok using my rpcserver name");
     }
-    RemoteSlobrok *partner = _exchanger.lookupPartner(remslobrok);
-    if (partner == NULL) {
+    const RemoteSlobrok *partner = _exchanger.lookupPartner(remslobrok);
+    if (partner == nullptr) {
         return OkState(13, "remote slobrok not a partner");
     }
     return OkState();
 }
 
 OkState
-RpcServerManager::addRemReservation(const char *remslobrok,
-                                    const char *name,
-                                    const char *spec)
+RpcServerManager::addRemReservation(const std::string & remslobrok, const std::string & name, const std::string &spec)
 {
     OkState state = checkPartner(remslobrok);
     if (state.failed()) return state;
@@ -72,31 +70,28 @@ RpcServerManager::addRemReservation(const char *remslobrok,
     OkState valid = validateName(name);
     if (valid.failed()) return valid;
 
-    NamedService *old = _rpcsrvmap.lookupManaged(name);
-    if (old != NULL) {
-        if (strcmp(old->getSpec(), spec) == 0) {
+    const NamedService *old = _rpcsrvmap.lookupManaged(name);
+    if (old != nullptr) {
+        if (old->getSpec() == spec) {
             // was alright already
             return OkState(0, "already registered");
         }
         LOG(warning, "remote %s tried to register [%s -> %s] but we already have [%s -> %s] registered!",
-            remslobrok, name, spec, old->getName(), old->getSpec());
+            remslobrok.c_str(), name.c_str(), spec.c_str(), old->getName().c_str(), old->getSpec().c_str());
         return OkState(FRTE_RPC_METHOD_FAILED, "already managed by me");
     }
     if (_rpcsrvmap.conflictingReservation(name, spec)) {
-        return OkState(FRTE_RPC_METHOD_FAILED,
-                       "registration for name already in progress");
+        return OkState(FRTE_RPC_METHOD_FAILED, "registration for name already in progress");
     }
-    ReservedName *rpcsrv = new ReservedName(name, spec, false);
-    _rpcsrvmap.addReservation(rpcsrv);
+    _rpcsrvmap.addReservation(std::make_unique<ReservedName>(name, spec, false));
     return OkState(0, "done");
 }
 
 
 OkState
-RpcServerManager::addPeer(const char *remsbname,
-                          const char *remsbspec)
+RpcServerManager::addPeer(const std::string & remsbname, const std::string &remsbspec)
 {
-    if (strcmp(remsbname, _env.mySpec()) == 0) {
+    if (remsbname == _env.mySpec()) {
         return OkState(13, "cannot add remote slobrok with my rpcserver name");
     }
     return _exchanger.addPartner(remsbname, remsbspec);
@@ -104,17 +99,16 @@ RpcServerManager::addPeer(const char *remsbname,
 
 
 OkState
-RpcServerManager::removePeer(const char *remsbname,
-                             const char *remsbspec)
+RpcServerManager::removePeer(const std::string & remsbname, const std::string & remsbspec)
 {
-    if (strcmp(remsbname, _env.mySpec()) == 0) {
+    if (remsbname == _env.mySpec()) {
         return OkState(13, "cannot remove my own rpcserver name");
     }
-    RemoteSlobrok *partner = _exchanger.lookupPartner(remsbname);
-    if (partner == NULL) {
+    const RemoteSlobrok *partner = _exchanger.lookupPartner(remsbname);
+    if (partner == nullptr) {
         return OkState(0, "remote slobrok not a partner");
     }
-    if (strcmp(partner->getSpec(), remsbspec) != 0) {
+    if (partner->getSpec() != remsbspec) {
         return OkState(13, "peer registered with different spec");
     }
     _exchanger.removePartner(remsbname);
@@ -123,41 +117,39 @@ RpcServerManager::removePeer(const char *remsbname,
 
 
 OkState
-RpcServerManager::addMyReservation(const char *name, const char *spec)
+RpcServerManager::addMyReservation(const std::string & name, const std::string & spec)
 {
     OkState valid = validateName(name);
     if (valid.failed()) return valid;
 
-    NamedService *old = _rpcsrvmap.lookupManaged(name);
-    if (old != NULL) {
-        if (strcmp(old->getSpec(), spec) == 0) {
+    const NamedService *old = _rpcsrvmap.lookupManaged(name);
+    if (old != nullptr) {
+        if (old->getSpec() == spec) {
             // was alright already
             return OkState(0, "already registered");
         } else {
             return OkState(FRTE_RPC_METHOD_FAILED, vespalib::make_string(
                           "name %s registered (to %s), cannot register %s",
-                          name, old->getSpec(), spec));
+                          name.c_str(), old->getSpec().c_str(), spec.c_str()));
         }
     }
 
     // check if we already are in the progress of adding this
     if (_rpcsrvmap.conflictingReservation(name, spec)) {
-        ReservedName * rsv = _rpcsrvmap.getReservation(name);
+        const ReservedName * rsv = _rpcsrvmap.getReservation(name);
         LOG(warning, "conflicting registrations: wanted [%s -> %s] but [%s -> %s] already reserved",
-            name, spec, rsv->getName(), rsv->getSpec());
+            name.c_str(), spec.c_str(), rsv->getName().c_str(), rsv->getSpec().c_str());
         return OkState(FRTE_RPC_METHOD_FAILED,
                        "registration for name already in progress with a different spec");
     }
     _rpcsrvmap.removeReservation(name);
-    ReservedName *rpcsrv = new ReservedName(name, spec, true);
-    _rpcsrvmap.addReservation(rpcsrv);
+    _rpcsrvmap.addReservation(std::make_unique<ReservedName>(name, spec, true));
     return OkState(0, "done");
 }
 
 
 OkState
-RpcServerManager::addRemote(const char *name,
-                            const char *spec)
+RpcServerManager::addRemote(const std::string & name, const std::string &spec)
 {
     OkState valid = validateName(name);
     if (valid.failed()) return valid;
@@ -165,13 +157,12 @@ RpcServerManager::addRemote(const char *name,
     if (alreadyManaged(name, spec)) {
         return OkState(0, "already correct");
     }
-    NamedService *old = _rpcsrvmap.lookup(name);
-    if (old != NULL) {
-        if (strcmp(old->getSpec(), spec) != 0) {
-            LOG(warning, "collision on remote add: "
-                "name %s registered to %s locally, "
+    const NamedService *old = _rpcsrvmap.lookup(name);
+    if (old != nullptr) {
+        if (old->getSpec() !=  spec) {
+            LOG(warning, "collision on remote add: name %s registered to %s locally, "
                 "but another location broker wants it registered to %s",
-                name, old->getSpec(), spec);
+                name.c_str(), old->getSpec().c_str(), spec.c_str());
             removeRemote(name, old->getSpec());
             return OkState(13, "registered, with different spec");
         }
@@ -180,16 +171,17 @@ RpcServerManager::addRemote(const char *name,
         return OkState(0, "already correct");
     }
     _rpcsrvmap.removeReservation(name);
-    ManagedRpcServer *rpcsrv = new ManagedRpcServer(name, spec, *this);
-    _rpcsrvmap.addNew(rpcsrv);
-    rpcsrv->healthCheck();
+    auto rpcsrv = std::make_unique<ManagedRpcServer>(name, spec, *this);
+    ManagedRpcServer & rpcServer = *rpcsrv;
+    _rpcsrvmap.addNew(std::move(rpcsrv));
+    rpcServer.healthCheck();
     return OkState(0, "done");
 }
 
 OkState
 RpcServerManager::remove(ManagedRpcServer *rpcsrv)
 {
-    NamedService *td = _rpcsrvmap.lookup(rpcsrv->getName());
+    const NamedService *td = _rpcsrvmap.lookup(rpcsrv->getName());
     if (td == rpcsrv) {
         return removeLocal(rpcsrv->getName(), rpcsrv->getSpec());
     } else {
@@ -199,84 +191,80 @@ RpcServerManager::remove(ManagedRpcServer *rpcsrv)
 
 
 OkState
-RpcServerManager::removeRemote(const char *name,
-                               const char *spec)
+RpcServerManager::removeRemote(const std::string &name, const std::string &spec)
 {
-    NamedService *old = _rpcsrvmap.lookup(name);
-    if (old == NULL) {
+    const NamedService *old = _rpcsrvmap.lookup(name);
+    if (old == nullptr) {
         // was alright already, remove any reservation too
         _rpcsrvmap.removeReservation(name);
         return OkState(0, "already done");
     }
-    if (strcmp(old->getSpec(), spec) != 0) {
+    if (old->getSpec() != spec) {
         return OkState(1, "name registered, but with different spec");
     }
-    NamedService *td = _rpcsrvmap.remove(name);
-    LOG_ASSERT(td == old);
-    delete td;
+    std::unique_ptr<NamedService> td = _rpcsrvmap.remove(name);
+    LOG_ASSERT(td.get() == old);
     return OkState(0, "done");
 }
 
 OkState
-RpcServerManager::removeLocal(const char *name, const char *spec)
+RpcServerManager::removeLocal(const std::string & name, const std::string &spec)
 {
-    NamedService *td = _rpcsrvmap.lookup(name);
-    if (td == NULL) {
+    const NamedService *td = _rpcsrvmap.lookup(name);
+    if (td == nullptr) {
         // already removed, nop
         return OkState();
     }
 
-    RemoteSlobrok *partner = _exchanger.lookupPartner(name);
-    if (partner != NULL) {
+    const RemoteSlobrok *partner = _exchanger.lookupPartner(name);
+    if (partner != nullptr) {
         return OkState(13, "cannot unregister partner slobrok");
     }
 
-    ManagedRpcServer *rpcsrv = _rpcsrvmap.lookupManaged(name);
-    if (rpcsrv == NULL) {
+    const ManagedRpcServer *rpcsrv = _rpcsrvmap.lookupManaged(name);
+    if (rpcsrv == nullptr) {
         return OkState(13, "not a local rpcserver");
     }
 
-    if (strcmp(rpcsrv->getSpec(), spec) != 0) {
+    if (rpcsrv->getSpec() != spec) {
         // the client can probably ignore this "error"
         // or log it on level INFO?
         return OkState(1, "name registered, but with different spec");
     }
-    td = _rpcsrvmap.remove(name);
-    LOG_ASSERT(td == rpcsrv);
-    delete rpcsrv;
+    auto tdUP = _rpcsrvmap.remove(name);
+    LOG_ASSERT(tdUP.get() == rpcsrv);
     _exchanger.forwardRemove(name, spec);
     return OkState();
 }
 
 
 void
-RpcServerManager::addManaged(const char *name, const char *spec,
-                             RegRpcSrvCommand rdc)
+RpcServerManager::addManaged(const std::string &name, const std::string &spec, RegRpcSrvCommand rdc)
 {
-    ManagedRpcServer *rpcsrv = new ManagedRpcServer(name, spec, *this);
-    _rpcsrvmap.addNew(rpcsrv);
+    auto newRpcServer = std::make_unique<ManagedRpcServer>(name, spec, *this);
+    ManagedRpcServer & rpcsrv = *newRpcServer;
+    _rpcsrvmap.addNew(std::move(newRpcServer));
     for (size_t i = 0; i < _addManageds.size(); i++) {
-        if (_addManageds[i].rpcsrv == NULL) {
-            _addManageds[i].rpcsrv = rpcsrv;
-            _addManageds[i].handler = rdc;
-            rpcsrv->healthCheck();
+        if (_addManageds[i].rpcsrv == nullptr) {
+            _addManageds[i].rpcsrv = &rpcsrv;
+            _addManageds[i].handler = std::move(rdc);
+            rpcsrv.healthCheck();
             return;
         }
     }
-    MRSandRRSC pair(rpcsrv, rdc);
-    _addManageds.push_back(pair);
-    rpcsrv->healthCheck();
+    _addManageds.emplace_back(&rpcsrv, std::move(rdc));
+    rpcsrv.healthCheck();
     return;
 }
 
 
 
 bool
-RpcServerManager::alreadyManaged(const char *name, const char *spec)
+RpcServerManager::alreadyManaged(const std::string &name, const std::string &spec)
 {
-    ManagedRpcServer *rpcsrv = _rpcsrvmap.lookupManaged(name);
-    if (rpcsrv != NULL) {
-        if (strcmp(rpcsrv->getSpec(), spec) == 0) {
+    const ManagedRpcServer *rpcsrv = _rpcsrvmap.lookupManaged(name);
+    if (rpcsrv != nullptr) {
+        if (rpcsrv->getSpec() == spec) {
             return true;
         }
     }
@@ -294,11 +282,8 @@ RpcServerManager::~RpcServerManager()
 void
 RpcServerManager::PerformTask()
 {
-    std::vector<ManagedRpcServer *> dl;
-    std::swap(dl, _deleteList);
-    for (uint32_t i = 0; i < dl.size(); ++i) {
-        delete dl[i];
-    }
+    std::vector<std::unique_ptr<ManagedRpcServer>> deleteAfterSwap;
+    std::swap(deleteAfterSwap, _deleteList);
 }
 
 
@@ -307,12 +292,12 @@ RpcServerManager::notifyFailedRpcSrv(ManagedRpcServer *rpcsrv, std::string errms
 {
     _env.countFailedHeartbeat();
     bool logged = false;
-    NamedService *old = _rpcsrvmap.lookup(rpcsrv->getName());
+    const NamedService *old = _rpcsrvmap.lookup(rpcsrv->getName());
     if (old == rpcsrv) {
-        old = _rpcsrvmap.remove(rpcsrv->getName());
+        old = _rpcsrvmap.remove(rpcsrv->getName()).release();
         LOG_ASSERT(old == rpcsrv);
         LOG(info, "managed server %s at %s failed: %s",
-            rpcsrv->getName(), rpcsrv->getSpec(), errmsg.c_str());
+            rpcsrv->getName().c_str(), rpcsrv->getSpec().c_str(), errmsg.c_str());
         logged = true;
     }
     _exchanger.forwardRemove(rpcsrv->getName(), rpcsrv->getSpec());
@@ -322,15 +307,15 @@ RpcServerManager::notifyFailedRpcSrv(ManagedRpcServer *rpcsrv, std::string errms
                 .doneHandler(OkState(13, "failed check using listNames callback"));
             _addManageds[i].rpcsrv = 0;
             LOG(warning, "rpcserver %s at %s failed while trying to register",
-                rpcsrv->getName(), rpcsrv->getSpec());
+                rpcsrv->getName().c_str(), rpcsrv->getSpec().c_str());
             logged = true;
         }
     }
     if (!logged) {
         LOG(warning, "unmanaged server %s at %s failed: %s",
-            rpcsrv->getName(), rpcsrv->getSpec(), errmsg.c_str());
+            rpcsrv->getName().c_str(), rpcsrv->getSpec().c_str(), errmsg.c_str());
     }
-    _deleteList.push_back(rpcsrv);
+    _deleteList.push_back(std::unique_ptr<ManagedRpcServer>(rpcsrv));
     ScheduleNow();
 }
 
diff --git a/slobrok/src/vespa/slobrok/server/rpc_server_manager.h b/slobrok/src/vespa/slobrok/server/rpc_server_manager.h
index a01e1592690..70ca10e480d 100644
--- a/slobrok/src/vespa/slobrok/server/rpc_server_manager.h
+++ b/slobrok/src/vespa/slobrok/server/rpc_server_manager.h
@@ -7,6 +7,7 @@
 #include "named_service.h"
 #include <vespa/fnet/task.h>
 #include <vector>
+#include <memory>
 
 namespace slobrok {
 
@@ -39,60 +40,30 @@ private:
         ManagedRpcServer *rpcsrv;
         RegRpcSrvCommand      handler;
         MRSandRRSC(ManagedRpcServer *d, RegRpcSrvCommand h)
-            : rpcsrv(d), handler(h) {}
-
-        MRSandRRSC(const MRSandRRSC &rhs)
-            : rpcsrv(rhs.rpcsrv),
-              handler(rhs.handler)
-        {
-        }
-
-        MRSandRRSC& operator=(const MRSandRRSC &rhs)
-        {
-            rpcsrv = rhs.rpcsrv;
-            handler = rhs.handler;
-            return *this;
-        }
+            : rpcsrv(d), handler(std::move(h)) {}
     };
     std::vector<MRSandRRSC>         _addManageds;
-    std::vector<ManagedRpcServer *> _deleteList;
-
-    RpcServerManager(const RpcServerManager &);            // Not used
-    RpcServerManager &operator=(const RpcServerManager &); // Not used
-
+    std::vector<std::unique_ptr<ManagedRpcServer>> _deleteList;
 public:
-    OkState checkPartner(const char *remslobrok);
-
-    OkState addPeer(const char *remsbname,
-                    const char *remsbspec);
-    OkState removePeer(const char *remsbname,
-                       const char *remsbspec);
+    OkState checkPartner(const std::string & remslobrok);
 
-    OkState addLocal(const char *name,
-                     const char *spec,
-                     FRT_RPCRequest *req);
-    OkState addRemote(const char *name,
-                      const char *spec);
+    OkState addPeer(const std::string & remsbname, const std::string & remsbspec);
+    OkState removePeer(const std::string & remsbname, const std::string &  remsbspec);
+    OkState addRemote(const std::string & name, const std::string & spec);
 
-    OkState addRemReservation(const char *remslobrok,
-                              const char *name,
-                              const char *spec);
-    OkState addMyReservation(const char *name,
-                           const char *spec);
+    OkState addRemReservation(const std::string & remslobrok, const std::string & name, const std::string & spec);
+    OkState addMyReservation(const std::string & name, const std::string & spec);
 
-    bool alreadyManaged(const char *name,
-                        const char *spec);
-    void addManaged(const char *name,
-                    const char *spec,
-                    RegRpcSrvCommand rdc);
+    bool alreadyManaged(const std::string & name, const std::string & spec);
+    void addManaged(const std::string & name, const std::string & spec, RegRpcSrvCommand rdc);
 
     OkState remove(ManagedRpcServer *rpcsrv);
 
-    OkState removeLocal(const char *name, const char *spec);
-
-    OkState removeRemote(const char *name,
-                         const char *spec);
+    OkState removeLocal(const std::string & name, const std::string & spec);
+    OkState removeRemote(const std::string & name, const std::string & spec);
 
+    RpcServerManager(const RpcServerManager &) = delete;
+    RpcServerManager &operator=(const RpcServerManager &) = delete;
     RpcServerManager(SBEnv &sbenv);
     ~RpcServerManager();
 
diff --git a/slobrok/src/vespa/slobrok/server/rpc_server_map.cpp b/slobrok/src/vespa/slobrok/server/rpc_server_map.cpp
index 06c5698ec09..e19a91cd78d 100644
--- a/slobrok/src/vespa/slobrok/server/rpc_server_map.cpp
+++ b/slobrok/src/vespa/slobrok/server/rpc_server_map.cpp
@@ -12,33 +12,34 @@ namespace slobrok {
 
 //-----------------------------------------------------------------------------
 
-NamedService *
-RpcServerMap::lookup(const char *name) const
-{
-    NamedService *d = _myrpcsrv_map[name];
-    return d;
+ManagedRpcServer *
+RpcServerMap::lookupManaged(const std::string & name) const {
+    auto found = _myrpcsrv_map.find(name);
+    return (found == _myrpcsrv_map.end()) ? nullptr : found->second.get();
 }
 
+const NamedService *
+RpcServerMap::lookup(const std::string & name) const
+{
+    return lookupManaged(name);
+}
 
-NamedService *
-RpcServerMap::remove(const char *name)
+std::unique_ptr<NamedService>
+RpcServerMap::remove(const std::string & name)
 {
     _visible_map.remove(name);
-    NamedService *d = _myrpcsrv_map.remove(name);
-    return d;
+    auto service = std::move(_myrpcsrv_map[name]);
+    _myrpcsrv_map.erase(name);
+    return service;
 }
 
-
-
 std::vector<const NamedService *>
 RpcServerMap::lookupPattern(const char *pattern) const
 {
     std::vector<const NamedService *> retval;
-    for (HashMap<ManagedRpcServer *>::Iterator it = _myrpcsrv_map.iterator();
-         it.valid(); it.next())
-    {
-        if (match(it.key(), pattern)) {
-            retval.push_back(it.value());
+    for (const auto & entry : _myrpcsrv_map) {
+        if (match(entry.first.c_str(), pattern)) {
+            retval.push_back(entry.second.get());
         }
     }
     return retval;
@@ -50,10 +51,8 @@ RpcServerMap::allManaged() const
 {
     std::vector<const NamedService *> retval;
     // get list of all names in myrpcsrv_map
-    for (HashMap<ManagedRpcServer *>::Iterator it = _myrpcsrv_map.iterator();
-         it.valid(); it.next())
-    {
-        retval.push_back(it.value());
+    for (const auto & entry : _myrpcsrv_map) {
+        retval.push_back(entry.second.get());
     }
     return retval;
 }
@@ -62,104 +61,98 @@ RpcServerMap::allManaged() const
 void
 RpcServerMap::add(NamedService *rpcsrv)
 {
-    const char *name = rpcsrv->getName();
+    const std::string &name = rpcsrv->getName();
 
-    LOG_ASSERT(rpcsrv != NULL);
-    LOG_ASSERT(_myrpcsrv_map.isSet(name) == false);
+    LOG_ASSERT(rpcsrv != nullptr);
+    LOG_ASSERT(_myrpcsrv_map.find(name) == _myrpcsrv_map.end());
 
     removeReservation(name);
 
-    LOG_ASSERT(_visible_map.lookup(name) == NULL);
+    LOG_ASSERT(_visible_map.lookup(name) == nullptr);
     _visible_map.addNew(rpcsrv);
 }
 
 void
-RpcServerMap::addNew(ManagedRpcServer *rpcsrv)
+RpcServerMap::addNew(std::unique_ptr<ManagedRpcServer> rpcsrv)
 {
-    const char *name = rpcsrv->getName();
+    const std::string &name = rpcsrv->getName();
 
-    ManagedRpcServer  *oldman = _myrpcsrv_map.remove(name);
+    auto oldman = std::move(_myrpcsrv_map[name]);
+    _myrpcsrv_map.erase(name);
 
-    if (oldman != NULL) {
-        ReservedName *oldres = _reservations[name];
-        NamedService *oldvis = _visible_map.remove(name);
+    if (oldman) {
+        const ReservedName *oldres = _reservations[name].get();
+        const NamedService *oldvis = _visible_map.remove(name);
 
-        const char *spec = rpcsrv->getSpec();
-        const char *oldname = oldman->getName();
-        const char *oldspec = oldman->getSpec();
-        if (strcmp(spec, oldspec) != 0)  {
+        const std::string &spec = rpcsrv->getSpec();
+        const std::string &oldname = oldman->getName();
+        const std::string &oldspec = oldman->getSpec();
+        if (spec != oldspec)  {
             LOG(warning, "internal state problem: adding [%s at %s] but already had [%s at %s]",
-                name, spec, oldname, oldspec);
-            if (oldvis != oldman) {
-                const char *n = oldvis->getName();
-                const char *s = oldvis->getSpec();
-                LOG(warning, "BAD: different old visible: [%s at %s]", n, s);
+                name.c_str(), spec.c_str(), oldname.c_str(), oldspec.c_str());
+            if (oldvis != oldman.get()) {
+                const std::string &n = oldvis->getName();
+                const std::string &s = oldvis->getSpec();
+                LOG(warning, "BAD: different old visible: [%s at %s]", n.c_str(), s.c_str());
             }
-            if (oldres != NULL) {
-                const char *n = oldres->getName();
-                const char *s = oldres->getSpec();
-                LOG(warning, "old reservation: [%s at %s]", n, s);
+            if (oldres != nullptr) {
+                const std::string &n = oldres->getName();
+                const std::string &s = oldres->getSpec();
+                LOG(warning, "old reservation: [%s at %s]", n.c_str(), s.c_str());
             }
         }
-        delete oldman;
     }
-    add(rpcsrv);
-    _myrpcsrv_map.set(name, rpcsrv);
+    add(rpcsrv.get());
+    _myrpcsrv_map[name] = std::move(rpcsrv);
 }
 
 
 void
-RpcServerMap::addReservation(ReservedName *rpcsrv)
+RpcServerMap::addReservation(std::unique_ptr<ReservedName> rpcsrv)
 {
-    LOG_ASSERT(rpcsrv != NULL);
-    LOG_ASSERT(_myrpcsrv_map.isSet(rpcsrv->getName()) == false);
+    LOG_ASSERT(rpcsrv != nullptr);
+    LOG_ASSERT(_myrpcsrv_map.find(rpcsrv->getName()) == _myrpcsrv_map.end());
 
     // must not be reserved for something else already
     // this should have been checked already, so assert
     LOG_ASSERT(! conflictingReservation(rpcsrv->getName(), rpcsrv->getSpec()));
-    ReservedName *old = _reservations.set(rpcsrv->getName(), rpcsrv);
-    LOG_ASSERT(old == NULL
-               || strcmp(old->getSpec(), rpcsrv->getSpec()) == 0
+    auto old = std::move(_reservations[rpcsrv->getName()]);
+    LOG_ASSERT(!old
+               || old->getSpec() == rpcsrv->getSpec()
                || ! old->stillReserved());
-    delete old;
+    _reservations[rpcsrv->getName()] = std::move(rpcsrv);
 }
 
 
 /** check if there is a (different) registration for this name in progress */
 bool
-RpcServerMap::conflictingReservation(const char *name, const char *spec)
+RpcServerMap::conflictingReservation(const std::string &name, const std::string &spec)
 {
-    ReservedName *resv = _reservations[name];
-    return (resv != NULL &&
+    const ReservedName *resv = _reservations[name].get();
+    return (resv != nullptr &&
             resv->stillReserved() &&
-            strcmp(resv->getSpec(), spec) != 0);
+            resv->getSpec() !=  spec);
 }
 
+const ReservedName *
+RpcServerMap::getReservation(const std::string &name) const {
+    auto found = _reservations.find(name);
+    return (found == _reservations.end()) ? nullptr : found->second.get();
+}
 
-RpcServerMap::~RpcServerMap()
+RpcServerMap::RpcServerMap()
+    : _myrpcsrv_map(),
+      _reservations()
 {
-    // get list of names in rpcsrv_map
-    std::vector<const char *> names;
-    for (HashMap<ManagedRpcServer *>::Iterator it = _myrpcsrv_map.iterator();
-         it.valid(); it.next())
-    {
-        names.push_back(it.key());
-    }
-
-    for (uint32_t i = 0; i < names.size(); i++) {
-        NamedService *rpcsrv = _myrpcsrv_map.remove(names[i]);
-        LOG_ASSERT(rpcsrv != NULL);
-        delete rpcsrv;
-    }
-    LOG_ASSERT(_myrpcsrv_map.size() == 0);
 }
 
+RpcServerMap::~RpcServerMap() = default;
 
 bool
 RpcServerMap::match(const char *name, const char *pattern)
 {
-    LOG_ASSERT(name != NULL);
-    LOG_ASSERT(pattern != NULL);
+    LOG_ASSERT(name != nullptr);
+    LOG_ASSERT(pattern != nullptr);
     while (*pattern != '\0') {
         if (*name == *pattern) {
             ++name;
@@ -177,10 +170,9 @@ RpcServerMap::match(const char *name, const char *pattern)
 }
 
 void
-RpcServerMap::removeReservation(const char *name)
+RpcServerMap::removeReservation(const std::string & name)
 {
-    delete _reservations.remove(name);
+    _reservations.erase(name);
 }
 
-
 } // namespace slobrok
diff --git a/slobrok/src/vespa/slobrok/server/rpc_server_map.h b/slobrok/src/vespa/slobrok/server/rpc_server_map.h
index f25b9989378..2c69c1b8cde 100644
--- a/slobrok/src/vespa/slobrok/server/rpc_server_map.h
+++ b/slobrok/src/vespa/slobrok/server/rpc_server_map.h
@@ -7,7 +7,6 @@ namespace slobrok {
 
 class NamedService;
 class ManagedRpcServer;
-class RemoteRpcServer;
 class ReservedName;
 
 /**
@@ -19,22 +18,17 @@ class ReservedName;
  * three seperate hashmaps.
  **/
 
-using vespalib::HashMap;
-
 class RpcServerMap
 {
 private:
-    VisibleMap                   _visible_map;
-
-    HashMap<ManagedRpcServer *>  _myrpcsrv_map;
-
-    HashMap<ReservedName *> _reservations;
+    using ManagedRpcServerMap = std::unordered_map<std::string, std::unique_ptr<ManagedRpcServer>>;
+    using ReservedNameMap = std::unordered_map<std::string, std::unique_ptr<ReservedName>>;
+    VisibleMap           _visible_map;
+    ManagedRpcServerMap  _myrpcsrv_map;
+    ReservedNameMap      _reservations;
 
     static bool match(const char *name, const char *pattern);
 
-    RpcServerMap(const RpcServerMap &);            // Not used
-    RpcServerMap &operator=(const RpcServerMap &); // Not use
-
     void add(NamedService *rpcsrv);
 
 public:
@@ -42,31 +36,24 @@ public:
 
     VisibleMap& visibleMap() { return _visible_map; }
 
-    ManagedRpcServer *lookupManaged(const char *name) const {
-        return _myrpcsrv_map[name];
-    }
+    ManagedRpcServer *lookupManaged(const std::string & name) const;
 
-    NamedService *    lookup(const char *name) const;
+    const NamedService *    lookup(const std::string & name) const;
     RpcSrvlist        lookupPattern(const char *pattern) const;
-    RpcSrvlist        allVisible() const;
     RpcSrvlist        allManaged() const;
 
-    void              addNew(ManagedRpcServer *rpcsrv);
-    NamedService *    remove(const char *name);
+    void              addNew(std::unique_ptr<ManagedRpcServer> rpcsrv);
+    std::unique_ptr<NamedService> remove(const std::string & name);
 
-    void          addReservation(ReservedName *rpcsrv);
-    bool          conflictingReservation(const char *name, const char *spec);
+    void          addReservation(std::unique_ptr<ReservedName>rpcsrv);
+    bool          conflictingReservation(const std::string & name, const std::string &spec);
 
-    ReservedName *getReservation(const char *name) const {
-        return _reservations[name];
-    }
-    void removeReservation(const char *name);
+    const ReservedName *getReservation(const std::string & name) const;
+    void removeReservation(const std::string & name);
 
-    RpcServerMap()
-        : _myrpcsrv_map(NULL),
-          _reservations(NULL)
-    {
-    }
+    RpcServerMap(const RpcServerMap &) = delete;
+    RpcServerMap &operator=(const RpcServerMap &) = delete;
+    RpcServerMap();
     ~RpcServerMap();
 };
 
diff --git a/slobrok/src/vespa/slobrok/server/rpchooks.cpp b/slobrok/src/vespa/slobrok/server/rpchooks.cpp
index 82e30a309a1..460b060cb82 100644
--- a/slobrok/src/vespa/slobrok/server/rpchooks.cpp
+++ b/slobrok/src/vespa/slobrok/server/rpchooks.cpp
@@ -18,8 +18,6 @@ namespace slobrok {
 
 namespace {
 
-
-
 class MetricsReport : public FNET_Task
 {
     RPCHooks &_owner;
@@ -29,35 +27,29 @@ class MetricsReport : public FNET_Task
         Schedule(300.0);
     }
 public:
-    MetricsReport(FRT_Supervisor *orb,
-                  RPCHooks &owner)
+    MetricsReport(FRT_Supervisor *orb, RPCHooks &owner)
         :  FNET_Task(orb->GetScheduler()),
            _owner(owner)
     {
         Schedule(0.0);
     }
 
-    virtual ~MetricsReport() { Kill(); }
+    ~MetricsReport() override { Kill(); }
 };
 
 } // namespace <unnamed>
 
 //-----------------------------------------------------------------------------
 
-RPCHooks::RPCHooks(SBEnv &env,
-                   RpcServerMap& rpcsrvmap,
-                   RpcServerManager& rpcsrvman)
+RPCHooks::RPCHooks(SBEnv &env, RpcServerMap& rpcsrvmap, RpcServerManager& rpcsrvman)
     : _env(env), _rpcsrvmap(rpcsrvmap), _rpcsrvmanager(rpcsrvman),
       _cnts(Metrics::zero()),
-      _m_reporter(nullptr)
+      _m_reporter()
 {
 }
 
 
-RPCHooks::~RPCHooks()
-{
-    delete _m_reporter;
-}
+RPCHooks::~RPCHooks() = default;
 
 void
 RPCHooks::reportMetrics()
@@ -76,7 +68,7 @@ RPCHooks::reportMetrics()
 void
 RPCHooks::initRPC(FRT_Supervisor *supervisor)
 {
-    _m_reporter = new MetricsReport(supervisor, *this);
+    _m_reporter = std::make_unique<MetricsReport>(supervisor, *this);
 
     FRT_ReflectionBuilder rb(supervisor);
 
@@ -236,7 +228,7 @@ RPCHooks::rpc_listNamesServed(FRT_RPCRequest *req)
 {
     FRT_Values &dst = *req->GetReturn();
     FRT_StringValue *names = dst.AddStringArray(1);
-    dst.SetString(names, _env.mySpec());
+    dst.SetString(names, _env.mySpec().c_str());
     _cnts.otherReqs++;
     return;
 }
@@ -422,8 +414,8 @@ RPCHooks::rpc_lookupRpcServer(FRT_RPCRequest *req)
     FRT_StringValue *names = dst.AddStringArray(rpcsrvlist.size());
     FRT_StringValue *specs = dst.AddStringArray(rpcsrvlist.size());
     for (uint32_t i = 0; i < rpcsrvlist.size(); ++i) {
-        dst.SetString(&names[i], rpcsrvlist[i]->getName());
-        dst.SetString(&specs[i], rpcsrvlist[i]->getSpec());
+        dst.SetString(&names[i], rpcsrvlist[i]->getName().c_str());
+        dst.SetString(&specs[i], rpcsrvlist[i]->getSpec().c_str());
     }
     if (rpcsrvlist.size() < 1) {
         LOG(debug, "RPC: lookupRpcServers(%s) -> no match",
@@ -431,7 +423,7 @@ RPCHooks::rpc_lookupRpcServer(FRT_RPCRequest *req)
     } else {
         LOG(debug, "RPC: lookupRpcServers(%s) -> %u matches, first [%s,%s]",
             rpcserverPattern, (unsigned int)rpcsrvlist.size(),
-            rpcsrvlist[0]->getName(), rpcsrvlist[0]->getSpec());
+            rpcsrvlist[0]->getName().c_str(), rpcsrvlist[0]->getSpec().c_str());
     }
     return;
 }
@@ -446,15 +438,15 @@ RPCHooks::rpc_listManagedRpcServers(FRT_RPCRequest *req)
     FRT_StringValue *names = dst.AddStringArray(rpcsrvlist.size());
     FRT_StringValue *specs = dst.AddStringArray(rpcsrvlist.size());
     for (uint32_t i = 0; i < rpcsrvlist.size(); ++i) {
-        dst.SetString(&names[i], rpcsrvlist[i]->getName());
-        dst.SetString(&specs[i], rpcsrvlist[i]->getSpec());
+        dst.SetString(&names[i], rpcsrvlist[i]->getName().c_str());
+        dst.SetString(&specs[i], rpcsrvlist[i]->getSpec().c_str());
     }
     if (rpcsrvlist.size() < 1) {
         LOG(debug, "RPC: listManagedRpcServers() -> 0 managed");
     } else {
         LOG(debug, "RPC: listManagedRpcServers() -> %u managed, first [%s,%s]",
             (unsigned int)rpcsrvlist.size(),
-            rpcsrvlist[0]->getName(), rpcsrvlist[0]->getSpec());
+            rpcsrvlist[0]->getName().c_str(), rpcsrvlist[0]->getSpec().c_str());
     }
     return;
 }
@@ -466,14 +458,14 @@ RPCHooks::rpc_lookupManaged(FRT_RPCRequest *req)
     FRT_Values &args = *req->GetParams();
     const char *name = args[0]._string._str;
     LOG(debug, "RPC: lookupManaged(%s)", name);
-    ManagedRpcServer *found = _rpcsrvmap.lookupManaged(name);
+    const ManagedRpcServer *found = _rpcsrvmap.lookupManaged(name);
 
     if (found == nullptr) {
         req->SetError(FRTE_RPC_METHOD_FAILED, "Not found");
     } else {
         FRT_Values &dst = *req->GetReturn();
-        dst.AddString(found->getName());
-        dst.AddString(found->getSpec());
+        dst.AddString(found->getName().c_str());
+        dst.AddString(found->getSpec().c_str());
     }
     return;
 }
@@ -493,9 +485,9 @@ RPCHooks::rpc_listAllRpcServers(FRT_RPCRequest *req)
 
     int j = 0;
     for (uint32_t i = 0; i < mrpcsrvlist.size(); ++i, ++j) {
-        dst.SetString(&names[j], mrpcsrvlist[i]->getName());
-        dst.SetString(&specs[j], mrpcsrvlist[i]->getSpec());
-        dst.SetString(&owner[j], _env.mySpec());
+        dst.SetString(&names[j], mrpcsrvlist[i]->getName().c_str());
+        dst.SetString(&specs[j], mrpcsrvlist[i]->getSpec().c_str());
+        dst.SetString(&owner[j], _env.mySpec().c_str());
     }
 
     if (sz > 0) {
diff --git a/slobrok/src/vespa/slobrok/server/rpchooks.h b/slobrok/src/vespa/slobrok/server/rpchooks.h
index 1c1d6ebf411..2f7e55d8fce 100644
--- a/slobrok/src/vespa/slobrok/server/rpchooks.h
+++ b/slobrok/src/vespa/slobrok/server/rpchooks.h
@@ -2,6 +2,7 @@
 #pragma once
 
 #include <vespa/fnet/frt/invokable.h>
+#include <memory>
 
 class FNET_Task;
 class FRT_Supervisor;
@@ -41,17 +42,12 @@ private:
     RpcServerMap &_rpcsrvmap;
     RpcServerManager &_rpcsrvmanager;
 
-    RPCHooks(const RPCHooks &);            // Not used
-    RPCHooks &operator=(const RPCHooks &); // Not used
-
     Metrics _cnts;
-    FNET_Task *_m_reporter;
+    std::unique_ptr<FNET_Task> _m_reporter;
 
 public:
-    explicit RPCHooks(SBEnv &env,
-                      RpcServerMap& rpcsrvmap,
-                      RpcServerManager& rpcsrvman);
-    virtual ~RPCHooks();
+    RPCHooks(SBEnv &env, RpcServerMap& rpcsrvmap, RpcServerManager& rpcsrvman);
+    ~RPCHooks() override;
 
     void initRPC(FRT_Supervisor *supervisor);
     void reportMetrics();
diff --git a/slobrok/src/vespa/slobrok/server/rpcmirror.cpp b/slobrok/src/vespa/slobrok/server/rpcmirror.cpp
index af5139f043c..46d7f70288b 100644
--- a/slobrok/src/vespa/slobrok/server/rpcmirror.cpp
+++ b/slobrok/src/vespa/slobrok/server/rpcmirror.cpp
@@ -38,8 +38,8 @@ MirrorFetch::completeReq()
         FRT_StringValue *names  = dst.AddStringArray(sz);
         FRT_StringValue *specs  = dst.AddStringArray(sz);
         for (uint32_t i = 0; i < rpcsrvlist.size(); ++i) {
-            dst.SetString(&names[i],  rpcsrvlist[i]->getName());
-            dst.SetString(&specs[i],  rpcsrvlist[i]->getSpec());
+            dst.SetString(&names[i],  rpcsrvlist[i]->getName().c_str());
+            dst.SetString(&specs[i],  rpcsrvlist[i]->getSpec().c_str());
         }
         if (sz > 0) {
             LOG(debug, "mirrorFetch %p -> %u, last [%s,%s]",
@@ -145,8 +145,8 @@ IncrementalFetch::completeReq()
     FRT_StringValue *names  = dst.AddStringArray(sz);
     FRT_StringValue *specs  = dst.AddStringArray(sz);
     for (uint32_t i = 0; i < sz; ++i) {
-        dst.SetString(&names[i],  diff.updated[i]->getName());
-        dst.SetString(&specs[i],  diff.updated[i]->getSpec());
+        dst.SetString(&names[i],  diff.updated[i]->getName().c_str());
+        dst.SetString(&specs[i],  diff.updated[i]->getSpec().c_str());
     }
 
     dst.AddInt32(newgen.getAsInt());
diff --git a/slobrok/src/vespa/slobrok/server/sbenv.cpp b/slobrok/src/vespa/slobrok/server/sbenv.cpp
index 35af0daf24a..163113de7b9 100644
--- a/slobrok/src/vespa/slobrok/server/sbenv.cpp
+++ b/slobrok/src/vespa/slobrok/server/sbenv.cpp
@@ -212,20 +212,18 @@ SBEnv::setup(const std::vector<std::string> &cfg)
         std::string slobrok = cfg[i];
         discard(oldList, slobrok);
         if (slobrok != mySpec()) {
-            OkState res = _rpcsrvmanager.addPeer(slobrok.c_str(), slobrok.c_str());
+            OkState res = _rpcsrvmanager.addPeer(slobrok, slobrok.c_str());
             if (!res.ok()) {
-                LOG(warning, "could not add peer %s: %s", slobrok.c_str(),
-                    res.errorMsg.c_str());
+                LOG(warning, "could not add peer %s: %s", slobrok.c_str(), res.errorMsg.c_str());
             } else {
                 LOG(config, "added peer %s", slobrok.c_str());
             }
         }
     }
     for (uint32_t i = 0; i < oldList.size(); ++i) {
-        OkState res = _rpcsrvmanager.removePeer(oldList[i].c_str(), oldList[i].c_str());
+        OkState res = _rpcsrvmanager.removePeer(oldList[i], oldList[i].c_str());
         if (!res.ok()) {
-            LOG(warning, "could not remove peer %s: %s", oldList[i].c_str(),
-                res.errorMsg.c_str());
+            LOG(warning, "could not remove peer %s: %s", oldList[i].c_str(), res.errorMsg.c_str());
         } else {
             LOG(config, "removed peer %s", oldList[i].c_str());
         }
@@ -252,7 +250,7 @@ SBEnv::addPeer(const std::string &name, const std::string &spec)
                      spec.c_str(), peers.c_str());
         return OkState(FRTE_RPC_METHOD_FAILED, "configured partner list does not contain peer. configured peers = " + peers);
     }
-    return _rpcsrvmanager.addPeer(name.c_str(), spec.c_str());
+    return _rpcsrvmanager.addPeer(name, spec.c_str());
 }
 
 OkState
@@ -266,7 +264,7 @@ SBEnv::removePeer(const std::string &name, const std::string &spec)
             return OkState(FRTE_RPC_METHOD_FAILED, "configured partner list contains peer, cannot remove");
         }
     }
-    return _rpcsrvmanager.removePeer(name.c_str(), spec.c_str());
+    return _rpcsrvmanager.removePeer(name, spec.c_str());
 }
 
 } // namespace slobrok
diff --git a/slobrok/src/vespa/slobrok/server/sbenv.h b/slobrok/src/vespa/slobrok/server/sbenv.h
index 8c897c9c999..223a8b7e9ee 100644
--- a/slobrok/src/vespa/slobrok/server/sbenv.h
+++ b/slobrok/src/vespa/slobrok/server/sbenv.h
@@ -73,7 +73,7 @@ public:
     ExchangeManager          _exchanger;
     RpcServerMap             _rpcsrvmap;
 
-    const char *mySpec() const { return _me->getSpec(); }
+    const std::string & mySpec() const { return _me->getSpec(); }
 
     bool isSuspended() const { return false; }
     bool isShuttingDown() const { return _shuttingDown; }
diff --git a/slobrok/src/vespa/slobrok/server/selfcheck.cpp b/slobrok/src/vespa/slobrok/server/selfcheck.cpp
index 7d1ca23957a..7fc639ec028 100644
--- a/slobrok/src/vespa/slobrok/server/selfcheck.cpp
+++ b/slobrok/src/vespa/slobrok/server/selfcheck.cpp
@@ -42,7 +42,7 @@ SelfCheck::PerformTask()
         const NamedService *r = mrpcsrvlist[i];
         ManagedRpcServer *m = _rpcsrvmap.lookupManaged(r->getName());
         LOG_ASSERT(r == m);
-        LOG(debug, "managed: %s -> %s", m->getName(), m->getSpec());
+        LOG(debug, "managed: %s -> %s", m->getName().c_str(), m->getSpec().c_str());
         m->healthCheck();
     }
     // reschedule in 1-2 seconds:
@@ -51,5 +51,4 @@ SelfCheck::PerformTask()
     Schedule(seconds);
 }
 
-
 } // namespace slobrok
diff --git a/slobrok/src/vespa/slobrok/server/visible_map.cpp b/slobrok/src/vespa/slobrok/server/visible_map.cpp
index d4487fd0884..d26bb49d874 100644
--- a/slobrok/src/vespa/slobrok/server/visible_map.cpp
+++ b/slobrok/src/vespa/slobrok/server/visible_map.cpp
@@ -13,23 +13,21 @@ VisibleMap::updated()
     _genCnt.add();
     WaitList waitList;
     std::swap(waitList, _waitList);
-    for (uint32_t i = 0; i < waitList.size(); ++i) {
-        waitList[i]->updated(*this);
+    for (auto & entry : waitList) {
+        entry->updated(*this);
     }
 }
 
-
 void
 VisibleMap::aborted()
 {
     WaitList waitList;
     std::swap(waitList, _waitList);
-    for (uint32_t i = 0; i < waitList.size(); ++i) {
-        waitList[i]->aborted(*this);
+    for (auto & entry : waitList) {
+        entry->aborted(*this);
     }
 }
 
-
 void
 VisibleMap::addUpdateListener(IUpdateListener *l)
 {
@@ -56,28 +54,19 @@ VisibleMap::removeUpdateListener(IUpdateListener *l)
 
 //-----------------------------------------------------------------------------
 
-std::vector<const NamedService *>
-VisibleMap::lookupPattern(const char *pattern) const
-{
-    std::vector<const NamedService *> retval;
-    for (iter_t it = _map.iterator(); it.valid(); it.next())
-    {
-        if (match(it.key(), pattern)) {
-            retval.push_back(it.value());
-        }
-    }
-    return retval;
+const NamedService *
+VisibleMap::lookup(const std::string &name) const {
+    auto found = _map.find(name);
+    return (found == _map.end()) ? nullptr : found->second;
 }
 
-
 std::vector<const NamedService *>
 VisibleMap::allVisible() const
 {
     std::vector<const NamedService *> retval;
     // get list of all names in myrpcsrvmap
-    for (iter_t it = _map.iterator(); it.valid(); it.next())
-    {
-        retval.push_back(it.value());
+    for (const auto & entry : _map) {
+        retval.push_back(entry.second);
     }
     return retval;
 }
@@ -85,22 +74,23 @@ VisibleMap::allVisible() const
 
 
 void
-VisibleMap::addNew(NamedService *rpcsrv)
+VisibleMap::addNew(const NamedService *rpcsrv)
 {
-    LOG_ASSERT(rpcsrv != NULL);
-    LOG_ASSERT(_map.isSet(rpcsrv->getName()) == false);
-    _map.set(rpcsrv->getName(), rpcsrv);
+    LOG_ASSERT(rpcsrv != nullptr);
+    LOG_ASSERT(_map.find(rpcsrv->getName()) == _map.end());
+    _map[rpcsrv->getName()] = rpcsrv;
 
     _history.add(rpcsrv->getName(), _genCnt);
     updated();
 }
 
 
-NamedService *
-VisibleMap::remove(const char *name) {
+const NamedService *
+VisibleMap::remove(const std::string &name) {
 
-    NamedService *d = _map.remove(name);
-    if (d != NULL) {
+    const NamedService *d = _map[name];
+    _map.erase(name);
+    if (d != nullptr) {
         _history.add(name, _genCnt);
         updated();
     }
@@ -108,14 +98,13 @@ VisibleMap::remove(const char *name) {
 }
 
 
-NamedService *
-VisibleMap::update(NamedService *rpcsrv) {
-    LOG_ASSERT(rpcsrv != NULL);
-
-    NamedService *d = _map.remove(rpcsrv->getName());
-    LOG_ASSERT(d != NULL);
+const NamedService *
+VisibleMap::update(const NamedService *rpcsrv) {
+    LOG_ASSERT(rpcsrv != nullptr);
 
-    _map.set(rpcsrv->getName(), rpcsrv);
+    const NamedService *d = rpcsrv;
+    std::swap(d, _map[rpcsrv->getName()]);
+    LOG_ASSERT(d != nullptr);
 
     _history.add(rpcsrv->getName(), _genCnt);
     updated();
@@ -128,13 +117,11 @@ VisibleMap::history(const vespalib::GenCnt& gen) const
 {
     MapDiff retval;
     std::set<std::string> names = _history.since(gen);
-    for (std::set<std::string>::iterator it = names.begin();
-         it != names.end();
-         ++it)
+    for (const auto & name : names)
     {
-        const NamedService *val = lookup(it->c_str());
-        if (val == NULL) {
-            retval.removed.push_back(*it);
+        const NamedService *val = lookup(name.c_str());
+        if (val == nullptr) {
+            retval.removed.push_back(name);
         } else {
             retval.updated.push_back(val);
         }
@@ -142,11 +129,11 @@ VisibleMap::history(const vespalib::GenCnt& gen) const
     return retval;
 }
 
-VisibleMap::MapDiff::MapDiff() {}
-VisibleMap::MapDiff::~MapDiff() {}
+VisibleMap::MapDiff::MapDiff() = default;
+VisibleMap::MapDiff::~MapDiff() = default;
 
 VisibleMap::VisibleMap()
-    : _map(NULL),
+    : _map(),
       _waitList(),
       _genCnt(1)
 {
@@ -160,8 +147,8 @@ VisibleMap::~VisibleMap()
 bool
 VisibleMap::match(const char *name, const char *pattern)
 {
-    LOG_ASSERT(name != NULL);
-    LOG_ASSERT(pattern != NULL);
+    LOG_ASSERT(name != nullptr);
+    LOG_ASSERT(pattern != nullptr);
     while (*pattern != '\0') {
         if (*name == *pattern) {
             ++name;
diff --git a/slobrok/src/vespa/slobrok/server/visible_map.h b/slobrok/src/vespa/slobrok/server/visible_map.h
index 9ad6c13872e..6ea2d5e2a46 100644
--- a/slobrok/src/vespa/slobrok/server/visible_map.h
+++ b/slobrok/src/vespa/slobrok/server/visible_map.h
@@ -3,7 +3,9 @@
 
 #include "history.h"
 #include "named_service.h"
-#include <vespa/vespalib/util/hashmap.h>
+#include <unordered_map>
+#include <string>
+#include <memory>
 
 namespace slobrok {
 
@@ -13,9 +15,6 @@ namespace slobrok {
  *        name->spec mappings visible to the world
  **/
 
-using vespalib::HashMap;
-
-
 class VisibleMap
 {
 public:
@@ -46,19 +45,16 @@ public:
     };
 
 private:
-    HashMap<NamedService *> _map;
-    typedef HashMap<NamedService *>::Iterator iter_t;
+    using Map = std::unordered_map<std::string, const NamedService *>;
+    using WaitList = std::vector<IUpdateListener *>;
 
-    typedef std::vector<IUpdateListener *> WaitList;
+    Map              _map;
     WaitList         _waitList;
     vespalib::GenCnt _genCnt;
     History          _history;
 
     static bool match(const char *name, const char *pattern);
 
-    VisibleMap(const VisibleMap &);            // Not used
-    VisibleMap &operator=(const VisibleMap &); // Not use
-
     void updated();
     void aborted();
 
@@ -66,12 +62,11 @@ public:
     void addUpdateListener(IUpdateListener *l);
     void removeUpdateListener(IUpdateListener *l);
 
-    void       addNew(NamedService *rpcsrv);
-    NamedService *remove(const char *name);
-    NamedService *update(NamedService *rpcsrv);
+    void       addNew(const NamedService *rpcsrv);
+    const NamedService *remove(const std::string &name);
+    const NamedService *update(const NamedService *rpcsrv);
 
-    NamedService *lookup(const char *name) const { return _map[name]; }
-    RpcSrvlist lookupPattern(const char *pattern) const;
+    const NamedService *lookup(const std::string &name) const;
     RpcSrvlist allVisible() const;
 
     const vespalib::GenCnt& genCnt() { return _genCnt; }
@@ -80,6 +75,8 @@ public:
 
     MapDiff history(const vespalib::GenCnt& gen) const;
 
+    VisibleMap(const VisibleMap &) = delete;
+    VisibleMap &operator=(const VisibleMap &) = delete;
     VisibleMap();
     ~VisibleMap();
 };