ReflectableUtil.h

Go to the documentation of this file.

#ifndef ZSERIO_REFLECTABLE_UTIL_H_INC
#define ZSERIO_REFLECTABLE_UTIL_H_INC
 
#include <algorithm>
#include <cmath>
#include <functional>
#include <limits>
#include <string_view>
 
#include "zserio/CppRuntimeException.h"
#include "zserio/Enums.h"
#include "zserio/IReflectableData.h"
#include "zserio/ITypeInfo.h"
#include "zserio/Traits.h"
#include "zserio/TypeInfoUtil.h"
 
namespace zserio
{
 
namespace detail
{
 
template <typename T>
struct gets_value_by_value
        : std::integral_constant<bool,
                  std::is_arithmetic_v<T> || std::is_same_v<std::string_view, T> || std::is_enum_v<T> ||
                          is_bitmask_v<T> || is_numeric_wrapper_v<T>>
{};
 
} // namespace detail
 
class ReflectableUtil
{
public:
    template <typename ALLOC = std::allocator<uint8_t>>
    static bool equal(
            const IBasicReflectableDataConstPtr<ALLOC>& lhs, const IBasicReflectableDataConstPtr<ALLOC>& rhs);
 
    template <typename T, typename ALLOC = std::allocator<uint8_t>,
            typename std::enable_if<detail::gets_value_by_value<T>::value, int>::type = 0>
    static T getValue(const IBasicReflectableDataConstPtr<ALLOC>& reflectable, const ALLOC& allocator = ALLOC())
    {
        return reflectable->getAnyValue(allocator).template get<T>();
    }
 
    template <typename T, typename ALLOC = std::allocator<uint8_t>,
            typename std::enable_if<!detail::gets_value_by_value<T>::value, int>::type = 0>
    static const T& getValue(
            const IBasicReflectableDataConstPtr<ALLOC>& reflectable, const ALLOC& allocator = ALLOC())
    {
        return reflectable->getAnyValue(allocator).template get<std::reference_wrapper<const T>>().get();
    }
 
    template <typename T, typename ALLOC = std::allocator<uint8_t>,
            typename std::enable_if<!detail::gets_value_by_value<T>::value &&
                            !std::is_same<BasicBitBuffer<ALLOC>, T>::value,
                    int>::type = 0>
    static T& getValue(const IBasicReflectableDataPtr<ALLOC>& reflectable, const ALLOC& allocator = ALLOC())
    {
        return reflectable->getAnyValue(allocator).template get<std::reference_wrapper<T>>().get();
    }
 
    template <typename T, typename ALLOC = std::allocator<uint8_t>,
            typename std::enable_if<std::is_same<BasicBitBuffer<ALLOC>, T>::value, int>::type = 0>
    static const T& getValue(
            const IBasicReflectableDataPtr<ALLOC>& reflectable, const ALLOC& allocator = ALLOC())
    {
        return reflectable->getAnyValue(allocator).template get<std::reference_wrapper<const T>>().get();
    }
 
    template <typename T, typename ALLOC>
    static T fromAny(const BasicAny<ALLOC>& any);
 
private:
    template <typename ALLOC>
    static bool arraysEqual(const IBasicReflectableDataConstPtr<ALLOC>& lhsArray,
            const IBasicReflectableDataConstPtr<ALLOC>& rhsArray);
 
    template <typename ALLOC>
    static bool compoundsEqual(const IBasicReflectableDataConstPtr<ALLOC>& lhsCompound,
            const IBasicReflectableDataConstPtr<ALLOC>& rhsCompound);
 
    template <typename ALLOC>
    static bool valuesEqual(const IBasicReflectableDataConstPtr<ALLOC>& lhsValue,
            const IBasicReflectableDataConstPtr<ALLOC>& rhsValue);
 
    static bool doubleValuesAlmostEqual(double lhs, double rhs);
};
 
template <typename ALLOC>
bool ReflectableUtil::equal(
        const IBasicReflectableDataConstPtr<ALLOC>& lhs, const IBasicReflectableDataConstPtr<ALLOC>& rhs)
{
    if (lhs == nullptr || rhs == nullptr)
    {
        return lhs == rhs;
    }
 
    const auto& lhsTypeInfo = lhs->getTypeInfo();
    const auto& rhsTypeInfo = rhs->getTypeInfo();
 
    if (lhsTypeInfo.getSchemaType() != rhsTypeInfo.getSchemaType() ||
            lhsTypeInfo.getSchemaName() != rhsTypeInfo.getSchemaName())
    {
        return false;
    }
 
    if (lhs->isArray() || rhs->isArray())
    {
        if (!lhs->isArray() || !rhs->isArray())
        {
            return false;
        }
        return arraysEqual<ALLOC>(lhs, rhs);
    }
    else if (TypeInfoUtil::isCompound(lhsTypeInfo.getSchemaType()))
    {
        return compoundsEqual<ALLOC>(lhs, rhs);
    }
    else
    {
        return valuesEqual<ALLOC>(lhs, rhs);
    }
}
 
template <typename ALLOC>
bool ReflectableUtil::arraysEqual(const IBasicReflectableDataConstPtr<ALLOC>& lhsArray,
        const IBasicReflectableDataConstPtr<ALLOC>& rhsArray)
{
    if (lhsArray->size() != rhsArray->size())
    {
        return false;
    }
 
    for (size_t i = 0; i < lhsArray->size(); ++i)
    {
        if (!equal<ALLOC>(lhsArray->at(i), rhsArray->at(i)))
        {
            return false;
        }
    }
 
    return true;
}
 
template <typename ALLOC>
bool ReflectableUtil::compoundsEqual(const IBasicReflectableDataConstPtr<ALLOC>& lhsCompound,
        const IBasicReflectableDataConstPtr<ALLOC>& rhsCompound)
{
    if (TypeInfoUtil::hasChoice(lhsCompound->getTypeInfo().getSchemaType()))
    {
        if (lhsCompound->getChoice() != rhsCompound->getChoice())
        {
            return false;
        }
 
        if (!lhsCompound->getChoice().empty())
        {
            auto lhsField = lhsCompound->getField(lhsCompound->getChoice());
            auto rhsField = rhsCompound->getField(rhsCompound->getChoice());
            if (!equal<ALLOC>(lhsField, rhsField))
            {
                return false;
            }
        }
    }
    else
    {
        for (const auto& fieldInfo : lhsCompound->getTypeInfo().getFields())
        {
            auto lhsField = lhsCompound->getField(fieldInfo.schemaName);
            auto rhsField = rhsCompound->getField(fieldInfo.schemaName);
            if (!equal<ALLOC>(lhsField, rhsField))
            {
                return false;
            }
        }
    }
 
    return true;
}
 
template <typename ALLOC>
bool ReflectableUtil::valuesEqual(const IBasicReflectableDataConstPtr<ALLOC>& lhsValue,
        const IBasicReflectableDataConstPtr<ALLOC>& rhsValue)
{
    CppType cppType = lhsValue->getTypeInfo().getCppType();
    if (cppType == CppType::ENUM || cppType == CppType::BITMASK)
    {
        cppType = lhsValue->getTypeInfo().getUnderlyingType().getCppType();
    }
 
    switch (cppType)
    {
    case CppType::BOOL:
        return lhsValue->getBool() == rhsValue->getBool();
    case CppType::INT8:
    case CppType::INT16:
    case CppType::INT32:
    case CppType::INT64:
        return lhsValue->toInt() == rhsValue->toInt();
    case CppType::UINT8:
    case CppType::UINT16:
    case CppType::UINT32:
    case CppType::UINT64:
        return lhsValue->toUInt() == rhsValue->toUInt();
    case CppType::FLOAT:
    case CppType::DOUBLE:
        return doubleValuesAlmostEqual(lhsValue->toDouble(), rhsValue->toDouble());
    case CppType::BYTES:
        {
            Span<const uint8_t> lhs = lhsValue->getBytes();
            Span<const uint8_t> rhs = rhsValue->getBytes();
 
            return lhs.size() == rhs.size() && std::equal(lhs.begin(), lhs.end(), rhs.begin());
        }
    case CppType::STRING:
        return lhsValue->getStringView() == rhsValue->getStringView();
    case CppType::BIT_BUFFER:
        return lhsValue->getBitBuffer() == rhsValue->getBitBuffer();
    default:
        throw CppRuntimeException("ReflectableUtil::valuesEqual - Unexpected C++ type!");
    }
}
 
inline bool ReflectableUtil::doubleValuesAlmostEqual(double lhs, double rhs)
{
    if (std::isinf(lhs) || std::isinf(rhs))
    {
        return std::isinf(lhs) && std::isinf(rhs) && ((lhs > 0.0 && rhs > 0.0) || (lhs < 0.0 && rhs < 0.0));
    }
 
    if (std::isnan(lhs) || std::isnan(rhs))
    {
        return std::isnan(lhs) && std::isnan(rhs);
    }
 
    // see: https://en.cppreference.com/w/cpp/types/numeric_limits/epsilon
    return std::fabs(lhs - rhs) <= std::numeric_limits<double>::epsilon() * std::fabs(lhs + rhs) ||
            std::fabs(lhs - rhs) < std::numeric_limits<double>::min();
}
 
template <typename T, typename ALLOC>
T ReflectableUtil::fromAny(const BasicAny<ALLOC>& any)
{
    if constexpr (is_bitmask_v<T>)
    {
        using ZserioType = typename T::ZserioType;
        using UnderlyingType = typename ZserioType::ValueType;
 
        if (any.template isType<T>())
        {
            return any.template get<T>();
        }
        else if (any.template isType<ZserioType>())
        {
            return T(any.template get<ZserioType>());
        }
        else
        {
            return T(any.template get<UnderlyingType>());
        }
    }
    else if constexpr (std::is_enum_v<T>)
    {
        using ZserioType = typename EnumTraits<T>::ZserioType;
        using UnderlyingType = std::underlying_type_t<T>;
 
        if (any.template isType<T>())
        {
            return any.template get<T>();
        }
        else if (any.template isType<ZserioType>())
        {
            return valueToEnum<T>(any.template get<ZserioType>());
        }
        else
        {
            return valueToEnum<T>(any.template get<UnderlyingType>());
        }
    }
    else if constexpr (is_numeric_wrapper_v<T>)
    {
        if (any.template isType<T>())
        {
            return any.template get<T>();
        }
        else
        {
            return any.template get<typename T::ValueType>();
        }
    }
    else
    {
        return any.template get<T>();
    }
}
 
} // namespace zserio
 
#endif // ZSERIO_REFLECTABLE_UTIL_H_INC