updated build system

support/include/utils/ttl_cache.hpp

@@ -0,0 +1,100 @@
+#ifndef REPERTORY_INCLUDE_UTILS_TTL_CACHE_HPP_
+#define REPERTORY_INCLUDE_UTILS_TTL_CACHE_HPP_
+
+#include "utils/config.hpp"
+
+namespace repertory::utils {
+template <typename data_t, template <typename> class atomic_t = std::atomic>
+class ttl_cache final {
+public:
+  using clock = std::chrono::steady_clock;
+  using duration = std::chrono::milliseconds;
+  using entry_t = atomic_t<data_t>;
+  using entry_ptr_t = std::shared_ptr<entry_t>;
+
+  static constexpr const auto default_expiration{duration(60000U)};
+
+private:
+  struct entry final {
+    entry_ptr_t data;
+    clock::time_point expires_at;
+  };
+
+public:
+  ttl_cache(duration ttl = default_expiration) : ttl_{ttl} {}
+
+private:
+  duration ttl_;
+
+private:
+  mutable std::mutex mutex_;
+  std::unordered_map<std::string, entry> entries_;
+
+public:
+  void clear() {
+    mutex_lock lock(mutex_);
+    entries_.clear();
+  }
+
+  void erase(const std::string &api_path) {
+    mutex_lock lock(mutex_);
+    entries_.erase(api_path);
+  }
+
+  [[nodiscard]] auto contains(const std::string &api_path) -> bool {
+    mutex_lock lock(mutex_);
+    return entries_.contains(api_path);
+  }
+
+  [[nodiscard]] auto get(const std::string &api_path) -> entry_ptr_t {
+    mutex_lock lock(mutex_);
+    auto iter = entries_.find(api_path);
+    if (iter == entries_.end()) {
+      return nullptr;
+    }
+
+    iter->second.expires_at = clock::now() + ttl_;
+    return iter->second.data;
+  }
+
+  void purge_expired() {
+    mutex_lock lock(mutex_);
+    auto now = clock::now();
+    for (auto iter = entries_.begin(); iter != entries_.end();) {
+      if (iter->second.expires_at <= now) {
+        iter = entries_.erase(iter);
+        continue;
+      }
+
+      ++iter;
+    }
+  }
+
+  [[nodiscard]] auto get_ttl() const -> duration {
+    mutex_lock lock(mutex_);
+    return ttl_;
+  }
+
+  void set(const std::string &api_path, const data_t &data) {
+    mutex_lock lock(mutex_);
+    if (entries_.contains(api_path)) {
+      auto &entry = entries_.at(api_path);
+      entry.data->store(data);
+      entry.expires_at = clock::now() + ttl_;
+      return;
+    }
+
+    entries_.emplace(api_path, entry{
+                                   .data = std::make_shared<entry_t>(data),
+                                   .expires_at = clock::now() + ttl_,
+                               });
+  }
+
+  void set_ttl(duration ttl) {
+    mutex_lock lock(mutex_);
+    ttl_ = ttl;
+  }
+};
+} // namespace repertory::utils
+
+#endif // REPERTORY_INCLUDE_UTILS_TTL_CACHE_HPP_