TokenList.h

#pragma once
 
 
#include <algorithm>
#include <numeric>
#include <vector>
#include <string>
 
//--- User configuration header ---//
#include "TasksConfig.h"
 
NAMESPACE_SQUID_BEGIN
 
template <typename T = void>
class TokenList;
 
struct Token
{
    Token(std::string in_name)
        : name(std::move(in_name))
    {
    }
    std::string name; // Used for debug only
};
 
template <typename tData>
struct DataToken
{
    DataToken(std::string in_name, tData in_data)
        : name(std::move(in_name))
        , data(std::move(in_data))
    {
    }
    std::string name; // Used for debug only
    tData data;
};
 
inline std::shared_ptr<Token> MakeToken(std::string in_name)
{
    return std::make_shared<Token>(std::move(in_name));
}
 
template <typename tData>
std::shared_ptr<DataToken<tData>> MakeToken(std::string in_name, tData in_data)
{
    return std::make_shared<DataToken<tData>>(std::move(in_name), std::move(in_data));
}
 
template <typename T>
class TokenList
{
public:
    using Token = typename std::conditional_t<std::is_void<T>::value, Token, DataToken<T>>;
 
    template <typename U = T, typename std::enable_if_t<std::is_void<U>::value>* = nullptr>
    static std::shared_ptr<Token> MakeToken(std::string in_name)
    {
        return std::make_shared<Token>(std::move(in_name));
    }
 
    template <typename U = T, typename std::enable_if_t<!std::is_void<U>::value>* = nullptr>
    static std::shared_ptr<Token> MakeToken(std::string in_name, U in_data)
    {
        return std::make_shared<Token>(std::move(in_name), std::move(in_data));
    }
 
    template <typename U = T, typename std::enable_if_t<std::is_void<U>::value>* = nullptr>
    SQUID_NODISCARD std::shared_ptr<Token> TakeToken(std::string in_name)
    {
        return AddTokenInternal(MakeToken(std::move(in_name)));
    }
 
    template <typename U = T, typename std::enable_if_t<!std::is_void<U>::value>* = nullptr>
    SQUID_NODISCARD std::shared_ptr<Token> TakeToken(std::string in_name, U in_data)
    {
        return AddTokenInternal(MakeToken(std::move(in_name), std::move(in_data)));
    }
 
    std::shared_ptr<Token> AddToken(std::shared_ptr<Token> in_token)
    {
        SQUID_RUNTIME_CHECK(in_token, "Cannot add null token");
        auto foundIter = std::find_if(m_tokens.begin(), m_tokens.end(), [&in_token](const std::weak_ptr<Token> in_iterToken){ 
            return in_iterToken.lock() == in_token; 
        });
 
        if(foundIter == m_tokens.end()) // Prevent duplicate tokens
        {
            return AddTokenInternal(in_token);
        }
        return in_token;
    }
 
    void RemoveToken(std::shared_ptr<Token> in_token)
    {
        // Find and remove the token
        if(m_tokens.size())
        {
            m_tokens.erase(std::remove_if(m_tokens.begin(), m_tokens.end(), [&in_token](const std::weak_ptr<Token>& in_otherToken) {
                return !in_otherToken.owner_before(in_token) && !in_token.owner_before(in_otherToken);
            }), m_tokens.end());
        }
    }
 
    operator bool() const
    {
        return HasTokens();
    }
 
    bool HasTokens() const
    {
        // Return true when holding any unexpired tokens
        for(auto i = (int32_t)(m_tokens.size() - 1); i >= 0; --i)
        {
            const auto& token = m_tokens[i];
            if(!token.expired())
            {
                return true;
            }
            m_tokens.pop_back(); // Because the token is expired, we can safely remove it from the back
        }
        return false;
    }
 
    std::vector<T> GetTokenData() const
    {
        std::vector<T> tokenData;
        for(const auto& tokenWeak : m_tokens)
        {
            if(auto token = tokenWeak.lock())
            {
                tokenData.push_back(token->data);
            }
        }
        return tokenData;
    }
 
    
    std::optional<T> GetLeastRecent() const
    {
        Sanitize();
        return m_tokens.size() ? m_tokens.front().lock()->data : std::optional<T>{};
    }
 
    std::optional<T> GetMostRecent() const
    {
        Sanitize();
        return m_tokens.size() ? m_tokens.back().lock()->data : std::optional<T>{};
    }
 
    std::optional<T> GetMin() const
    {
        std::optional<T> ret;
        SanitizeAndProcessData([&ret](const T& in_data) {
            if(!ret || in_data < ret.value())
            {
                ret = in_data;
            }
        });
        return ret;
    }
 
    std::optional<T> GetMax() const
    {
        std::optional<T> ret;
        SanitizeAndProcessData([&ret](const T& in_data) {
            if(!ret || in_data > ret.value())
            {
                ret = in_data;
            }
        });
        return ret;
    }
 
    std::optional<double> GetMean() const
    {
        std::optional<double> ret;
        std::optional<double> total;
        SanitizeAndProcessData([&total](const T& in_data) {
            total = total.value_or(0.0) + (double)in_data;
        });
        if(total)
        {
            ret = total.value() / m_tokens.size();
        }
        return ret;
    }
 
    template <typename U = T, typename std::enable_if_t<!std::is_void<U>::value>* = nullptr>
    bool Contains(const U& in_searchData) const
    {
        bool containsData = false;
        SanitizeAndProcessData([&in_searchData, &containsData](const T& in_data) {
            if(in_searchData == in_data)
            {
                containsData = true;
            }
        });
        return containsData;
    }
 
    std::string GetDebugString() const 
    {
        std::vector<std::string> tokenStrings;
        std::string debugStr;
        for(const auto& token : m_tokens) 
        {
            if(!token.expired())
            {
                if(debugStr.size() > 0)
                {
                    debugStr += "\n";
                }
                debugStr += token.lock()->name;
            }
        }
        if(debugStr.size() == 0)
        {
            debugStr = "[no tokens]";
        }
        return debugStr;
    }
 
private:
    // Shared internal implementation for adding tokens
    std::shared_ptr<Token> AddTokenInternal(std::shared_ptr<Token> in_token)
    {
        Sanitize();
        m_tokens.push_back(in_token);
        return in_token;
    }
 
    // Sanitation
    void Sanitize() const
    {
        // Remove all invalid tokens
        if(m_tokens.size())
        {
            m_tokens.erase(std::remove_if(m_tokens.begin(), m_tokens.end(), [](const std::weak_ptr<Token>& in_token) {
                return in_token.expired();
            }), m_tokens.end());
        }
    }
    template <typename tFn>
    void SanitizeAndProcessData(tFn in_dataFn) const
    {
        // Remove all invalid tokens while applying a processing function on each valid token
        if(m_tokens.size())
        {
            m_tokens.erase(std::remove_if(m_tokens.begin(), m_tokens.end(), [&in_dataFn](const std::weak_ptr<Token>& in_token) {
                if(in_token.expired())
                {
                    return true;
                }
                if(auto token = in_token.lock())
                {
                    in_dataFn(token->data);
                }
                return false;
            }), m_tokens.end());
        }
    }
 
    // Token data
    mutable std::vector<std::weak_ptr<Token>> m_tokens; // Mutable so we can remove expired tokens while converting bool
};
 
NAMESPACE_SQUID_END