Class HashMapLru

src/fl/stl/unordered_map_lru.h:22–173

          typename KeyEqual = EqualTo<Key>,
          int INLINED_COUNT = FASTLED_HASHMAP_INLINED_COUNT>
class HashMapLru {
  private:
    // Wrapper for values that includes access time tracking
    struct ValueWithTimestamp {
        T value;
        u32 last_access_time;

        ValueWithTimestamp() FL_NOEXCEPT : last_access_time(0) {}
        ValueWithTimestamp(const T &v, u32 time)
            : value(v), last_access_time(time) {}
    };

  public:
    HashMapLru(fl::size max_size) : mMaxSize(max_size), mCurrentTime(0) {
        // Ensure max size is at least 1
        if (mMaxSize < 1)
            mMaxSize = 1;
    }

    HashMapLru(fl::size max_size, memory_resource* resource)
        : mMap(resource), mMaxSize(max_size), mCurrentTime(0) {
        if (mMaxSize < 1)
            mMaxSize = 1;
    }

    void setMaxSize(fl::size max_size) {
        while (mMaxSize < max_size) {
            // Evict oldest items until we reach the new max size
            evictOldest();
        }
        mMaxSize = max_size;
    }

    void swap(HashMapLru &other) {
        fl::swap(mMap, other.mMap);
        fl::swap(mMaxSize, other.mMaxSize);
        fl::swap(mCurrentTime, other.mCurrentTime);
    }

    // Insert or update a key-value pair
    void insert(const Key &key, const T &value) {
        // Only evict if we're at capacity AND this is a new key
        const ValueWithTimestamp *existing = mMap.find_value(key);

        auto curr = mCurrentTime++;

        if (existing) {
            // Update the value and access time
            ValueWithTimestamp &vwt =
                const_cast<ValueWithTimestamp &>(*existing);
            vwt.value = value;
            vwt.last_access_time = curr;
            return;
        }
        if (mMap.size() >= mMaxSize) {
            evictOldest();
        }