primitive_types.h

 
#pragma once
 
#include <system/boolean.h>
#include <system/byte.h>
#include <system/double.h>
#include <system/int16.h>
#include <system/int32.h>
#include <system/int64.h>
#include <system/sbyte.h>
#include <system/single.h>
#include <system/uint16.h>
#include <system/uint32.h>
#include <system/uint64.h>
 
#include <system/exceptions.h>
#include <system/get_hash_code.h>//do not remove. Translator includes primitive_types.h on using System::GetHashCode(...)
#include <limits>
#include <cmath>
 
namespace System {
 
namespace Details {
 
template<typename T>
struct IsSigned : std::is_signed<T> {};
 
template<typename T>
struct IsUnsigned : std::is_unsigned<T> {};
 
template<>
struct IsSigned<Decimal> : std::true_type {};
 
template<>
struct IsUnsigned<Decimal> : std::false_type {};
 
template<typename TTo, typename TFrom>
typename std::enable_if<IsSigned<TFrom>::value && IsSigned<TTo>::value>::type CheckCast(TFrom value)
{
    if (value < std::numeric_limits<TTo>::min() || value > std::numeric_limits<TTo>::max())
        throw OverflowException();
}
 
template<typename TTo, typename TFrom>
typename std::enable_if<IsSigned<TFrom>::value && IsUnsigned<TTo>::value>::type CheckCast(TFrom value)
{
    if (value < 0 || std::numeric_limits<TTo>::max() - value < 0)
        throw OverflowException();
}
 
template<typename TTo, typename TFrom>
typename std::enable_if<IsUnsigned<TFrom>::value && IsSigned<TTo>::value>::type CheckCast(TFrom value)
{
    if (static_cast<TTo>(std::numeric_limits<TTo>::max() - value) < 0)
        throw OverflowException();
}
 
template<typename TTo, typename TFrom>
typename std::enable_if<IsUnsigned<TFrom>::value && IsUnsigned<TTo>::value>::type CheckCast(TFrom value)
{
    if (value > std::numeric_limits<TTo>::max())
        throw OverflowException();
}
 
} // Details
 
template <typename TA, typename TB>
inline bool Equals(const TA& a, const TB& b)
{
    return a == b;
}
 
template<>
inline bool Equals<float, float>(const float& a, const float& b)
{
    return (std::isnan(a) && std::isnan(b)) ? true : a == b;
}
 
template<>
inline bool Equals<double, double>(const double& a, const double& b)
{
    return (std::isnan(a) && std::isnan(b)) ? true : a == b;
}
 
template <typename TA, typename TB>
std::enable_if_t<!std::is_floating_point<TA>::value && !std::is_floating_point<TB>::value, int>
Compare(const TA& a, const TB& b)
{
    return (a < b) ? -1 : ((b < a) ? 1 : 0);
}
 
template <typename TA, typename TB>
std::enable_if_t<std::is_floating_point<TA>::value && std::is_floating_point<TB>::value, int>
Compare(const TA& a, const TB& b)
{
    if (std::isnan(a))
    {
        if (std::isnan(b))
            return 0;
        return -1;
    }
    if (std::isnan(b))
        return 1;
    return (a < b) ? -1 : ((b < a) ? 1 : 0);
}
 
template <typename T>
inline bool IsNaN(const T& value)
{
    return std::isnan(value);
}
 
template <typename T>
inline bool IsInfinity(const T& value)
{
    return std::isinf(value);
}
 
template <typename T>
inline bool IsPositiveInfinity(const T& value)
{
    return (std::isinf(value) && value > 0);
}
 
template <typename T>
inline bool IsNegativeInfinity(const T& value)
{
    return (std::isinf(value) && value < 0);
}
 
template<typename TTo, typename TFrom>
TTo CheckedCast(TFrom value)
{
    Details::CheckCast<TTo>(value);
    return static_cast<TTo>(value);
}
 
} // namespace System