cache.h

Go to the documentation of this file.

/********************************************************************************************
* Twitch Broadcasting SDK
*
* This software is supplied under the terms of a license agreement with Twitch Interactive, Inc. and
* may not be copied or used except in accordance with the terms of that agreement
* Copyright (c) 2012-2016 Twitch Interactive, Inc.
*********************************************************************************************/

#pragma once

#include "twitchsdk/core/systemclock.h"
#include "twitchsdk/core/types/coretypes.h"

#include <memory>
#include <unordered_map>

namespace ttv
{
    template <typename KEY_TYPE, typename VALUE_TYPE>
    class Cache
    {
    public:
        struct CacheEntry
        {
            CacheEntry()
                : expiryTime(0)
                , lastUsedTime(0)
            {
            }

            KEY_TYPE key;
            uint64_t expiryTime;      
            uint64_t lastUsedTime;    
            VALUE_TYPE data;          
        };

        typedef std::function<void(CacheEntry& entry)> VisitorFunc;

    protected:
        typedef std::unordered_map<KEY_TYPE, CacheEntry> MapType;

    public:
        Cache()
            : mExpiryAge(1000 * 60 * 60)
        {
        }

        void SetExpiryAge(uint64_t age)
        {
            mExpiryAge = age;
        }

        uint32_t GetSize() const
        {
            return static_cast<uint32_t>(mCache.size());
        }

        void PurgeUnused(uint64_t olderThan)
        {
            auto now = GetSystemTimeMilliseconds();
            if (olderThan > now)
            {
                olderThan = 0;
            }
            else
            {
                olderThan = now - olderThan;
            }

            for (auto iter = mCache.begin(); iter != mCache.end();)
            {
                if ((*iter).second.lastUsedTime < olderThan)
                {
                    iter = mCache.erase(iter);
                }
                else
                {
                    ++iter;
                }
            }
        }

        void PurgeExpired()
        {
            auto now = GetSystemTimeMilliseconds();

            for (auto iter = mCache.begin(); iter != mCache.end();)
            {
                if ((*iter).second.expiryTime <= now)
                {
                    iter = mCache.erase(iter);
                }
                else
                {
                    ++iter;
                }
            }
        }

        void Clear()
        {
            mCache.clear();
        }

        bool MarkEntryUsed(const KEY_TYPE& key)
        {
            auto iter = mCache.find(key);
            if (iter == mCache.end())
            {
                return false;
            }

            (*iter).second.lastUsedTime = GetSystemTimeMilliseconds();

            return true;
        }

        bool MarkEntryNeverUnused(const KEY_TYPE& key)
        {
            auto iter = mCache.find(key);
            if (iter == mCache.end())
            {
                return false;
            }

            (*iter).second.lastUsedTime = std::numeric_limits<uint64_t>::max();

            return true;
        }

        bool MarkEntryNeverExpires(const KEY_TYPE& key)
        {
            auto iter = mCache.find(key);
            if (iter == mCache.end())
            {
                return false;
            }

            (*iter).second.expiryTime = std::numeric_limits<uint64_t>::max();

            return true;
        }

        bool SetEntryExpiryTime(const KEY_TYPE& key, uint64_t time)
        {
            auto iter = mCache.find(key);
            if (iter == mCache.end())
            {
                return false;
            }

            (*iter).second.expiryTime = time;

            return true;
        }

        bool ExpireEntry(const KEY_TYPE& key)
        {
            return SetEntryExpiryTime(key, 0);
        }

        void ExpireAll()
        {
            for (auto& kvp : mCache)
            {
                kvp.second.expiryTime = 0;
            }
        }

        void SetEntry(const KEY_TYPE& key, VALUE_TYPE data)
        {
            uint64_t now = GetSystemTimeMilliseconds();

            CacheEntry entry;

            typename MapType::iterator iter = mCache.find(key);
            if (iter != mCache.end())
            {
                entry = (*iter).second;
            }
            else
            {
                entry.key = key;
                entry.lastUsedTime = now;
            }

            entry.data = data;

            // Set the expiry time, handle overflow
            if (now <= std::numeric_limits<uint64_t>::max() - mExpiryAge)
            {
                entry.expiryTime = now + mExpiryAge;
            }
            else
            {
                entry.expiryTime = std::numeric_limits<uint64_t>::max();
            }

            mCache[key] = entry;
        }

        void RemoveEntry(const KEY_TYPE& key)
        {
            auto iter = mCache.find(key);
            if (iter == mCache.end())
            {
                return;
            }

            mCache.erase(iter);
        }

        bool GetEntry(const KEY_TYPE& key, VALUE_TYPE& result)
        {
            auto iter = mCache.find(key);
            if (iter != mCache.end())
            {
                result = (*iter).second.data;
            }

            return iter != mCache.end();
        }

        void GetKeys(std::vector<KEY_TYPE>& result)
        {
            for (auto kvp : mCache)
            {
                result.push_back(kvp.first);
            }
        }

        bool ContainsEntry(const KEY_TYPE& key) const
        {
            return mCache.find(key) != mCache.end();
        }

        void ForEach(VisitorFunc func)
        {
            auto copy = mCache;

            for (auto& kvp : copy)
            {
                func(kvp.second);
            }
        }

        bool HasExpiredEntries() const
        {
            Timestamp now = static_cast<Timestamp>(GetSystemTimeMilliseconds());
            for (const auto& kvp : mCache)
            {
                if (kvp.second.expiryTime <= now)
                {
                    return true;
                }
            }

            return false;
        }

        void ForEachExpired(VisitorFunc func)
        {
            auto now = GetSystemTimeMilliseconds();

            auto copy = mCache;

            for (auto& kvp : copy)
            {
                if (kvp.second.expiryTime <= now)
                {
                    func(kvp.second);
                }
            }
        }

    protected:
        MapType mCache;         
        uint64_t mExpiryAge;    
    };
}