memory_cache.h

#ifndef MEMORY_CACHE_H
#define MEMORY_CACHE_H
 
#include <chrono>
#include <map>
 
namespace application
{
    namespace helper
    {
        template <typename K, typename T>
        class MemoryCache
        {
        private:
            const std::chrono::seconds cLifetime;
            std::map<K, std::pair<const std::chrono::system_clock::time_point, const T>> mCachedItems;
 
        public:
            explicit MemoryCache(std::chrono::seconds lifetime) : cLifetime{lifetime}
            {
            }
 
            void Add(K key, const T &item)
            {
                mCachedItems.emplace(
                    key, std::make_pair(std::chrono::system_clock::now(), item));
            }
 
            bool TryGet(K key, T &item)
            {
                auto _cachedItemItr{mCachedItems.find(key)};
 
                if (_cachedItemItr != mCachedItems.end())
                {
                    const auto cNow{std::chrono::system_clock::now()};
                    if (cNow - _cachedItemItr->second.first < cLifetime)
                    {
                        item = _cachedItemItr->second.second;
                        return true;
                    }
                    else
                    {
                        // Remove the item if it is already expired
                        mCachedItems.erase(_cachedItemItr);
                        return false;
                    }
                }
                else
                {
                    return false;
                }
            }
        };
    }
}
 
#endif