Class SpeedTemplate

src/OpenLoco/include/OpenLoco/Speed.hpp:10–86

{
    template<typename TValue>
    struct SpeedTemplate
    {
        using ValueType = TValue;

        ValueType value;
        constexpr ValueType getRaw() const { return value; }
        constexpr SpeedTemplate() = default;
        constexpr explicit SpeedTemplate(ValueType val)
            : value(val)
        {
        }

        // Conversion function (only valid to more accuracy)
        template<typename T>
        constexpr operator SpeedTemplate<T>() const
        {
            static_assert(sizeof(T) > sizeof(ValueType));
            constexpr auto shift = (sizeof(T) - sizeof(ValueType)) * 8;
            return SpeedTemplate<T>(getRaw() * (1 << shift));
        }

        // Best accuracy between ThisType and OtherType
        template<typename OtherType>
        using BestValue = std::conditional_t<(sizeof(ValueType) > sizeof(OtherType)), ValueType, OtherType>;
        template<typename OtherType>
        using BestType = SpeedTemplate<BestValue<OtherType>>;

        template<typename RhsT>
        constexpr bool operator==(SpeedTemplate<RhsT> const& rhs) const
        {
            return BestType<RhsT>(*this).value == BestType<RhsT>(rhs).value;
        }
        template<typename RhsT>
        constexpr std::strong_ordering operator<=>(SpeedTemplate<RhsT> const& rhs) const
        {
            return BestType<RhsT>(*this).value <=> BestType<RhsT>(rhs).value;
        }

        constexpr SpeedTemplate& operator-()
        {
            value = -value;
            return *this;
        }
        constexpr SpeedTemplate& operator+=(SpeedTemplate const& rhs)
        {
            value += rhs.value;
            return *this;
        }
        constexpr SpeedTemplate& operator-=(SpeedTemplate const& rhs)
        {
            value -= rhs.value;
            return *this;
        }
        template<typename RhsT>
        constexpr BestType<RhsT> operator+(SpeedTemplate<RhsT> const& rhs) const
        {
            return BestType<RhsT>(BestType<RhsT>(*this).value + BestType<RhsT>(rhs).value);
        }