---
title: llarp/util/decaying_hashset.hpp

---

# llarp/util/decaying_hashset.hpp



## Namespaces

| Name           |
| -------------- |
| **[llarp](Namespaces/namespacellarp.md)** <br>[crypto.hpp] |
| **[llarp::util](Namespaces/namespacellarp_1_1util.md)**  |

## Classes

|                | Name           |
| -------------- | -------------- |
| struct | **[llarp::util::DecayingHashSet](Classes/structllarp_1_1util_1_1DecayingHashSet.md)**  |




## Source code

```cpp
#pragma once

#include "time.hpp"
#include <unordered_map>

namespace llarp
{
  namespace util
  {
    template <typename Val_t, typename Hash_t = std::hash<Val_t>>
    struct DecayingHashSet
    {
      using Time_t = std::chrono::milliseconds;

      DecayingHashSet(Time_t cacheInterval = 1s) : m_CacheInterval(cacheInterval)
      {}

      size_t
      Size() const
      {
        return m_Values.size();
      }

      bool
      Contains(const Val_t& v) const
      {
        return m_Values.count(v) != 0;
      }

      bool
      Insert(const Val_t& v, Time_t now = 0s)
      {
        if (now == 0s)
          now = llarp::time_now_ms();
        return m_Values.try_emplace(v, now).second;
      }

      void
      Upsert(const Val_t& v)
      {
        m_Values[v] = llarp::time_now_ms();
      }

      void
      Decay(Time_t now = 0s)
      {
        if (now == 0s)
          now = llarp::time_now_ms();
        EraseIf([&](const auto& item) { return (m_CacheInterval + item.second) <= now; });
      }

      Time_t
      DecayInterval() const
      {
        return m_CacheInterval;
      }

      bool
      Empty() const
      {
        return m_Values.empty();
      }

      void
      DecayInterval(Time_t interval)
      {
        m_CacheInterval = interval;
      }

      void
      Remove(const Val_t& val)
      {
        m_Values.erase(val);
      }

     private:
      template <typename Predicate_t>
      void
      EraseIf(Predicate_t pred)
      {
        for (auto i = m_Values.begin(), last = m_Values.end(); i != last;)
        {
          if (pred(*i))
          {
            i = m_Values.erase(i);
          }
          else
          {
            ++i;
          }
        }
      }

      Time_t m_CacheInterval;
      std::unordered_map<Val_t, Time_t, Hash_t> m_Values;
    };
  }  // namespace util
}  // namespace llarp
```


-------------------------------

Updated on 2022-11-08 at 16:19:49 +0000
