Enums.h

Go to the documentation of this file.

#ifndef ZSERIO_ENUMS_H_INC
#define ZSERIO_ENUMS_H_INC
 
#include <algorithm>
#include <cstddef>
#include <string_view>
#include <type_traits>
 
#include "zserio/BitStreamReader.h"
#include "zserio/BitStreamWriter.h"
#include "zserio/DeltaContext.h"
#include "zserio/ItemsAccessor.h"
 
namespace zserio
{
 
template <typename T>
struct EnumTraits
{};
 
template <typename T>
size_t enumToOrdinal(T value);
 
template <typename T>
T valueToEnum(typename EnumTraits<T>::ZserioType rawValue);
 
template <typename T>
constexpr typename EnumTraits<T>::ZserioType enumToValue(T value)
{
    return static_cast<typename EnumTraits<T>::ZserioType>(static_cast<std::underlying_type_t<T>>(value));
}
 
template <typename T>
T stringToEnum(std::string_view itemName)
{
    const auto foundIt = std::find_if(EnumTraits<T>::names.begin(), EnumTraits<T>::names.end(),
            [itemName](std::string_view enumItemName) {
                return itemName.compare(enumItemName) == 0;
            });
    if (foundIt == EnumTraits<T>::names.end())
    {
        throw CppRuntimeException("Enum item '")
                << itemName << "' doesn't exist in enum '" << EnumTraits<T>::enumName << "'!";
    }
 
    const size_t ordinal = static_cast<size_t>(std::distance(EnumTraits<T>::names.begin(), foundIt));
    return EnumTraits<T>::values[ordinal];
}
 
template <typename T>
std::string_view enumToString(T value)
{
    return EnumTraits<T>::names[enumToOrdinal(value)];
}
 
namespace detail
{
 
template <typename T>
std::enable_if_t<std::is_enum_v<T>> validate(T value, std::string_view fieldName)
{
    validate(enumToValue(value), fieldName);
}
 
template <typename T>
std::enable_if_t<std::is_enum_v<T>, BitSize> bitSizeOf(T value, BitSize bitPosition = 0)
{
    return bitSizeOf(enumToValue(value), bitPosition);
}
 
template <typename T>
std::enable_if_t<std::is_enum_v<T>> write(BitStreamWriter& writer, T value)
{
    write(writer, enumToValue(value));
}
 
template <typename T>
std::enable_if_t<std::is_enum_v<T>> read(zserio::BitStreamReader& reader, T& value)
{
    typename EnumTraits<T>::ZserioType rawValue;
    read(reader, rawValue);
    value = valueToEnum<T>(rawValue);
}
 
template <typename T, std::enable_if_t<std::is_enum_v<T>, int> = 0>
inline void initContext(DeltaContext& deltaContext, T value)
{
    deltaContext.init(enumToValue(value));
}
 
template <typename T>
std::enable_if_t<std::is_enum_v<T>, BitSize> bitSizeOf(DeltaContext& deltaContext, T value, BitSize = 0)
{
    return deltaContext.bitSizeOf(enumToValue(value));
}
 
template <typename T>
std::enable_if_t<std::is_enum_v<T>> write(DeltaContext& deltaContext, BitStreamWriter& writer, T value)
{
    deltaContext.write(writer, enumToValue(value));
}
 
template <typename T>
std::enable_if_t<std::is_enum_v<T>> read(DeltaContext& deltaContext, BitStreamReader& reader, T& value)
{
    typename EnumTraits<T>::ZserioType rawValue;
    deltaContext.read(reader, rawValue);
    value = valueToEnum<T>(rawValue);
}
 
} // namespace detail
 
template <typename T, std::enable_if_t<std::is_enum_v<T>, int> = 0>
CppRuntimeException& operator<<(CppRuntimeException& exception, T value)
{
    exception << enumToString(value);
    return exception;
}
 
} // namespace zserio
 
#endif // ZSERIO_ENUMS_H_INC