Fix indent.

1 files changed, 146 insertions, 146 deletions

diff --git a/searchcore/src/vespa/searchcore/proton/matching/sessionmanager.cpp b/searchcore/src/vespa/searchcore/proton/matching/sessionmanager.cpp
index 5ac5cf3488e..b6c6c798506 100644
--- a/searchcore/src/vespa/searchcore/proton/matching/sessionmanager.cpp
+++ b/searchcore/src/vespa/searchcore/proton/matching/sessionmanager.cpp
@@ -13,159 +13,159 @@ using search::grouping::GroupingSession;
 
 namespace proton::matching {
 
-    namespace {
-        using Stats = SessionManager::Stats;
-        struct SessionCacheBase {
-        protected:
-            Stats _stats;
-            vespalib::Lock _lock;
-
-            void entryDropped(const SessionId &id);
-            ~SessionCacheBase() {}
-        };
-
-        template <typename T>
-        struct SessionCache : SessionCacheBase {
-            typedef typename T::UP EntryUP;
-            vespalib::lrucache_map<vespalib::LruParam<SessionId, EntryUP> > _cache;
-
-            SessionCache(uint32_t max_size) : _cache(max_size) {}
-
-            void insert(EntryUP session) {
-                vespalib::LockGuard guard(_lock);
-                const SessionId &id(session->getSessionId());
-                if (_cache.size() >= _cache.capacity()) {
-                    entryDropped(id);
-                }
-                _cache.insert(id, std::move(session));
-                _stats.numInsert++;
-            }
-            EntryUP pick(const SessionId & id) {
-                vespalib::LockGuard guard(_lock);
-                EntryUP ret;
-                if (_cache.hasKey(id)) {
-                    _stats.numPick++;
-                    ret = std::move(_cache[id]);
-                    _cache.erase(id);
-                }
-                return ret;
-            }
-            void pruneTimedOutSessions(fastos::TimeStamp currentTime) {
-                std::vector<EntryUP> toDestruct = stealTimedOutSessions(currentTime);
-                toDestruct.clear();
-            }
-            std::vector<EntryUP> stealTimedOutSessions(fastos::TimeStamp currentTime) {
-                std::vector<EntryUP> toDestruct;
-                vespalib::LockGuard guard(_lock);
-                toDestruct.reserve(_cache.size());
-                for (auto it(_cache.begin()), mt(_cache.end()); it != mt;) {
-                    auto &session = *it;
-                    if (session->getTimeOfDoom() < currentTime) {
-                        toDestruct.push_back(std::move(session));
-                        it = _cache.erase(it);
-                        _stats.numTimedout++;
-                    } else {
-                        it++;
-                    }
-                }
-                return toDestruct;
-            }
-            Stats getStats() {
-                vespalib::LockGuard guard(_lock);
-                Stats stats = _stats;
-                stats.numCached = _cache.size();
-                _stats = Stats();
-                return stats;
-            }
-            bool empty() const {
-                vespalib::LockGuard guard(_lock);
-                return _cache.empty();
-            }
-        };
-
-        template <typename T>
-        struct SessionMap : SessionCacheBase {
-            typedef typename T::SP EntrySP;
-            vespalib::hash_map<SessionId, EntrySP> _map;
-
-            void insert(EntrySP session) {
-                vespalib::LockGuard guard(_lock);
-                const SessionId &id(session->getSessionId());
-                _map.insert(std::make_pair(id, session));
-                _stats.numInsert++;
-            }
-            EntrySP pick(const SessionId & id) {
-                vespalib::LockGuard guard(_lock);
-                auto it = _map.find(id);
-                if (it != _map.end()) {
-                    _stats.numPick++;
-                    return it->second;
-                }
-                return EntrySP();
-            }
-            void pruneTimedOutSessions(fastos::TimeStamp currentTime) {
-                std::vector<EntrySP> toDestruct = stealTimedOutSessions(currentTime);
-                toDestruct.clear();
-            }
-            std::vector<EntrySP> stealTimedOutSessions(fastos::TimeStamp currentTime) {
-                std::vector<EntrySP> toDestruct;
-                std::vector<SessionId> keys;
-                vespalib::LockGuard guard(_lock);
-                keys.reserve(_map.size());
-                toDestruct.reserve(_map.size());
-                for (auto & it : _map) {
-                    EntrySP &session = it.second;
-                    if (session->getTimeOfDoom() < currentTime) {
-                        keys.push_back(it.first);
-                        toDestruct.push_back(EntrySP());
-                        toDestruct.back().swap(session);
-                    }
-                }
-                for (auto key : keys) {
-                    _map.erase(key);
-                    _stats.numTimedout++;
-                }
-                return toDestruct;
-            }
-            Stats getStats() {
-                vespalib::LockGuard guard(_lock);
-                Stats stats = _stats;
-                stats.numCached = _map.size();
-                _stats = Stats();
-                return stats;
-            }
-            size_t size() const {
-                vespalib::LockGuard guard(_lock);
-                return _map.size();
-            }
-            bool empty() const {
-                vespalib::LockGuard guard(_lock);
-                return _map.empty();
+namespace {
+using Stats = SessionManager::Stats;
+struct SessionCacheBase {
+protected:
+    Stats _stats;
+    vespalib::Lock _lock;
+
+    void entryDropped(const SessionId &id);
+    ~SessionCacheBase() {}
+};
+
+template <typename T>
+struct SessionCache : SessionCacheBase {
+    typedef typename T::UP EntryUP;
+    vespalib::lrucache_map<vespalib::LruParam<SessionId, EntryUP> > _cache;
+
+    SessionCache(uint32_t max_size) : _cache(max_size) {}
+
+    void insert(EntryUP session) {
+        vespalib::LockGuard guard(_lock);
+        const SessionId &id(session->getSessionId());
+        if (_cache.size() >= _cache.capacity()) {
+            entryDropped(id);
+        }
+        _cache.insert(id, std::move(session));
+        _stats.numInsert++;
+    }
+    EntryUP pick(const SessionId & id) {
+        vespalib::LockGuard guard(_lock);
+        EntryUP ret;
+        if (_cache.hasKey(id)) {
+            _stats.numPick++;
+            ret = std::move(_cache[id]);
+            _cache.erase(id);
+        }
+        return ret;
+    }
+    void pruneTimedOutSessions(fastos::TimeStamp currentTime) {
+        std::vector<EntryUP> toDestruct = stealTimedOutSessions(currentTime);
+        toDestruct.clear();
+    }
+    std::vector<EntryUP> stealTimedOutSessions(fastos::TimeStamp currentTime) {
+        std::vector<EntryUP> toDestruct;
+        vespalib::LockGuard guard(_lock);
+        toDestruct.reserve(_cache.size());
+        for (auto it(_cache.begin()), mt(_cache.end()); it != mt;) {
+            auto &session = *it;
+            if (session->getTimeOfDoom() < currentTime) {
+                toDestruct.push_back(std::move(session));
+                it = _cache.erase(it);
+                _stats.numTimedout++;
+            } else {
+                it++;
             }
-            template <typename F>
-            void each(F f) const {
-                vespalib::LockGuard guard(_lock);
-                for (const auto &entry: _map) {
-                    f(*entry.second);
-                }
+        }
+        return toDestruct;
+    }
+    Stats getStats() {
+        vespalib::LockGuard guard(_lock);
+        Stats stats = _stats;
+        stats.numCached = _cache.size();
+        _stats = Stats();
+        return stats;
+    }
+    bool empty() const {
+        vespalib::LockGuard guard(_lock);
+        return _cache.empty();
+    }
+};
+
+template <typename T>
+struct SessionMap : SessionCacheBase {
+    typedef typename T::SP EntrySP;
+    vespalib::hash_map<SessionId, EntrySP> _map;
+
+    void insert(EntrySP session) {
+        vespalib::LockGuard guard(_lock);
+        const SessionId &id(session->getSessionId());
+        _map.insert(std::make_pair(id, session));
+        _stats.numInsert++;
+    }
+    EntrySP pick(const SessionId & id) {
+        vespalib::LockGuard guard(_lock);
+        auto it = _map.find(id);
+        if (it != _map.end()) {
+            _stats.numPick++;
+            return it->second;
+        }
+        return EntrySP();
+    }
+    void pruneTimedOutSessions(fastos::TimeStamp currentTime) {
+        std::vector<EntrySP> toDestruct = stealTimedOutSessions(currentTime);
+        toDestruct.clear();
+    }
+    std::vector<EntrySP> stealTimedOutSessions(fastos::TimeStamp currentTime) {
+        std::vector<EntrySP> toDestruct;
+        std::vector<SessionId> keys;
+        vespalib::LockGuard guard(_lock);
+        keys.reserve(_map.size());
+        toDestruct.reserve(_map.size());
+        for (auto & it : _map) {
+            EntrySP &session = it.second;
+            if (session->getTimeOfDoom() < currentTime) {
+                keys.push_back(it.first);
+                toDestruct.push_back(EntrySP());
+                toDestruct.back().swap(session);
             }
-        };
-
-        void SessionCacheBase::entryDropped(const SessionId &id) {
-            LOG(debug, "Session cache is full, dropping entry to fit session '%s'", id.c_str());
-            _stats.numDropped++;
         }
-
+        for (auto key : keys) {
+            _map.erase(key);
+            _stats.numTimedout++;
+        }
+        return toDestruct;
     }
+    Stats getStats() {
+        vespalib::LockGuard guard(_lock);
+        Stats stats = _stats;
+        stats.numCached = _map.size();
+        _stats = Stats();
+        return stats;
+    }
+    size_t size() const {
+        vespalib::LockGuard guard(_lock);
+        return _map.size();
+    }
+    bool empty() const {
+        vespalib::LockGuard guard(_lock);
+        return _map.empty();
+    }
+    template <typename F>
+    void each(F f) const {
+        vespalib::LockGuard guard(_lock);
+        for (const auto &entry: _map) {
+            f(*entry.second);
+        }
+    }
+};
+
+void SessionCacheBase::entryDropped(const SessionId &id) {
+    LOG(debug, "Session cache is full, dropping entry to fit session '%s'", id.c_str());
+    _stats.numDropped++;
+}
+
+}
 
-    struct GroupingSessionCache : public SessionCache<search::grouping::GroupingSession> {
-        using Parent = SessionCache<search::grouping::GroupingSession>;
-        using Parent::Parent;
-    };
+struct GroupingSessionCache : public SessionCache<search::grouping::GroupingSession> {
+    using Parent = SessionCache<search::grouping::GroupingSession>;
+    using Parent::Parent;
+};
 
-    struct SearchSessionCache : public SessionMap<SearchSession> {
+struct SearchSessionCache : public SessionMap<SearchSession> {
 
-    };
+};
 
 
 SessionManager::SessionManager(uint32_t maxSize)