1 files changed, 57 insertions, 65 deletions
diff --git a/third_party/nix/src/libutil/lru-cache.hh b/third_party/nix/src/libutil/lru-cache.hh
index 8b83f842c3..bf7263243c 100644
--- a/third_party/nix/src/libutil/lru-cache.hh
+++ b/third_party/nix/src/libutil/lru-cache.hh
@@ -1,92 +1,84 @@
 #pragma once
 
-#include <map>
 #include <list>
+#include <map>
 #include <optional>
 
 namespace nix {
 
 /* A simple least-recently used cache. Not thread-safe. */
-template<typename Key, typename Value>
-class LRUCache
-{
-private:
-
-    size_t capacity;
+template <typename Key, typename Value>
+class LRUCache {
+ private:
+  size_t capacity;
 
-    // Stupid wrapper to get around circular dependency between Data
-    // and LRU.
-    struct LRUIterator;
+  // Stupid wrapper to get around circular dependency between Data
+  // and LRU.
+  struct LRUIterator;
 
-    using Data = std::map<Key, std::pair<LRUIterator, Value>>;
-    using LRU = std::list<typename Data::iterator>;
+  using Data = std::map<Key, std::pair<LRUIterator, Value>>;
+  using LRU = std::list<typename Data::iterator>;
 
-    struct LRUIterator { typename LRU::iterator it; };
+  struct LRUIterator {
+    typename LRU::iterator it;
+  };
 
-    Data data;
-    LRU lru;
+  Data data;
+  LRU lru;
 
-public:
+ public:
+  LRUCache(size_t capacity) : capacity(capacity) {}
 
-    LRUCache(size_t capacity) : capacity(capacity) { }
+  /* Insert or upsert an item in the cache. */
+  void upsert(const Key& key, const Value& value) {
+    if (capacity == 0) return;
 
-    /* Insert or upsert an item in the cache. */
-    void upsert(const Key & key, const Value & value)
-    {
-        if (capacity == 0) return;
+    erase(key);
 
-        erase(key);
-
-        if (data.size() >= capacity) {
-            /* Retire the oldest item. */
-            auto oldest = lru.begin();
-            data.erase(*oldest);
-            lru.erase(oldest);
-        }
+    if (data.size() >= capacity) {
+      /* Retire the oldest item. */
+      auto oldest = lru.begin();
+      data.erase(*oldest);
+      lru.erase(oldest);
+    }
 
-        auto res = data.emplace(key, std::make_pair(LRUIterator(), value));
-        assert(res.second);
-        auto & i(res.first);
+    auto res = data.emplace(key, std::make_pair(LRUIterator(), value));
+    assert(res.second);
+    auto& i(res.first);
 
-        auto j = lru.insert(lru.end(), i);
+    auto j = lru.insert(lru.end(), i);
 
-        i->second.first.it = j;
-    }
+    i->second.first.it = j;
+  }
 
-    bool erase(const Key & key)
-    {
-        auto i = data.find(key);
-        if (i == data.end()) return false;
-        lru.erase(i->second.first.it);
-        data.erase(i);
-        return true;
-    }
+  bool erase(const Key& key) {
+    auto i = data.find(key);
+    if (i == data.end()) return false;
+    lru.erase(i->second.first.it);
+    data.erase(i);
+    return true;
+  }
 
-    /* Look up an item in the cache. If it exists, it becomes the most
-       recently used item. */
-    std::optional<Value> get(const Key & key)
-    {
-        auto i = data.find(key);
-        if (i == data.end()) return {};
+  /* Look up an item in the cache. If it exists, it becomes the most
+     recently used item. */
+  std::optional<Value> get(const Key& key) {
+    auto i = data.find(key);
+    if (i == data.end()) return {};
 
-        /* Move this item to the back of the LRU list. */
-        lru.erase(i->second.first.it);
-        auto j = lru.insert(lru.end(), i);
-        i->second.first.it = j;
+    /* Move this item to the back of the LRU list. */
+    lru.erase(i->second.first.it);
+    auto j = lru.insert(lru.end(), i);
+    i->second.first.it = j;
 
-        return i->second.second;
-    }
+    return i->second.second;
+  }
 
-    size_t size()
-    {
-        return data.size();
-    }
+  size_t size() { return data.size(); }
 
-    void clear()
-    {
-        data.clear();
-        lru.clear();
-    }
+  void clear() {
+    data.clear();
+    lru.clear();
+  }
 };
 
-}
+}  // namespace nix