Unify code layout.

2 files changed, 30 insertions, 40 deletions

diff --git a/searchlib/src/vespa/searchlib/predicate/document_features_store.cpp b/searchlib/src/vespa/searchlib/predicate/document_features_store.cpp
index 6fb757fe0a6..b2cd65593fb 100644
--- a/searchlib/src/vespa/searchlib/predicate/document_features_store.cpp
+++ b/searchlib/src/vespa/searchlib/predicate/document_features_store.cpp
@@ -113,8 +113,7 @@ DocumentFeaturesStore::insert(uint64_t featureId, uint32_t docId) {
     if (_currDocId != docId) {
         auto docsItr = _docs.find(docId);
         if (docsItr == _docs.end()) {
-            docsItr =
-                _docs.insert(std::make_pair(docId, FeatureVector())).first;
+            docsItr = _docs.insert(std::make_pair(docId, FeatureVector())).first;
         }
         setCurrent(docId, &docsItr->second);
     }
diff --git a/searchlib/src/vespa/searchlib/predicate/predicate_tree_annotator.cpp b/searchlib/src/vespa/searchlib/predicate/predicate_tree_annotator.cpp
index 64752f83a20..6a7f092ccb4 100644
--- a/searchlib/src/vespa/searchlib/predicate/predicate_tree_annotator.cpp
+++ b/searchlib/src/vespa/searchlib/predicate/predicate_tree_annotator.cpp
@@ -25,13 +25,13 @@ class PredicateTreeAnnotatorImpl {
     uint32_t _left_weight;
     PredicateTreeAnnotations &_result;
     uint64_t _zStar_hash;
-    bool _negated;
-    bool _final_range_used;
+    bool     _negated;
+    bool     _final_range_used;
     const std::map<std::string, int> &_size_map;
     TreeCrumbs _crumbs;
-    int64_t _lower_bound;
-    int64_t _upper_bound;
-    uint16_t _interval_range;
+    int64_t    _lower_bound;
+    int64_t    _upper_bound;
+    uint16_t   _interval_range;
 
 
     uint32_t makeMarker(uint32_t begin, uint32_t end) {
@@ -54,12 +54,12 @@ public:
     void assignIntervalMarkers(const vespalib::slime::Inspector &in);
 };
 
-void PredicateTreeAnnotatorImpl::addZstarIntervalIfNegated(uint32_t cEnd) {
+void
+PredicateTreeAnnotatorImpl::addZstarIntervalIfNegated(uint32_t cEnd) {
     if (_negated) {
         auto it = _result.interval_map.find(_zStar_hash);
         if (it == _result.interval_map.end()) {
-            it = _result.interval_map.insert(make_pair(
-                            _zStar_hash, std::vector<Interval>())).first;
+            it = _result.interval_map.insert(make_pair(_zStar_hash, std::vector<Interval>())).first;
             _result.features.push_back(_zStar_hash);
         }
         auto &intervals = it->second;
@@ -71,10 +71,8 @@ void PredicateTreeAnnotatorImpl::addZstarIntervalIfNegated(uint32_t cEnd) {
     }
 }
 
-PredicateTreeAnnotatorImpl::PredicateTreeAnnotatorImpl(
-        const map<string, int> &size_map,
-        PredicateTreeAnnotations &result,
-        int64_t lower_bound, int64_t upper_bound, uint16_t interval_range)
+PredicateTreeAnnotatorImpl::PredicateTreeAnnotatorImpl(const map<string, int> &size_map, PredicateTreeAnnotations &result,
+                                                       int64_t lower_bound, int64_t upper_bound, uint16_t interval_range)
     : _begin(MIN_INTERVAL),
       _end(interval_range),
       _left_weight(0),
@@ -86,10 +84,12 @@ PredicateTreeAnnotatorImpl::PredicateTreeAnnotatorImpl(
       _crumbs(),
       _lower_bound(lower_bound),
       _upper_bound(upper_bound),
-      _interval_range(interval_range) {
+      _interval_range(interval_range)
+{
 }
 
-long getType(const Inspector &in, bool negated) {
+long
+getType(const Inspector &in, bool negated) {
     long type = in[Predicate::NODE_TYPE].asLong();
     if (negated) {
         if (type == Predicate::TYPE_CONJUNCTION) {
@@ -101,7 +101,8 @@ long getType(const Inspector &in, bool negated) {
     return type;
 }
 
-void PredicateTreeAnnotatorImpl::assignIntervalMarkers(const Inspector &in) {
+void
+PredicateTreeAnnotatorImpl::assignIntervalMarkers(const Inspector &in) {
     switch (getType(in, _negated)) {
     case Predicate::TYPE_CONJUNCTION: {
         int crumb_size = _crumbs.size();
@@ -162,12 +163,10 @@ void PredicateTreeAnnotatorImpl::assignIntervalMarkers(const Inspector &in) {
             label.resize(prefix_size);
             label.append(value.data, value.size);
             uint64_t hash = PredicateHash::hash64(label);
-            if (_result.interval_map.find(hash)
-                == _result.interval_map.end()) {
+            if (_result.interval_map.find(hash) == _result.interval_map.end()) {
                 _result.features.push_back(hash);
             }
-            _result.interval_map[hash].push_back(
-                    { makeMarker(_begin, _negated? cEnd : _end) });
+            _result.interval_map[hash].push_back({ makeMarker(_begin, _negated? cEnd : _end) });
         }
         addZstarIntervalIfNegated(cEnd);
         _left_weight += 1;
@@ -175,29 +174,21 @@ void PredicateTreeAnnotatorImpl::assignIntervalMarkers(const Inspector &in) {
     }
     case Predicate::TYPE_FEATURE_RANGE: {
         uint32_t cEnd = _negated? getCEnd() : 0;
-        for (size_t i = 0; i < in[Predicate::HASHED_PARTITIONS].children();
-             ++i) {
+        for (size_t i = 0; i < in[Predicate::HASHED_PARTITIONS].children(); ++i) {
             uint64_t hash = in[Predicate::HASHED_PARTITIONS][i].asLong();
-            _result.interval_map[hash].push_back(
-                    { makeMarker(_begin, _negated? cEnd : _end) });
+            _result.interval_map[hash].push_back({ makeMarker(_begin, _negated? cEnd : _end) });
         }
-        const Inspector& in_hashed_edges =
-            in[Predicate::HASHED_EDGE_PARTITIONS];
+        const Inspector& in_hashed_edges = in[Predicate::HASHED_EDGE_PARTITIONS];
         for (size_t i = 0; i < in_hashed_edges.children(); ++i){
             const Inspector& child = in_hashed_edges[i];
             uint64_t hash = child[Predicate::HASH].asLong();
             uint32_t payload = child[Predicate::PAYLOAD].asLong();
-            _result.bounds_map[hash].push_back(
-                    { makeMarker(_begin, _negated? cEnd : _end), payload });
+            _result.bounds_map[hash].push_back({ makeMarker(_begin, _negated? cEnd : _end), payload });
         }
-        uint32_t hash_count = in[Predicate::HASHED_PARTITIONS].children() +
-                              in_hashed_edges.children();
-        if (hash_count < 3) {  // three features takes more space than
-                               // one stored range.
-            for (size_t i = 0; i < in[Predicate::HASHED_PARTITIONS].children();
-                 ++i) {
-                _result.features.push_back(in[Predicate::HASHED_PARTITIONS][i]
-                                           .asLong());
+        uint32_t hash_count = in[Predicate::HASHED_PARTITIONS].children() + in_hashed_edges.children();
+        if (hash_count < 3) {  // three features takes more space than one stored range.
+            for (size_t i = 0; i < in[Predicate::HASHED_PARTITIONS].children(); ++i) {
+                _result.features.push_back(in[Predicate::HASHED_PARTITIONS][i].asLong());
             }
             for (size_t i = 0; i < in_hashed_edges.children(); ++i) {
                 _result.features.push_back(in_hashed_edges[i].asLong());
@@ -231,9 +222,9 @@ PredicateTreeAnnotations::PredicateTreeAnnotations(uint32_t mf, uint16_t ir)
 
 PredicateTreeAnnotations::~PredicateTreeAnnotations() = default;
 
-void PredicateTreeAnnotator::annotate(const Inspector &in,
-                                      PredicateTreeAnnotations &result,
-                                      int64_t lower, int64_t upper) {
+void
+PredicateTreeAnnotator::annotate(const Inspector &in, PredicateTreeAnnotations &result, int64_t lower, int64_t upper)
+{
     PredicateTreeAnalyzer analyzer(in);
     uint32_t min_feature = static_cast<uint32_t>(analyzer.getMinFeature());
     // Size is as interval range (tree size is lower bound for interval range)