Extended.h

Go to the documentation of this file.

#ifndef ZSERIO_EXTENDED_H_INC
#define ZSERIO_EXTENDED_H_INC
 
#include "HashCodeUtil.h"
 
namespace zserio
{
 
namespace detail
{
 
template <typename T, typename... ARGS>
struct is_single_type : std::false_type
{};
 
template <typename T, typename A1>
struct is_single_type<T, A1> : std::is_same<T, std::decay_t<A1>>
{};
 
template <typename T, typename... ARGS>
inline constexpr bool is_single_type_v = is_single_type<T, ARGS...>::value;
 
} // namespace detail
 
template <typename T>
class Extended
{
public:
    Extended(Extended&& other) = default;
 
    template <typename ALLOC>
    Extended(Extended&& other, const ALLOC& allocator) :
            m_isPresent(other.m_isPresent),
            m_value(std::move(other.m_value), allocator)
    {}
 
    Extended(const Extended& other) = default;
 
    template <typename ALLOC>
    Extended(const Extended& other, const ALLOC& allocator) :
            m_isPresent(other.m_isPresent),
            m_value(other.m_value, allocator)
    {}
 
    template <typename... ARGS,
            typename = std::enable_if_t<!detail::is_single_type_v<Extended, ARGS...> &&
                    std::is_constructible_v<T, ARGS...>>>
    explicit constexpr Extended(ARGS&&... args) :
            m_value(std::forward<ARGS>(args)...)
    {}
 
    Extended& operator=(Extended&& other) = default;
    Extended& operator=(const Extended& other) = default;
 
    ~Extended() = default;
 
    constexpr const T& value() const noexcept
    {
        return m_value;
    }
 
    T& value() noexcept
    {
        return m_value;
    }
 
    constexpr T& operator*() noexcept
    {
        return m_value;
    }
 
    constexpr const T& operator*() const noexcept
    {
        return m_value;
    }
 
    T* operator->() noexcept
    {
        return &m_value;
    }
 
    const T* operator->() const noexcept
    {
        return &m_value;
    }
 
    constexpr explicit operator bool() const noexcept
    {
        return m_isPresent;
    }
 
    bool isPresent() const noexcept
    {
        return m_isPresent;
    }
 
    void setPresent(bool present) noexcept
    {
        m_isPresent = present;
    }
 
private:
    bool m_isPresent = true; // present by default
    T m_value;
};
 
template <typename T>
bool operator==(const Extended<T>& lhs, const Extended<T>& rhs)
{
    if (lhs.isPresent() && rhs.isPresent())
    {
        return lhs.value() == rhs.value();
    }
    return lhs.isPresent() == rhs.isPresent();
}
 
template <typename T>
bool operator!=(const Extended<T>& lhs, const Extended<T>& rhs)
{
    return !(lhs == rhs);
}
 
template <typename T>
bool operator<(const Extended<T>& lhs, const Extended<T>& rhs)
{
    if (lhs.isPresent() && rhs.isPresent())
    {
        return lhs.value() < rhs.value();
    }
    return lhs.isPresent() < rhs.isPresent();
}
 
template <typename T>
bool operator>(const Extended<T>& lhs, const Extended<T>& rhs)
{
    if (lhs.isPresent() && rhs.isPresent())
    {
        return lhs.value() > rhs.value();
    }
    return lhs.isPresent() > rhs.isPresent();
}
 
template <typename T>
bool operator<=(const Extended<T>& lhs, const Extended<T>& rhs)
{
    return !(lhs > rhs);
}
 
template <typename T>
bool operator>=(const Extended<T>& lhs, const Extended<T>& rhs)
{
    return !(rhs > lhs);
}
 
template <typename T>
uint32_t calcHashCode(uint32_t seed, const Extended<T>& extendedValue)
{
    uint32_t result = seed;
    if (extendedValue.isPresent())
    {
        result = calcHashCode(result, *extendedValue);
    }
    return result;
}
 
} // namespace zserio
 
namespace std
{
 
template <typename T>
struct hash<zserio::Extended<T>>
{
    size_t operator()(const zserio::Extended<T>& extendedValue) const
    {
        return zserio::calcHashCode(zserio::HASH_SEED, extendedValue);
    }
};
 
} // namespace std
 
#endif // ZSERIO_EXTENDED_H_INC