Limits.h

#pragma once
// ===========================================================================
// Copyright (c) 2015-2024 Toolchefs Ltd. All rights reserved.
//
// Use of this software is subject to the terms of the Toolchefs license
// agreement provided at the time of installation or download, or which
// otherwise accompanies this software in either electronic or hard copy form.
// ===========================================================================
#include <stdint.h>
 
namespace ToolchefsSTL
{
 
    template <typename NumericType>
    struct NumericLimits;
 
    template<>
    struct NumericLimits<uint8_t>
    {
        typedef uint8_t NumericType;
 
        static constexpr NumericType min()
        {
#ifndef _WIN32
            return 0;
#else
            return 0ui8;
#endif
        }
 
        static constexpr NumericType max()
        {
            return UINT8_MAX;
        }
    };
 
 
    template<>
    struct NumericLimits<uint16_t>
    {
        typedef uint16_t NumericType;
 
        static constexpr NumericType min()
        {
#ifndef _WIN32
            return 0;
#else
            return 0ui16;
#endif
        }
 
        static constexpr NumericType max()
        {
            return UINT16_MAX;
        }
    };
 
 
    template<>
    struct NumericLimits<uint32_t>
    {
        typedef uint32_t NumericType;
 
        static constexpr NumericType min()
        {
#ifndef _WIN32
            return 0;
#else
            return 0ui32;
#endif
        }
 
        static constexpr NumericType max()
        {
            return UINT32_MAX;
        }
    };
 
 
    template<>
    struct NumericLimits<uint64_t>
    {
        typedef uint64_t NumericType;
 
        static constexpr NumericType min()
        {
#ifndef _WIN32
            return 0;
#else
            return 0ui64;
#endif
        }
 
        static constexpr NumericType max()
        {
            return UINT64_MAX;
        }
    };
 
 
    template<>
    struct NumericLimits<int8_t>
    {
        typedef int8_t NumericType;
 
        static constexpr NumericType min()
        {
            return INT8_MIN;
        }
 
        static constexpr NumericType max()
        {
            return INT8_MAX;
        }
    };
 
 
    template<>
    struct NumericLimits<int16_t>
    {
        typedef int16_t NumericType;
 
        static constexpr NumericType min()
        {
            return INT16_MIN;
        }
 
        static constexpr NumericType max()
        {
            return INT16_MAX;
        }
    };
 
 
    template<>
    struct NumericLimits<int32_t>
    {
        typedef int32_t NumericType;
 
        static constexpr NumericType min()
        {
            return INT32_MIN;
        }
 
        static constexpr NumericType max()
        {
            return INT32_MAX;
        }
    };
 
 
    template<>
    struct NumericLimits<int64_t>
    {
        typedef int64_t NumericType;
 
        static constexpr NumericType min()
        {
            return INT64_MIN;
        }
 
        static constexpr NumericType max()
        {
            return INT64_MAX;
        }
    };
 
 
    template<>
    struct NumericLimits<float>
    {
        typedef float NumericType;
 
        static constexpr NumericType min()
        {
            return 1.175494351e-38F;
        }
 
        static constexpr NumericType max()
        {
            return 3.402823466e+38F;
        }
    };
 
 
    template<>
    struct NumericLimits<double>
    {
        typedef double NumericType;
 
        static constexpr NumericType min()
        {
            return 2.2250738585072014e-308;
        }
 
        static constexpr NumericType max()
        {
            return 1.7976931348623158e+308;
        }
    };
 
}