peak_common_metadata.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <peak_common/detail/peak_common_metadata_traits.hpp>
#include <peak_common/exceptions/peak_common_exceptions.hpp>
#include <peak_common/types/peak_common_any.hpp>
#include <peak_common/types/peak_common_metadata_key.hpp>
#include <peak_common_c/detail/peak_common_defines.h>
 
#include <unordered_map>
#include <algorithm>
#include <sstream>
#include <vector>
 
namespace peak
{
namespace common
{
namespace detail
{
struct MetadataAccessor;
}

class Metadata
{
public:
    using allowedTypes = std::tuple<int64_t, std::vector<int64_t>, double, std::vector<double>, std::string, std::vector<std::string>, bool,
        std::vector<bool>>;

    template <typename T>
    void SetValueByName(const std::string& name, T&& value)
    {
        Dispatch(name, std::forward<T>(value), std::is_lvalue_reference<T>{});
    }

    void RemoveEntryByName(const std::string& name)
    {
        m_data.erase(name);
    }

    template <MetadataKey metadataKey, typename T>
    void SetValueByKey(T value)
    {
        static_assert(
            std::is_convertible<T, typename detail::MetadataKeyTraits<metadataKey>::type>::value, "Incorrect value type for metadata key");
        constexpr auto key = detail::MetadataKeyTraits<metadataKey>::Name();
        m_data[key] = Any(static_cast<typename detail::MetadataKeyTraits<metadataKey>::type>(std::forward<T>(value)));
    }

    PEAK_COMMON_NO_DISCARD bool HasEntryByName(const std::string& name) const
    {
        return m_data.find(name) != m_data.end(); // NOLINT
    }

    template <MetadataKey metadataKey>
    PEAK_COMMON_NO_DISCARD bool HasEntryByKey() const
    {
        using trait = detail::MetadataKeyTraits<metadataKey>;
        const auto hasKey = HasEntryByName(trait::Name());
 
        if (hasKey)
        {
            const auto hasCorrectType = TryGetValueByName(trait::Name()).GetType() == typeid(typename trait::type);
            return hasCorrectType;
        }
 
        return false;
    }

    PEAK_COMMON_NO_DISCARD Any TryGetValueByName(const std::string& name) const
    {
        if (!HasEntryByName(name))
        {
            return {};
        }
 
        return m_data.at(name);
    }

    template <typename T>
    PEAK_COMMON_NO_DISCARD T GetValueByName(const std::string& name) const
    {
        static_assert(detail::is_in_tuple<std::decay_t<T>, allowedTypes>::value, "T must be one of the allowedTypes!");
 
        if (!HasEntryByName(name))
        {
            throw OutOfRangeException("There is no value named " + name);
        }
 
        return TryGetValueByName(name).AnyCast<T>();
    }

    template <MetadataKey metadataKey>
    PEAK_COMMON_NO_DISCARD typename detail::MetadataKeyTraits<metadataKey>::type GetValueByKey() const
    {
        using trait = detail::MetadataKeyTraits<metadataKey>;
        if (!HasEntryByName(trait::Name()))
        {
            const std::string keyName = trait::Name();
            throw OutOfRangeException("There is no value named " + keyName);
        }
 
        return TryGetValueByName(trait::Name()).template AnyCast<typename trait::type>();
    }

    friend std::ostream& operator<<(std::ostream& os, const Metadata& metadata)
    {
        bool first = true;
        os << "{";
        for (const auto& pair : metadata.m_data)
        {
            if (!first)
            {
                os << ',';
            }
 
            // NOTE: Cannot output value, as we don't know the type...
            os << " \"" << pair.first << "\"";
 
            first = false;
        }
        os << " }";
 
        return os;
    }

    PEAK_COMMON_NO_DISCARD std::string ToString() const
    {
        std::ostringstream ss;
        ss << *this;
        return ss.str();
    }

    PEAK_COMMON_NO_DISCARD std::vector<std::string> GetKeyNames() const
    {
        std::vector<std::string> names;
        names.reserve(m_data.size());
        std::transform(m_data.cbegin(), m_data.cend(), std::back_inserter(names), [](const auto& pair) {
            return pair.first;
        });
 
        return names;
    }
 
private:
    template <typename T>
    void Dispatch(const std::string& key, T&& value, std::true_type)
    {
        using Decayed = typename std::decay<T>::type;
 
        static_assert(detail::is_in_tuple<Decayed, allowedTypes>::value, "Lvalue type must be exactly one of the 'allowedTypes'!");
 
        m_data[key] = Any(value);
    }
 
    template <typename T>
    void Dispatch(const std::string& key, T&& value, std::false_type)
    {
        using Normalized = detail::normalize_t<T>;
 
        static_assert(detail::is_in_tuple<Normalized, allowedTypes>::value,
            "Rvalue type must be one of the 'allowedTypes' or be able to be widened into one of the 'allowedTypes'!");
 
        m_data[key] = Any(Cast(std::forward<T>(value)));
    }
 
    template <typename T>
    void SetValueByNameInternal(const std::string& name, T&& value)
    {
        m_data[name] = Any(std::forward<T>(value));
    }
 
    template <typename T>
    static detail::normalize_t<T> Cast(T&& v)
    {
        return static_cast<detail::normalize_t<T>>(v);
    }
 
    template <typename T>
    static std::vector<T> Cast(std::vector<T>&& v)
    {
        return std::move(v);
    }
 
    std::unordered_map<std::string, Any> m_data;
 
    friend struct detail::MetadataAccessor;
};
 
namespace detail
{
struct MetadataAccessor
{
    template <typename T>
    static void SetValueByName(Metadata& metadata, const std::string& key, T&& value)
    {
        metadata.SetValueByNameInternal(key, std::forward<T>(value));
    }
};
} // namespace detail
 
} // namespace common 
} // namespace peak