Reduce use of default values in method calls

6 files changed, 63 insertions, 146 deletions

diff --git a/storage/src/tests/distributor/distributor_stripe_test_util.cpp b/storage/src/tests/distributor/distributor_stripe_test_util.cpp
index 7a64eda28ff..6ececa39583 100644
--- a/storage/src/tests/distributor/distributor_stripe_test_util.cpp
+++ b/storage/src/tests/distributor/distributor_stripe_test_util.cpp
@@ -40,34 +40,22 @@ DistributorStripeTestUtil::createLinks()
     _node = std::make_unique<TestDistributorApp>(_config.getConfigId());
     _metrics = std::make_shared<DistributorMetricSet>();
     _ideal_state_metrics = std::make_shared<IdealStateMetricSet>();
-    _stripe = std::make_unique<DistributorStripe>(_node->getComponentRegister(),
-                                                  *_metrics,
-                                                  *_ideal_state_metrics,
-                                                  _node->node_identity(),
-                                                  _messageSender,
-                                                  *this,
-                                                  _done_initializing);
+    _stripe = std::make_unique<DistributorStripe>(_node->getComponentRegister(), *_metrics, *_ideal_state_metrics,
+                                                  _node->node_identity(), _messageSender, *this, _done_initializing);
 }
 
 void
-DistributorStripeTestUtil::setup_stripe(int redundancy,
-                                        int nodeCount,
-                                        const std::string& systemState,
-                                        uint32_t earlyReturn,
-                                        bool requirePrimaryToBeWritten)
+DistributorStripeTestUtil::setup_stripe(int redundancy, int nodeCount, const std::string& systemState,
+                                        uint32_t earlyReturn, bool requirePrimaryToBeWritten)
 {
     setup_stripe(redundancy, nodeCount, lib::ClusterStateBundle(lib::ClusterState(systemState)), earlyReturn, requirePrimaryToBeWritten);
 }
 
 void
-DistributorStripeTestUtil::setup_stripe(int redundancy,
-                                        int node_count,
-                                        const lib::ClusterStateBundle& state,
-                                        uint32_t early_return,
-                                        bool require_primary_to_be_written)
+DistributorStripeTestUtil::setup_stripe(int redundancy, int node_count, const lib::ClusterStateBundle& state,
+                                        uint32_t early_return, bool require_primary_to_be_written)
 {
-    lib::Distribution::DistributionConfigBuilder config(
-            lib::Distribution::getDefaultDistributionConfig(redundancy, node_count).get());
+    lib::Distribution::DistributionConfigBuilder config(lib::Distribution::getDefaultDistributionConfig(redundancy, node_count).get());
     config.redundancy = redundancy;
     config.initialRedundancy = early_return;
     config.ensurePrimaryPersisted = require_primary_to_be_written;
@@ -93,8 +81,7 @@ DistributorStripeTestUtil::setup_stripe(int redundancy,
 void
 DistributorStripeTestUtil::set_redundancy(uint32_t redundancy)
 {
-    auto distribution = std::make_shared<lib::Distribution>(
-            lib::Distribution::getDefaultDistributionConfig(redundancy, 100));
+    auto distribution = std::make_shared<lib::Distribution>(lib::Distribution::getDefaultDistributionConfig(redundancy, 100));
     // Same rationale for not triggering a full distribution change as
     // in setup_stripe() above
     _node->getComponentRegister().setDistribution(distribution);
@@ -217,8 +204,7 @@ DistributorStripeTestUtil::getIdealStr(document::BucketId id, const lib::Cluster
     }
 
     std::vector<uint16_t> nodes;
-    getDistribution().getIdealNodes(
-            lib::NodeType::STORAGE, state, id, nodes);
+    getDistribution().getIdealNodes(lib::NodeType::STORAGE, state, id, nodes, "uim");
     std::sort(nodes.begin(), nodes.end());
     std::ostringstream ost;
     ost << id << ": " << dumpVector(nodes);
@@ -226,8 +212,7 @@ DistributorStripeTestUtil::getIdealStr(document::BucketId id, const lib::Cluster
 }
 
 void
-DistributorStripeTestUtil::addIdealNodes(const lib::ClusterState& state,
-                                         const document::BucketId& id)
+DistributorStripeTestUtil::addIdealNodes(const lib::ClusterState& state, const document::BucketId& id)
 {
     BucketDatabase::Entry entry = getBucket(id);
 
@@ -236,15 +221,11 @@ DistributorStripeTestUtil::addIdealNodes(const lib::ClusterState& state,
     }
 
     std::vector<uint16_t> res;
-    getDistribution().getIdealNodes(
-            lib::NodeType::STORAGE, state, id, res);
+    getDistribution().getIdealNodes(lib::NodeType::STORAGE, state, id, res, "uim");
 
     for (uint32_t i = 0; i < res.size(); ++i) {
-        if (state.getNodeState(lib::Node(lib::NodeType::STORAGE, res[i])).getState() !=
-            lib::State::MAINTENANCE)
-        {
-            entry->addNode(BucketCopy(0, res[i], api::BucketInfo(1,1,1)),
-                           toVector<uint16_t>(0));
+        if (state.getNodeState(lib::Node(lib::NodeType::STORAGE, res[i])).getState() != lib::State::MAINTENANCE) {
+            entry->addNode(BucketCopy(0, res[i], api::BucketInfo(1,1,1)), toVector<uint16_t>(0));
         }
     }
 
@@ -292,10 +273,7 @@ DistributorStripeTestUtil::addNodesToBucketDB(const document::Bucket& bucket, co
         }
 
         uint16_t idx = atoi(tok2[0].data());
-        BucketCopy node(
-                0,
-                idx,
-                info);
+        BucketCopy node(0, idx, info);
 
         // Allow user to manually override trusted and active.
         if (tok3.size() > flagsIdx && tok3[flagsIdx] == "t") {
@@ -309,44 +287,32 @@ DistributorStripeTestUtil::addNodesToBucketDB(const document::Bucket& bucket, co
 }
 
 void
-DistributorStripeTestUtil::addNodesToBucketDB(const document::BucketId& id,
-                                              const std::string& nodeStr)
-{
+DistributorStripeTestUtil::addNodesToBucketDB(const document::BucketId& id, const std::string& nodeStr) {
     addNodesToBucketDB(document::Bucket(makeBucketSpace(), id), nodeStr);
 }
 
 void
-DistributorStripeTestUtil::removeFromBucketDB(const document::BucketId& id)
-{
+DistributorStripeTestUtil::removeFromBucketDB(const document::BucketId& id) {
     getBucketDatabase().remove(id);
 }
 
 void
-DistributorStripeTestUtil::addIdealNodes(const document::BucketId& id)
-{
+DistributorStripeTestUtil::addIdealNodes(const document::BucketId& id) {
     // TODO STRIPE roundabout way of getting state bundle..!
     addIdealNodes(*operation_context().cluster_state_bundle().getBaselineClusterState(), id);
 }
 
 void
-DistributorStripeTestUtil::insertBucketInfo(document::BucketId id,
-                                            uint16_t node,
-                                            uint32_t checksum,
-                                            uint32_t count,
-                                            uint32_t size,
-                                            bool trusted,
-                                            bool active)
+DistributorStripeTestUtil::insertBucketInfo(document::BucketId id, uint16_t node, uint32_t checksum,
+                                            uint32_t count, uint32_t size, bool trusted, bool active)
 {
     api::BucketInfo info(checksum, count, size);
     insertBucketInfo(id, node, info, trusted, active);
 }
 
 void
-DistributorStripeTestUtil::insertBucketInfo(document::BucketId id,
-                                            uint16_t node,
-                                            const api::BucketInfo& info,
-                                            bool trusted,
-                                            bool active)
+DistributorStripeTestUtil::insertBucketInfo(document::BucketId id, uint16_t node, const api::BucketInfo& info,
+                                            bool trusted, bool active)
 {
     BucketDatabase::Entry entry = getBucketDatabase().get(id);
     if (!entry.valid()) {
@@ -358,9 +324,7 @@ DistributorStripeTestUtil::insertBucketInfo(document::BucketId id,
         info2.setActive();
     }
     BucketCopy copy(operation_context().generate_unique_timestamp(), node, info2);
-
     entry->addNode(copy.setTrusted(trusted), toVector<uint16_t>(0));
-
     getBucketDatabase().update(entry);
 }
 
@@ -371,9 +335,7 @@ DistributorStripeTestUtil::dumpBucket(const document::BucketId& bid)
 }
 
 void
-DistributorStripeTestUtil::sendReply(Operation& op,
-                                     int idx,
-                                     api::ReturnCode::Result result)
+DistributorStripeTestUtil::sendReply(Operation& op, int idx, api::ReturnCode::Result result)
 {
     if (idx == -1) {
         idx = _sender.commands().size() - 1;
@@ -387,20 +349,17 @@ DistributorStripeTestUtil::sendReply(Operation& op,
 }
 
 BucketDatabase::Entry
-DistributorStripeTestUtil::getBucket(const document::Bucket& bucket) const
-{
+DistributorStripeTestUtil::getBucket(const document::Bucket& bucket) const {
     return getBucketDatabase(bucket.getBucketSpace()).get(bucket.getBucketId());
 }
 
 BucketDatabase::Entry
-DistributorStripeTestUtil::getBucket(const document::BucketId& bId) const
-{
+DistributorStripeTestUtil::getBucket(const document::BucketId& bId) const {
     return getBucketDatabase().get(bId);
 }
 
 void
-DistributorStripeTestUtil::disableBucketActivationInConfig(bool disable)
-{
+DistributorStripeTestUtil::disableBucketActivationInConfig(bool disable) {
     ConfigBuilder builder;
     builder.disableBucketActivation = disable;
     configure_stripe(builder);
@@ -437,14 +396,12 @@ DistributorStripeTestUtil::doc_selection_parser() const {
 }
 
 DistributorMetricSet&
-DistributorStripeTestUtil::metrics()
-{
+DistributorStripeTestUtil::metrics() {
     return *_metrics;
 }
 
 bool
-DistributorStripeTestUtil::tick()
-{
+DistributorStripeTestUtil::tick() {
     return _stripe->tick();
 }
 
@@ -553,8 +510,7 @@ DistributorStripeTestUtil::getBucketSpaces() const
 void
 DistributorStripeTestUtil::enable_cluster_state(vespalib::stringref state)
 {
-    getBucketDBUpdater().simulate_cluster_state_bundle_activation(
-            lib::ClusterStateBundle(lib::ClusterState(state)));
+    getBucketDBUpdater().simulate_cluster_state_bundle_activation(lib::ClusterStateBundle(lib::ClusterState(state)));
 }
 
 void
diff --git a/storage/src/tests/distributor/top_level_bucket_db_updater_test.cpp b/storage/src/tests/distributor/top_level_bucket_db_updater_test.cpp
index 567e0a947da..7eb9dfe6269 100644
--- a/storage/src/tests/distributor/top_level_bucket_db_updater_test.cpp
+++ b/storage/src/tests/distributor/top_level_bucket_db_updater_test.cpp
@@ -65,12 +65,9 @@ public:
         close();
     }
 
-    std::shared_ptr<RequestBucketInfoReply> make_fake_bucket_reply(
-            const lib::ClusterState& state,
-            const RequestBucketInfoCommand& cmd,
-            int storageIndex,
-            uint32_t bucketCount,
-            uint32_t invalidBucketCount = 0)
+    std::shared_ptr<RequestBucketInfoReply>
+    make_fake_bucket_reply(const lib::ClusterState& state, const RequestBucketInfoCommand& cmd,
+                           int storageIndex, uint32_t bucketCount,uint32_t invalidBucketCount = 0)
     {
         auto sreply = std::make_shared<RequestBucketInfoReply>(cmd);
         sreply->setAddress(storage_address(storageIndex));
@@ -84,19 +81,14 @@ public:
             }
 
             std::vector<uint16_t> nodes;
-            distributor_bucket_space(bucket).getDistribution().getIdealNodes(
-                    lib::NodeType::STORAGE, state, bucket, nodes);
+            distributor_bucket_space(bucket).getDistribution().getIdealNodes(lib::NodeType::STORAGE, state, bucket, nodes, "uim");
 
             for (uint32_t j = 0; j < nodes.size(); ++j) {
                 if (nodes[j] == storageIndex) {
                     if (i >= bucketCount) {
-                        vec.push_back(api::RequestBucketInfoReply::Entry(
-                                document::BucketId(16, i),
-                                api::BucketInfo()));
+                        vec.emplace_back(document::BucketId(16, i), api::BucketInfo());
                     } else {
-                        vec.push_back(api::RequestBucketInfoReply::Entry(
-                                document::BucketId(16, i),
-                                api::BucketInfo(10,1,1)));
+                        vec.emplace_back(document::BucketId(16, i), api::BucketInfo(10,1,1));
                     }
                 }
             }
@@ -105,45 +97,34 @@ public:
         return sreply;
     }
 
-    void fake_bucket_reply(const lib::ClusterState &state,
-                           const api::StorageCommand &cmd,
-                           uint32_t bucket_count,
-                           uint32_t invalid_bucket_count = 0)
+    void fake_bucket_reply(const lib::ClusterState &state, const api::StorageCommand &cmd,
+                           uint32_t bucket_count, uint32_t invalid_bucket_count = 0)
     {
         ASSERT_EQ(cmd.getType(), MessageType::REQUESTBUCKETINFO);
         const api::StorageMessageAddress& address(*cmd.getAddress());
         bucket_db_updater().onRequestBucketInfoReply(
-                make_fake_bucket_reply(state,
-                                       dynamic_cast<const RequestBucketInfoCommand &>(cmd),
-                                       address.getIndex(),
-                                       bucket_count,
-                                       invalid_bucket_count));
+                make_fake_bucket_reply(state, dynamic_cast<const RequestBucketInfoCommand &>(cmd),
+                                       address.getIndex(), bucket_count, invalid_bucket_count));
     }
 
-    void fake_bucket_reply(const lib::ClusterState &state,
-                           const api::StorageCommand &cmd,
-                           uint32_t bucket_count,
+    void fake_bucket_reply(const lib::ClusterState &state, const api::StorageCommand &cmd, uint32_t bucket_count,
                            const std::function<void(api::RequestBucketInfoReply&)>& reply_decorator)
     {
         ASSERT_EQ(cmd.getType(), MessageType::REQUESTBUCKETINFO);
         const api::StorageMessageAddress& address(*cmd.getAddress());
-        auto reply = make_fake_bucket_reply(state,
-                                            dynamic_cast<const RequestBucketInfoCommand &>(cmd),
-                                            address.getIndex(),
-                                            bucket_count, 0);
+        auto reply = make_fake_bucket_reply(state, dynamic_cast<const RequestBucketInfoCommand &>(cmd),
+                                            address.getIndex(), bucket_count, 0);
         reply_decorator(*reply);
         bucket_db_updater().onRequestBucketInfoReply(reply);
     }
 
-    void send_fake_reply_for_single_bucket_request(
-            const api::RequestBucketInfoCommand& rbi)
+    void send_fake_reply_for_single_bucket_request(const api::RequestBucketInfoCommand& rbi)
     {
         ASSERT_EQ(size_t(1), rbi.getBuckets().size());
         const document::BucketId& bucket(rbi.getBuckets()[0]);
 
         auto reply = std::make_shared<api::RequestBucketInfoReply>(rbi);
-        reply->getBucketInfo().push_back(
-                api::RequestBucketInfoReply::Entry(bucket, api::BucketInfo(20, 10, 12, 50, 60, true, true)));
+        reply->getBucketInfo().emplace_back(bucket, api::BucketInfo(20, 10, 12, 50, 60, true, true));
         stripe_of_bucket(bucket).bucket_db_updater().onRequestBucketInfoReply(reply);
     }
 
@@ -154,15 +135,11 @@ public:
         }
 
         std::vector<uint16_t> nodes;
-        distributor_bucket_space(id).getDistribution().getIdealNodes(
-                lib::NodeType::STORAGE, state, document::BucketId(id), nodes);
+        distributor_bucket_space(id).getDistribution().getIdealNodes(lib::NodeType::STORAGE, state, document::BucketId(id), nodes, "uim");
 
         if (nodes.size() != entry->getNodeCount()) {
-            return vespalib::make_string("Bucket Id %s has %d nodes in "
-                                         "ideal state, but has only %d in DB",
-                                         id.toString().c_str(),
-                                         (int)nodes.size(),
-                                         (int)entry->getNodeCount());
+            return vespalib::make_string("Bucket Id %s has %d nodes in ideal state, but has only %d in DB",
+                                         id.toString().c_str(), (int)nodes.size(), (int)entry->getNodeCount());
         }
 
         for (uint32_t i = 0; i<nodes.size(); i++) {
@@ -175,10 +152,7 @@ public:
             }
 
             if (!found) {
-                return vespalib::make_string(
-                        "Bucket Id %s has no copy from node %d",
-                        id.toString().c_str(),
-                        nodes[i]);
+                return vespalib::make_string("Bucket Id %s has no copy from node %d", id.toString().c_str(), nodes[i]);
             }
         }
 
@@ -188,13 +162,11 @@ public:
     struct OrderByIncreasingNodeIndex {
         template <typename T>
         bool operator()(const T& lhs, const T& rhs) {
-            return (lhs->getAddress()->getIndex()
-                    < rhs->getAddress()->getIndex());
+            return (lhs->getAddress()->getIndex() < rhs->getAddress()->getIndex());
         }
     };
 
-    void sort_sent_messages_by_index(DistributorMessageSenderStub& sender,
-                                     size_t sortFromOffset = 0)
+    void sort_sent_messages_by_index(DistributorMessageSenderStub& sender, size_t sortFromOffset = 0)
     {
         std::sort(sender.commands().begin() + sortFromOffset,
                   sender.commands().end(),
diff --git a/storage/src/tests/distributor/top_level_distributor_test_util.cpp b/storage/src/tests/distributor/top_level_distributor_test_util.cpp
index 9677ea568e8..9859a6fb237 100644
--- a/storage/src/tests/distributor/top_level_distributor_test_util.cpp
+++ b/storage/src/tests/distributor/top_level_distributor_test_util.cpp
@@ -187,7 +187,7 @@ TopLevelDistributorTestUtil::get_ideal_str(document::BucketId id, const lib::Clu
         return id.toString();
     }
     std::vector<uint16_t> nodes;
-    _component->getDistribution()->getIdealNodes(lib::NodeType::STORAGE, state, id, nodes);
+    _component->getDistribution()->getIdealNodes(lib::NodeType::STORAGE, state, id, nodes, "uim");
     std::sort(nodes.begin(), nodes.end());
     std::ostringstream ost;
     ost << id << ": " << dumpVector(nodes);
@@ -205,14 +205,11 @@ TopLevelDistributorTestUtil::add_ideal_nodes(const lib::ClusterState& state, con
 
     std::vector<uint16_t> res;
     assert(_component.get());
-    _component->getDistribution()->getIdealNodes(lib::NodeType::STORAGE, state, id, res);
+    _component->getDistribution()->getIdealNodes(lib::NodeType::STORAGE, state, id, res, "uim");
 
     for (uint32_t i = 0; i < res.size(); ++i) {
-        if (state.getNodeState(lib::Node(lib::NodeType::STORAGE, res[i])).getState() !=
-            lib::State::MAINTENANCE)
-        {
-            entry->addNode(BucketCopy(0, res[i], api::BucketInfo(1,1,1)),
-                           toVector<uint16_t>(0));
+        if (state.getNodeState(lib::Node(lib::NodeType::STORAGE, res[i])).getState() != lib::State::MAINTENANCE) {
+            entry->addNode(BucketCopy(0, res[i], api::BucketInfo(1,1,1)), toVector<uint16_t>(0));
         }
     }
 
diff --git a/storage/src/vespa/storage/distributor/activecopy.cpp b/storage/src/vespa/storage/distributor/activecopy.cpp
index 57052c9c509..ea194e1be21 100644
--- a/storage/src/vespa/storage/distributor/activecopy.cpp
+++ b/storage/src/vespa/storage/distributor/activecopy.cpp
@@ -144,10 +144,9 @@ ActiveCopy::calculate(const std::vector<uint16_t>& idealState, const lib::Distri
     if (validNodesWithCopy.empty()) {
         return ActiveList();
     }
-    using IndexList = std::vector<uint16_t>;
-    std::vector<IndexList> groups;
+    std::vector<lib::Distribution::IndexList> groups;
     if (distribution.activePerGroup()) {
-        groups = distribution.splitNodesIntoLeafGroups(std::move(validNodesWithCopy));
+        groups = distribution.splitNodesIntoLeafGroups(validNodesWithCopy);
     } else {
         groups.push_back(std::move(validNodesWithCopy));
     }
diff --git a/storage/src/vespa/storage/storageutil/distributorstatecache.h b/storage/src/vespa/storage/storageutil/distributorstatecache.h
index 8c4d07e39bf..0652a980e3a 100644
--- a/storage/src/vespa/storage/storageutil/distributorstatecache.h
+++ b/storage/src/vespa/storage/storageutil/distributorstatecache.h
@@ -1,6 +1,7 @@
 // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 
 #pragma once
+
 #include <vespa/vdslib/state/clusterstate.h>
 #include <vespa/vdslib/distribution/distribution.h>
 
@@ -9,9 +10,7 @@ namespace storage {
 class DistributorStateCache
 {
 public:
-    DistributorStateCache(
-            const lib::Distribution& distr,
-            const lib::ClusterState& state)
+    DistributorStateCache(const lib::Distribution& distr, const lib::ClusterState& state)
         : _distribution(distr),
           _state(state),
           _distrBitMask(0xffffffffffffffffull),
@@ -22,8 +21,7 @@ public:
         _distrBitMask >>= (64 - state.getDistributionBitCount());
     }
 
-    uint16_t getOwner(const document::BucketId& bid,
-                      const char* upStates = "ui")
+    uint16_t getOwner(const document::BucketId& bid, const char* upStates = "ui")
     {
         uint64_t distributionBits = bid.getRawId() & _distrBitMask;
 
diff --git a/storage/src/vespa/storage/tools/getidealstate.cpp b/storage/src/vespa/storage/tools/getidealstate.cpp
index 8b120924aaa..9e80517f4f7 100644
--- a/storage/src/vespa/storage/tools/getidealstate.cpp
+++ b/storage/src/vespa/storage/tools/getidealstate.cpp
@@ -64,18 +64,13 @@ Options::Options(int argc, const char* const* argv)
 Options::~Options() {}
 
 
-void processBucket(const lib::Distribution& distribution,
-                   const lib::ClusterState& clusterState,
-                   const std::string& upStates,
-                   const document::BucketId& bucket)
+void processBucket(const lib::Distribution& distribution, const lib::ClusterState& clusterState,
+                   const std::string& upStates, const document::BucketId& bucket)
 {
     std::ostringstream ost;
-    std::vector<uint16_t> storageNodes(distribution.getIdealStorageNodes(
-                clusterState, bucket, upStates.c_str()));
-    uint16_t distributorNode(distribution.getIdealDistributorNode(
-                clusterState, bucket, upStates.c_str()));
-    ost << bucket << " distributor: " << distributorNode
-              << ", storage:";
+    std::vector<uint16_t> storageNodes(distribution.getIdealStorageNodes(clusterState, bucket, upStates.c_str()));
+    uint16_t distributorNode(distribution.getIdealDistributorNode(clusterState, bucket, upStates.c_str()));
+    ost << bucket << " distributor: " << distributorNode << ", storage:";
     for (uint32_t i=0; i<storageNodes.size(); ++i) {
         ost << " " << storageNodes[i];
     }