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
{
 
class Metadata
{
public:
    template <typename T>
    void SetValueByName(const std::string& key, T&& value)
    {
        m_data[key] = Any(std::forward<T>(value));
    }
 
    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");
        SetValueByName(
            detail::MetadataKeyTraits<metadataKey>::Name(), static_cast<typename detail::MetadataKeyTraits<metadataKey>::type>(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& key) const
    {
        if (!HasEntryByName(key))
        {
            return {};
        }
 
        return m_data.at(key);
    }
 
    template <typename T>
    PEAK_COMMON_NO_DISCARD T GetValueByName(const std::string& key) const
    {
        if (!HasEntryByName(key))
        {
            throw OutOfRangeException("There is no value named " + key);
        }
 
        return TryGetValueByName(key).AnyCast<T>();
    }
 
    template <MetadataKey metadataKey>
    PEAK_COMMON_NO_DISCARD typename detail::MetadataKeyTraits<metadataKey>::type GetValueByKey() const
    {
        using trait = detail::MetadataKeyTraits<metadataKey>;
        return GetValueByName<typename trait::type>(trait::Name());
    }
 
    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> keys;
        keys.reserve(m_data.size());
        std::transform(m_data.cbegin(), m_data.cend(), std::back_inserter(keys), [](const auto& pair) {
            return pair.first;
        });
 
        return keys;
    }
 
private:
    std::unordered_map<std::string, Any> m_data;
};
 
} // namespace common 
} // namespace peak