Loading...
Searching...
No Matches
integral_limits.h
Go to the documentation of this file.
/******************************************************************************
The MIT License(MIT)
Embedded Template Library.
https://github.com/ETLCPP/etl
https://www.etlcpp.com
Copyright(c) 2014 John Wellbelove
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files(the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions :
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
******************************************************************************/
#ifndef ETL_INTEGRAL_LIMITS_INCLUDED
#define ETL_INTEGRAL_LIMITS_INCLUDED
#include "platform.h"
#include "type_traits.h"
#include <limits.h>
#include "private/minmax_push.h"
//*****************************************************************************
//*****************************************************************************
#ifndef LLONG_MAX
#define LLONG_MAX 9223372036854775807LL
#endif
#ifndef LLONG_MIN
#define LLONG_MIN (-LLONG_MAX - 1LL)
#endif
#ifndef ULLONG_MAX
#define ULLONG_MAX 18446744073709551615ULL
#endif
namespace etl
{
namespace private_integral_limits
{
//*****************************************************************************
//*****************************************************************************
//*********************************
// signed char
template <typename T = void>
struct statics_signed_char
{
typedef signed char value_type;
static ETL_CONSTANT signed char min = SCHAR_MIN;
static ETL_CONSTANT signed char max = SCHAR_MAX;
static ETL_CONSTANT int bits = CHAR_BIT;
static ETL_CONSTANT bool is_signed = etl::is_signed<signed char>::value;
};
template <typename T>
ETL_CONSTANT signed char statics_signed_char<T>::min;
template <typename T>
ETL_CONSTANT signed char statics_signed_char<T>::max;
template <typename T>
ETL_CONSTANT int statics_signed_char<T>::bits;
template <typename T>
ETL_CONSTANT bool statics_signed_char<T>::is_signed;
//***********************************
// unsigned char
template <typename T = void>
struct statics_unsigned_char
{
typedef unsigned char value_type;
static ETL_CONSTANT unsigned char min = 0;
static ETL_CONSTANT unsigned char max = UCHAR_MAX;
static ETL_CONSTANT int bits = CHAR_BIT;
static ETL_CONSTANT bool is_signed = etl::is_signed<unsigned char>::value;
};
template <typename T>
ETL_CONSTANT unsigned char statics_unsigned_char<T>::min;
template <typename T>
ETL_CONSTANT unsigned char statics_unsigned_char<T>::max;
template <typename T>
ETL_CONSTANT int statics_unsigned_char<T>::bits;
template <typename T>
ETL_CONSTANT bool statics_unsigned_char<T>::is_signed;
//***********************************
// char
template <typename T = void>
struct statics_char
{
typedef char value_type;
static ETL_CONSTANT char min = (etl::is_signed<char>::value) ? SCHAR_MIN : 0;
static ETL_CONSTANT char max = (etl::is_signed<char>::value) ? SCHAR_MAX : static_cast<char>(UCHAR_MAX);
static ETL_CONSTANT int bits = CHAR_BIT;
static ETL_CONSTANT bool is_signed = etl::is_signed<char>::value;
};
template <typename T>
ETL_CONSTANT char statics_char<T>::min;
template <typename T>
ETL_CONSTANT char statics_char<T>::max;
template <typename T>
ETL_CONSTANT int statics_char<T>::bits;
template <typename T>
ETL_CONSTANT bool statics_char<T>::is_signed;
//***********************************
// wchar_t
template <typename T = void>
struct statics_wchar_t
{
typedef wchar_t value_type;
static ETL_CONSTANT wchar_t min = WCHAR_MIN;
static ETL_CONSTANT wchar_t max = WCHAR_MAX;
static ETL_CONSTANT int bits = CHAR_BIT * sizeof(wchar_t);
static ETL_CONSTANT bool is_signed = etl::is_signed<wchar_t>::value;
};
template <typename T>
ETL_CONSTANT wchar_t statics_wchar_t<T>::min;
template <typename T>
ETL_CONSTANT wchar_t statics_wchar_t<T>::max;
template <typename T>
ETL_CONSTANT int statics_wchar_t<T>::bits;
template <typename T>
ETL_CONSTANT bool statics_wchar_t<T>::is_signed;
//***********************************
// short
#if defined(ETL_COMPILER_MICROSOFT)
#pragma warning(push)
#pragma warning(disable : 4309)
#endif
template <typename T = void>
struct statics_short
{
typedef short value_type;
static ETL_CONSTANT short min = SHRT_MIN;
static ETL_CONSTANT short max = SHRT_MAX;
static ETL_CONSTANT int bits = CHAR_BIT * (sizeof(short) / sizeof(char));
static ETL_CONSTANT bool is_signed = etl::is_signed<short>::value;
};
template <typename T>
ETL_CONSTANT short statics_short<T>::min;
template <typename T>
ETL_CONSTANT short statics_short<T>::max;
template <typename T>
ETL_CONSTANT int statics_short<T>::bits;
template <typename T>
ETL_CONSTANT bool statics_short<T>::is_signed;
#if defined(ETL_COMPILER_MICROSOFT)
#pragma warning(pop)
#endif
//***********************************
// unsigned short
template <typename T = void>
struct statics_unsigned_short
{
typedef unsigned short value_type;
static ETL_CONSTANT unsigned short min = 0;
static ETL_CONSTANT unsigned short max = USHRT_MAX;
static ETL_CONSTANT int bits = CHAR_BIT * (sizeof(unsigned short) / sizeof(char));
static ETL_CONSTANT bool is_signed = etl::is_signed<unsigned short>::value;
};
template <typename T>
ETL_CONSTANT unsigned short statics_unsigned_short<T>::min;
template <typename T>
ETL_CONSTANT unsigned short statics_unsigned_short<T>::max;
template <typename T>
ETL_CONSTANT int statics_unsigned_short<T>::bits;
template <typename T>
ETL_CONSTANT bool statics_unsigned_short<T>::is_signed;
//***********************************
// int
template <typename T = void>
struct statics_int
{
typedef int value_type;
static ETL_CONSTANT int min = INT_MIN;
static ETL_CONSTANT int max = INT_MAX;
static ETL_CONSTANT int bits = CHAR_BIT * (sizeof(int) / sizeof(char));
static ETL_CONSTANT bool is_signed = etl::is_signed<int>::value;
};
template <typename T>
ETL_CONSTANT int statics_int<T>::min;
template <typename T>
ETL_CONSTANT int statics_int<T>::max;
template <typename T>
ETL_CONSTANT int statics_int<T>::bits;
template <typename T>
ETL_CONSTANT bool statics_int<T>::is_signed;
//***********************************
// unsigned int
template <typename T = void>
struct statics_unsigned_int
{
typedef unsigned int value_type;
static ETL_CONSTANT unsigned int min = 0;
static ETL_CONSTANT unsigned int max = UINT_MAX;
static ETL_CONSTANT int bits = CHAR_BIT * (sizeof(unsigned int) / sizeof(char));
static ETL_CONSTANT bool is_signed = etl::is_signed<unsigned int>::value;
};
template <typename T>
ETL_CONSTANT unsigned int statics_unsigned_int<T>::min;
template <typename T>
ETL_CONSTANT unsigned int statics_unsigned_int<T>::max;
template <typename T>
ETL_CONSTANT int statics_unsigned_int<T>::bits;
template <typename T>
ETL_CONSTANT bool statics_unsigned_int<T>::is_signed;
//***********************************
// long
template <typename T = void>
struct statics_long
{
typedef long value_type;
static ETL_CONSTANT long min = LONG_MIN;
static ETL_CONSTANT long max = LONG_MAX;
static ETL_CONSTANT int bits = CHAR_BIT * (sizeof(long) / sizeof(char));
static ETL_CONSTANT bool is_signed = etl::is_signed<long>::value;
};
template <typename T>
ETL_CONSTANT long statics_long<T>::min;
template <typename T>
ETL_CONSTANT long statics_long<T>::max;
template <typename T>
ETL_CONSTANT int statics_long<T>::bits;
template <typename T>
ETL_CONSTANT bool statics_long<T>::is_signed;
//***********************************
// unsigned long
template <typename T = void>
struct statics_unsigned_long
{
typedef unsigned long value_type;
static ETL_CONSTANT unsigned long min = 0;
static ETL_CONSTANT unsigned long max = ULONG_MAX;
static ETL_CONSTANT int bits = CHAR_BIT * (sizeof(unsigned long) / sizeof(char));
static ETL_CONSTANT bool is_signed = etl::is_signed<unsigned long>::value;
};
template <typename T>
ETL_CONSTANT unsigned long statics_unsigned_long<T>::min;
template <typename T>
ETL_CONSTANT unsigned long statics_unsigned_long<T>::max;
template <typename T>
ETL_CONSTANT int statics_unsigned_long<T>::bits;
template <typename T>
ETL_CONSTANT bool statics_unsigned_long<T>::is_signed;
//***********************************
// long long
template <typename T = void>
struct statics_long_long
{
typedef long long value_type;
static ETL_CONSTANT long long min = LLONG_MIN;
static ETL_CONSTANT long long max = LLONG_MAX;
static ETL_CONSTANT int bits = CHAR_BIT * (sizeof(long long) / sizeof(char));
static ETL_CONSTANT bool is_signed = etl::is_signed<long long>::value;
};
template <typename T>
ETL_CONSTANT long long statics_long_long<T>::min;
template <typename T>
ETL_CONSTANT long long statics_long_long<T>::max;
template <typename T>
ETL_CONSTANT int statics_long_long<T>::bits;
template <typename T>
ETL_CONSTANT bool statics_long_long<T>::is_signed;
//***********************************
// unsigned long long
template <typename T = void>
struct statics_unsigned_long_long
{
typedef unsigned long value_type;
static ETL_CONSTANT unsigned long long min = 0;
static ETL_CONSTANT unsigned long long max = ULLONG_MAX;
static ETL_CONSTANT int bits = CHAR_BIT * (sizeof(unsigned long long) / sizeof(char));
static ETL_CONSTANT bool is_signed = etl::is_signed<unsigned long long>::value;
};
template <typename T>
ETL_CONSTANT unsigned long long statics_unsigned_long_long<T>::min;
template <typename T>
ETL_CONSTANT unsigned long long statics_unsigned_long_long<T>::max;
template <typename T>
ETL_CONSTANT int statics_unsigned_long_long<T>::bits;
template <typename T>
ETL_CONSTANT bool statics_unsigned_long_long<T>::is_signed;
#if ETL_HAS_NATIVE_CHAR8_T
//***********************************
// char8_t
template <typename T = void>
struct statics_char8_t
{
typedef char8_t value_type;
static ETL_CONSTANT char8_t min = static_cast<char8_t>((etl::is_signed<char8_t>::value) ? SCHAR_MIN : 0);
static ETL_CONSTANT char8_t max = (etl::is_signed<char8_t>::value) ? static_cast<char8_t>(SCHAR_MAX) : static_cast<char8_t>(UCHAR_MAX);
static ETL_CONSTANT int bits = CHAR_BIT;
static ETL_CONSTANT bool is_signed = etl::is_signed<char8_t>::value;
};
template <typename T>
ETL_CONSTANT char8_t statics_char8_t<T>::min;
template <typename T>
ETL_CONSTANT char8_t statics_char8_t<T>::max;
template <typename T>
ETL_CONSTANT int statics_char8_t<T>::bits;
template <typename T>
ETL_CONSTANT bool statics_char8_t<T>::is_signed;
#endif
#if ETL_HAS_NATIVE_CHAR16_T
//***********************************
// char16_t
template <typename T = void>
struct statics_char16_t
{
typedef char16_t value_type;
static ETL_CONSTANT char16_t min = 0;
static ETL_CONSTANT char16_t max = 0xFFFFU;
static ETL_CONSTANT int bits = 16;
static ETL_CONSTANT bool is_signed = false;
};
template <typename T>
ETL_CONSTANT char16_t statics_char16_t<T>::min;
template <typename T>
ETL_CONSTANT char16_t statics_char16_t<T>::max;
template <typename T>
ETL_CONSTANT int statics_char16_t<T>::bits;
template <typename T>
ETL_CONSTANT bool statics_char16_t<T>::is_signed;
#endif
#if ETL_HAS_NATIVE_CHAR32_T
//***********************************
// char32_t
template <typename T = void>
struct statics_char32_t
{
typedef char32_t value_type;
static ETL_CONSTANT char32_t min = 0;
static ETL_CONSTANT char32_t max = 0xFFFFFFFFU;
static ETL_CONSTANT int bits = 32;
static ETL_CONSTANT bool is_signed = false;
};
template <typename T>
ETL_CONSTANT char32_t statics_char32_t<T>::min;
template <typename T>
ETL_CONSTANT char32_t statics_char32_t<T>::max;
template <typename T>
ETL_CONSTANT int statics_char32_t<T>::bits;
template <typename T>
ETL_CONSTANT bool statics_char32_t<T>::is_signed;
#endif
#if ETL_USING_20BIT_TYPES
template <typename T = void>
struct statics___int20
{
typedef __int20 value_type;
static ETL_CONSTANT __int20 min = 0x80000;
static ETL_CONSTANT __int20 max = 0x7FFFF;
static ETL_CONSTANT int bits = 20;
static ETL_CONSTANT bool is_signed = true;
};
template <typename T>
ETL_CONSTANT __int20 statics___int20<T>::min;
template <typename T>
ETL_CONSTANT __int20 statics___int20<T>::max;
template <typename T>
ETL_CONSTANT int statics___int20<T>::bits;
template <typename T>
ETL_CONSTANT bool statics___int20<T>::is_signed;
template <typename T = void>
struct statics_unsigned___int20
{
typedef unsigned __int20 value_type;
static ETL_CONSTANT unsigned __int20 min = 0;
static ETL_CONSTANT unsigned __int20 max = 0xFFFFF;
static ETL_CONSTANT int bits = 20;
static ETL_CONSTANT bool is_signed = false;
};
template <typename T>
ETL_CONSTANT unsigned __int20 statics_unsigned___int20<T>::min;
template <typename T>
ETL_CONSTANT unsigned __int20 statics_unsigned___int20<T>::max;
template <typename T>
ETL_CONSTANT int statics_unsigned___int20<T>::bits;
template <typename T>
ETL_CONSTANT bool statics_unsigned___int20<T>::is_signed;
#endif
} // namespace private_integral_limits
//***************************************************************************
//***************************************************************************
template <typename T>
struct integral_limits;
//***************************************************************************
//***************************************************************************
template <>
struct integral_limits<signed char> : public private_integral_limits::statics_signed_char<>
{
};
//***************************************************************************
//***************************************************************************
template <>
struct integral_limits<unsigned char> : public private_integral_limits::statics_unsigned_char<>
{
};
//***************************************************************************
//***************************************************************************
template <>
struct integral_limits<char> : public private_integral_limits::statics_char<>
{
typedef char value_type;
};
//***************************************************************************
//***************************************************************************
template <>
struct integral_limits<short> : public private_integral_limits::statics_short<>
{
};
//***************************************************************************
//***************************************************************************
template <>
struct integral_limits<unsigned short> : public private_integral_limits::statics_unsigned_short<>
{
};
//***************************************************************************
//***************************************************************************
template <>
struct integral_limits<int> : public private_integral_limits::statics_int<>
{
};
//***************************************************************************
//***************************************************************************
template <>
struct integral_limits<unsigned int> : public private_integral_limits::statics_unsigned_int<>
{
};
//***************************************************************************
//***************************************************************************
template <>
struct integral_limits<long> : public private_integral_limits::statics_long<>
{
};
//***************************************************************************
//***************************************************************************
template <>
struct integral_limits<unsigned long> : public private_integral_limits::statics_unsigned_long<>
{
};
//***************************************************************************
//***************************************************************************
template <>
struct integral_limits<long long> : public private_integral_limits::statics_long_long<>
{
};
//***************************************************************************
//***************************************************************************
template <>
struct integral_limits<unsigned long long> : public private_integral_limits::statics_unsigned_long_long<>
{
};
#if ETL_USING_20BIT_TYPES
//***************************************************************************
//***************************************************************************
template <>
struct integral_limits<__int20> : public private_integral_limits::statics___int20<>
{
};
template <>
struct integral_limits<unsigned __int20> : public private_integral_limits::statics_unsigned___int20<>
{
};
#endif
} // namespace etl
#include "private/minmax_pop.h"
#endif
etl::integral_limits
Definition integral_limits.h:517
limits.h
minmax_pop.h
minmax_push.h
etl
Definition absolute.h:40
platform.h
etl::is_signed
is_signed
Definition type_traits.h:458
etl::value_type
etl::private_integral_limits::statics_char
Definition integral_limits.h:128
etl::private_integral_limits::statics_int
Definition integral_limits.h:237
etl::private_integral_limits::statics_long_long
Definition integral_limits.h:337
etl::private_integral_limits::statics_long
Definition integral_limits.h:287
etl::private_integral_limits::statics_short
Definition integral_limits.h:183
etl::private_integral_limits::statics_signed_char
Definition integral_limits.h:78
etl::private_integral_limits::statics_unsigned_char
Definition integral_limits.h:103
etl::private_integral_limits::statics_unsigned_int
Definition integral_limits.h:262
etl::private_integral_limits::statics_unsigned_long_long
Definition integral_limits.h:362
etl::private_integral_limits::statics_unsigned_long
Definition integral_limits.h:312
etl::private_integral_limits::statics_unsigned_short
Definition integral_limits.h:212
etl::private_integral_limits::statics_wchar_t
Definition integral_limits.h:153
type_traits.h