thijn/SqMod
1
0
Fork 0
mirror of https://github.com/VCMP-SqMod/SqMod.git synced 2024-11-08 00:37:15 +01:00
Code Releases Activity

Use direct integer type names instead of fixed size types.

Browse Source
This commit is contained in:
Sandu Liviu Catalin 2021-01-31 23:18:28 +02:00
parent 2ad78d66f4
commit 3c33af7640
2 changed files with 212 additions and 212 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

72
module/Core/Utility.cpp
View File

@ -16,7 +16,7 @@ namespace SqMod {
static SQChar g_NumBuf[1024]; static SQChar g_NumBuf[1024];
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
const SQChar * ConvNum< int8_t >::ToStr(int8_t v) const SQChar * ConvNum< signed char >::ToStr(signed char v)
{ {
// Write the numeric value to the buffer // Write the numeric value to the buffer
if (std::snprintf(g_NumBuf, sizeof(g_NumBuf), "%d", v) < 0) if (std::snprintf(g_NumBuf, sizeof(g_NumBuf), "%d", v) < 0)
@ -27,18 +27,18 @@ const SQChar * ConvNum< int8_t >::ToStr(int8_t v)
return g_NumBuf; return g_NumBuf;
} }
int8_t ConvNum< int8_t >::FromStr(const SQChar * s) signed char ConvNum< signed char >::FromStr(const SQChar * s)
{ {
return ConvTo< int8_t >::From(std::strtol(s, nullptr, 10)); return ConvTo< signed char >::From(std::strtol(s, nullptr, 10));
} }
int8_t ConvNum< int8_t >::FromStr(const SQChar * s, int32_t base) signed char ConvNum< signed char >::FromStr(const SQChar * s, int32_t base)
{ {
return ConvTo< int8_t >::From(std::strtol(s, nullptr, base)); return ConvTo< signed char >::From(std::strtol(s, nullptr, base));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
const SQChar * ConvNum< uint8_t >::ToStr(uint8_t v) const SQChar * ConvNum< unsigned char >::ToStr(unsigned char v)
{ {
// Write the numeric value to the buffer // Write the numeric value to the buffer
if (std::snprintf(g_NumBuf, sizeof(g_NumBuf), "%u", v) < 0) if (std::snprintf(g_NumBuf, sizeof(g_NumBuf), "%u", v) < 0)
@ -49,18 +49,18 @@ const SQChar * ConvNum< uint8_t >::ToStr(uint8_t v)
return g_NumBuf; return g_NumBuf;
} }
uint8_t ConvNum< uint8_t >::FromStr(const SQChar * s) unsigned char ConvNum< unsigned char >::FromStr(const SQChar * s)
{ {
return ConvTo< uint8_t >::From(std::strtoul(s, nullptr, 10)); return ConvTo< unsigned char >::From(std::strtoul(s, nullptr, 10));
} }
uint8_t ConvNum< uint8_t >::FromStr(const SQChar * s, int32_t base) unsigned char ConvNum< unsigned char >::FromStr(const SQChar * s, int32_t base)
{ {
return ConvTo< uint8_t >::From(std::strtoul(s, nullptr, base)); return ConvTo< unsigned char >::From(std::strtoul(s, nullptr, base));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
const SQChar * ConvNum< int16_t >::ToStr(int16_t v) const SQChar * ConvNum< signed short >::ToStr(signed short v)
{ {
// Write the numeric value to the buffer // Write the numeric value to the buffer
if (std::snprintf(g_NumBuf, sizeof(g_NumBuf), "%d", v) < 0) if (std::snprintf(g_NumBuf, sizeof(g_NumBuf), "%d", v) < 0)
@ -71,18 +71,18 @@ const SQChar * ConvNum< int16_t >::ToStr(int16_t v)
return g_NumBuf; return g_NumBuf;
} }
int16_t ConvNum< int16_t >::FromStr(const SQChar * s) signed short ConvNum< signed short >::FromStr(const SQChar * s)
{ {
return ConvTo< int16_t >::From(std::strtol(s, nullptr, 10)); return ConvTo< signed short >::From(std::strtol(s, nullptr, 10));
} }
int16_t ConvNum< int16_t >::FromStr(const SQChar * s, int32_t base) signed short ConvNum< signed short >::FromStr(const SQChar * s, int32_t base)
{ {
return ConvTo< int16_t >::From(std::strtol(s, nullptr, base)); return ConvTo< signed short >::From(std::strtol(s, nullptr, base));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
const SQChar * ConvNum< uint16_t >::ToStr(uint16_t v) const SQChar * ConvNum< unsigned short >::ToStr(unsigned short v)
{ {
// Write the numeric value to the buffer // Write the numeric value to the buffer
if (std::snprintf(g_NumBuf, sizeof(g_NumBuf), "%u", v) < 0) if (std::snprintf(g_NumBuf, sizeof(g_NumBuf), "%u", v) < 0)
@ -93,18 +93,18 @@ const SQChar * ConvNum< uint16_t >::ToStr(uint16_t v)
return g_NumBuf; return g_NumBuf;
} }
uint16_t ConvNum< uint16_t >::FromStr(const SQChar * s) unsigned short ConvNum< unsigned short >::FromStr(const SQChar * s)
{ {
return ConvTo< uint16_t >::From(std::strtoul(s, nullptr, 10)); return ConvTo< unsigned short >::From(std::strtoul(s, nullptr, 10));
} }
uint16_t ConvNum< uint16_t >::FromStr(const SQChar * s, int32_t base) unsigned short ConvNum< unsigned short >::FromStr(const SQChar * s, int32_t base)
{ {
return ConvTo< uint16_t >::From(std::strtoul(s, nullptr, base)); return ConvTo< unsigned short >::From(std::strtoul(s, nullptr, base));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
const SQChar * ConvNum< int32_t >::ToStr(int32_t v) const SQChar * ConvNum< signed int >::ToStr(signed int v)
{ {
// Write the numeric value to the buffer // Write the numeric value to the buffer
if (std::snprintf(g_NumBuf, sizeof(g_NumBuf), "%d", v) < 0) if (std::snprintf(g_NumBuf, sizeof(g_NumBuf), "%d", v) < 0)
@ -115,18 +115,18 @@ const SQChar * ConvNum< int32_t >::ToStr(int32_t v)
return g_NumBuf; return g_NumBuf;
} }
int32_t ConvNum< int32_t >::FromStr(const SQChar * s) signed int ConvNum< signed int >::FromStr(const SQChar * s)
{ {
return ConvTo< int32_t >::From(std::strtol(s, nullptr, 10)); return ConvTo< signed int >::From(std::strtol(s, nullptr, 10));
} }
int32_t ConvNum< int32_t >::FromStr(const SQChar * s, int32_t base) signed int ConvNum< signed int >::FromStr(const SQChar * s, signed int base)
{ {
return ConvTo< int32_t >::From(std::strtol(s, nullptr, base)); return ConvTo< signed int >::From(std::strtol(s, nullptr, base));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
const SQChar * ConvNum< uint32_t >::ToStr(uint32_t v) const SQChar * ConvNum< unsigned int >::ToStr(unsigned int v)
{ {
// Write the numeric value to the buffer // Write the numeric value to the buffer
if (std::snprintf(g_NumBuf, sizeof(g_NumBuf), "%u", v) < 0) if (std::snprintf(g_NumBuf, sizeof(g_NumBuf), "%u", v) < 0)
@ -137,18 +137,18 @@ const SQChar * ConvNum< uint32_t >::ToStr(uint32_t v)
return g_NumBuf; return g_NumBuf;
} }
uint32_t ConvNum< uint32_t >::FromStr(const SQChar * s) unsigned int ConvNum< unsigned int >::FromStr(const SQChar * s)
{ {
return ConvTo< uint32_t >::From(std::strtoul(s, nullptr, 10)); return ConvTo< unsigned int >::From(std::strtoul(s, nullptr, 10));
} }
uint32_t ConvNum< uint32_t >::FromStr(const SQChar * s, int32_t base) unsigned int ConvNum< unsigned int >::FromStr(const SQChar * s, signed int base)
{ {
return ConvTo< uint32_t >::From(std::strtoul(s, nullptr, base)); return ConvTo< unsigned int >::From(std::strtoul(s, nullptr, base));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
const SQChar * ConvNum< int64_t >::ToStr(int64_t v) const SQChar * ConvNum< signed long long >::ToStr(signed long long v)
{ {
// Write the numeric value to the buffer // Write the numeric value to the buffer
if (std::snprintf(g_NumBuf, sizeof(g_NumBuf), "%lld", v) < 0) if (std::snprintf(g_NumBuf, sizeof(g_NumBuf), "%lld", v) < 0)
@ -159,18 +159,18 @@ const SQChar * ConvNum< int64_t >::ToStr(int64_t v)
return g_NumBuf; return g_NumBuf;
} }
int64_t ConvNum< int64_t >::FromStr(const SQChar * s) signed long long ConvNum< signed long long >::FromStr(const SQChar * s)
{ {
return std::strtoll(s, nullptr, 10); return std::strtoll(s, nullptr, 10);
} }
int64_t ConvNum< int64_t >::FromStr(const SQChar * s, int32_t base) signed long long ConvNum< signed long long >::FromStr(const SQChar * s, int32_t base)
{ {
return std::strtoll(s, nullptr, base); return std::strtoll(s, nullptr, base);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
const SQChar * ConvNum< uint64_t >::ToStr(uint64_t v) const SQChar * ConvNum< unsigned long long >::ToStr(unsigned long long v)
{ {
// Write the numeric value to the buffer // Write the numeric value to the buffer
if (std::snprintf(g_NumBuf, sizeof(g_NumBuf), "%llu", v) < 0) if (std::snprintf(g_NumBuf, sizeof(g_NumBuf), "%llu", v) < 0)
@ -181,12 +181,12 @@ const SQChar * ConvNum< uint64_t >::ToStr(uint64_t v)
return g_NumBuf; return g_NumBuf;
} }
uint64_t ConvNum< uint64_t >::FromStr(const SQChar * s) unsigned long long ConvNum< unsigned long long >::FromStr(const SQChar * s)
{ {
return std::strtoull(s, nullptr, 10); return std::strtoull(s, nullptr, 10);
} }
uint64_t ConvNum< uint64_t >::FromStr(const SQChar * s, int32_t base) unsigned long long ConvNum< unsigned long long >::FromStr(const SQChar * s, int32_t base)
{ {
return std::strtoull(s, nullptr, base); return std::strtoull(s, nullptr, base);
} }

352
module/Core/Utility.hpp
View File

@ -9,7 +9,7 @@ namespace SqMod {
/* ------------------------------------------------------------------------------------------------ /* ------------------------------------------------------------------------------------------------
* Compute the next power of two for the specified number. * Compute the next power of two for the specified number.
*/ */
SQMOD_NODISCARD inline uint32_t NextPow2(uint32_t num) SQMOD_NODISCARD inline unsigned int NextPow2(unsigned int num)
{ {
--num; --num;
num |= num >> 1u; num |= num >> 1u;
@ -200,95 +200,95 @@ template < typename T > struct ConvNum;
* Specializations for each numeric type conversion to string and/or backwards. * Specializations for each numeric type conversion to string and/or backwards.
*/ */
template <> struct ConvNum< int8_t > template <> struct ConvNum< signed char >
{ {
static const char * ToStr(int8_t v); static const char * ToStr(signed char v);
static int8_t FromStr(const char * s); static signed char FromStr(const char * s);
static int8_t FromStr(const char * s, int32_t base); static signed char FromStr(const char * s, signed int base);
}; };
template <> struct ConvNum< uint8_t > template <> struct ConvNum< unsigned char >
{ {
static const char * ToStr(uint8_t v); static const char * ToStr(unsigned char v);
static uint8_t FromStr(const char * s); static unsigned char FromStr(const char * s);
static uint8_t FromStr(const char * s, int32_t base); static unsigned char FromStr(const char * s, signed int base);
}; };
template <> struct ConvNum< int16_t > template <> struct ConvNum< signed short >
{ {
static const char * ToStr(int16_t v); static const char * ToStr(signed short v);
static int16_t FromStr(const char * s); static signed short FromStr(const char * s);
static int16_t FromStr(const char * s, int32_t base); static signed short FromStr(const char * s, signed int base);
}; };
template <> struct ConvNum< uint16_t > template <> struct ConvNum< unsigned short >
{ {
static const char * ToStr(uint16_t v); static const char * ToStr(unsigned short v);
static uint16_t FromStr(const char * s); static unsigned short FromStr(const char * s);
static uint16_t FromStr(const char * s, int32_t base); static unsigned short FromStr(const char * s, signed int base);
}; };
template <> struct ConvNum< int32_t > template <> struct ConvNum< signed int >
{ {
static const char * ToStr(int32_t v); static const char * ToStr(signed int v);
static int32_t FromStr(const char * s); static signed int FromStr(const char * s);
static int32_t FromStr(const char * s, int32_t base); static signed int FromStr(const char * s, signed int base);
}; };
template <> struct ConvNum< uint32_t > template <> struct ConvNum< unsigned int >
{ {
static const char * ToStr(uint32_t v); static const char * ToStr(unsigned int v);
static uint32_t FromStr(const char * s); static unsigned int FromStr(const char * s);
static uint32_t FromStr(const char * s, int32_t base); static unsigned int FromStr(const char * s, signed int base);
}; };
template <> struct ConvNum< int64_t > template <> struct ConvNum< signed long long >
{ {
static const char * ToStr(int64_t v); static const char * ToStr(signed long long v);
static int64_t FromStr(const char * s); static signed long long FromStr(const char * s);
static int64_t FromStr(const char * s, int32_t base); static signed long long FromStr(const char * s, signed int base);
}; };
template <> struct ConvNum< uint64_t > template <> struct ConvNum< unsigned long long >
{ {
static const char * ToStr(uint64_t v); static const char * ToStr(unsigned long long v);
static uint64_t FromStr(const char * s); static unsigned long long FromStr(const char * s);
static uint64_t FromStr(const char * s, int32_t base); static unsigned long long FromStr(const char * s, signed int base);
}; };
template <> struct ConvNum< long > template <> struct ConvNum< long >
{ {
static const char * ToStr(long v); static const char * ToStr(long v);
static long FromStr(const char * s); static long FromStr(const char * s);
static long FromStr(const char * s, int32_t base); static long FromStr(const char * s, signed int base);
}; };
template <> struct ConvNum< unsigned long > template <> struct ConvNum< unsigned long >
{ {
static const char * ToStr(unsigned long v); static const char * ToStr(unsigned long v);
static unsigned long FromStr(const char * s); static unsigned long FromStr(const char * s);
static unsigned long FromStr(const char * s, int32_t base); static unsigned long FromStr(const char * s, signed int base);
}; };
template <> struct ConvNum< float > template <> struct ConvNum< float >
{ {
static const char * ToStr(float v); static const char * ToStr(float v);
static float FromStr(const char * s); static float FromStr(const char * s);
static float FromStr(const char * s, int32_t base); static float FromStr(const char * s, signed int base);
}; };
template <> struct ConvNum< double > template <> struct ConvNum< double >
{ {
static const char * ToStr(double v); static const char * ToStr(double v);
static double FromStr(const char * s); static double FromStr(const char * s);
static double FromStr(const char * s, int32_t base); static double FromStr(const char * s, signed int base);
}; };
template <> struct ConvNum< bool > template <> struct ConvNum< bool >
{ {
static const char * ToStr(bool v); static const char * ToStr(bool v);
static bool FromStr(const char * s); static bool FromStr(const char * s);
static bool FromStr(const char * s, int32_t base); static bool FromStr(const char * s, signed int base);
}; };
/* ------------------------------------------------------------------------------------------------ /* ------------------------------------------------------------------------------------------------
@ -318,267 +318,267 @@ template < typename T > struct ConvTo
/* ------------------------------------------------------------------------------------------------ /* ------------------------------------------------------------------------------------------------
* Convert a string to 8/16/32 bit signed integers. * Convert a string to 8/16/32 bit signed integers.
*/ */
template <> template <> inline int8_t ConvTo< int8_t >::From< const char * >(const char * v) template <> template <> inline signed char ConvTo< signed char >::From< const char * >(const char * v)
{ {
return ConvNum< int8_t >::FromStr(v); return ConvNum< signed char >::FromStr(v);
} }
template <> template <> inline int16_t ConvTo< int16_t >::From< const char * >(const char * v) template <> template <> inline signed short ConvTo< signed short >::From< const char * >(const char * v)
{ {
return ConvNum< int16_t >::FromStr(v); return ConvNum< signed short >::FromStr(v);
} }
template <> template <> inline int32_t ConvTo< int32_t >::From< const char * >(const char * v) template <> template <> inline signed int ConvTo< signed int >::From< const char * >(const char * v)
{ {
return ConvNum< int32_t >::FromStr(v); return ConvNum< signed int >::FromStr(v);
} }
/* ------------------------------------------------------------------------------------------------ /* ------------------------------------------------------------------------------------------------
* Convert a string to 8/16/32 bit unsigned integers. * Convert a string to 8/16/32 bit unsigned integers.
*/ */
template <> template <> inline uint8_t ConvTo< uint8_t >::From< const char * >(const char * v) template <> template <> inline unsigned char ConvTo< unsigned char >::From< const char * >(const char * v)
{ {
return ConvNum< uint8_t >::FromStr(v); return ConvNum< unsigned char >::FromStr(v);
} }
template <> template <> inline uint16_t ConvTo< uint16_t >::From< const char * >(const char * v) template <> template <> inline unsigned short ConvTo< unsigned short >::From< const char * >(const char * v)
{ {
return ConvNum< uint16_t >::FromStr(v); return ConvNum< unsigned short >::FromStr(v);
} }
template <> template <> inline uint32_t ConvTo< uint32_t >::From< const char * >(const char * v) template <> template <> inline unsigned int ConvTo< unsigned int >::From< const char * >(const char * v)
{ {
return ConvNum< uint32_t >::FromStr(v); return ConvNum< unsigned int >::FromStr(v);
} }
/* ------------------------------------------------------------------------------------------------ /* ------------------------------------------------------------------------------------------------
* Convert to 8 bit signed integer from any unsigned integer. * Convert to 8 bit signed integer from any unsigned integer.
*/ */
template <> template <> inline int8_t ConvTo< int8_t >::From< uint8_t >(uint8_t v) template <> template <> inline signed char ConvTo< signed char >::From< unsigned char >(unsigned char v)
{ {
return (v >= static_cast< uint8_t >(Max)) ? Max : static_cast< int8_t >(v); return (v >= static_cast< unsigned char >(Max)) ? Max : static_cast< signed char >(v);
} }
template <> template <> inline int8_t ConvTo< int8_t >::From< uint16_t >(uint16_t v) template <> template <> inline signed char ConvTo< signed char >::From< unsigned short >(unsigned short v)
{ {
return (v >= static_cast< uint8_t >(Max)) ? Max : static_cast< int8_t >(v); return (v >= static_cast< unsigned char >(Max)) ? Max : static_cast< signed char >(v);
} }
template <> template <> inline int8_t ConvTo< int8_t >::From< uint32_t >(uint32_t v) template <> template <> inline signed char ConvTo< signed char >::From< unsigned int >(unsigned int v)
{ {
return (v >= static_cast< uint8_t >(Max)) ? Max : static_cast< int8_t >(v); return (v >= static_cast< unsigned char >(Max)) ? Max : static_cast< signed char >(v);
} }
template <> template <> inline int8_t ConvTo< int8_t >::From< uint64_t >(uint64_t v) template <> template <> inline signed char ConvTo< signed char >::From< unsigned long long >(unsigned long long v)
{ {
return (v >= static_cast< uint8_t >(Max)) ? Max : static_cast< int8_t >(v); return (v >= static_cast< unsigned char >(Max)) ? Max : static_cast< signed char >(v);
} }
template <> template <> inline int8_t ConvTo< int8_t >::From< unsigned long >(unsigned long v) template <> template <> inline signed char ConvTo< signed char >::From< unsigned long >(unsigned long v)
{ {
return (v >= static_cast< uint8_t >(Max)) ? Max : static_cast< int8_t >(v); return (v >= static_cast< unsigned char >(Max)) ? Max : static_cast< signed char >(v);
} }
/* ------------------------------------------------------------------------------------------------ /* ------------------------------------------------------------------------------------------------
* Convert to 16 bit signed integer from any unsigned integer. * Convert to 16 bit signed integer from any unsigned integer.
*/ */
template <> template <> inline int16_t ConvTo< int16_t >::From< uint8_t >(uint8_t v) template <> template <> inline signed short ConvTo< signed short >::From< unsigned char >(unsigned char v)
{ {
return static_cast< int16_t >(v); return static_cast< signed short >(v);
} }
template <> template <> inline int16_t ConvTo< int16_t >::From< uint16_t >(uint16_t v) template <> template <> inline signed short ConvTo< signed short >::From< unsigned short >(unsigned short v)
{ {
return (v >= static_cast< uint16_t >(Max)) ? Max : static_cast< int16_t >(v); return (v >= static_cast< unsigned short >(Max)) ? Max : static_cast< signed short >(v);
} }
template <> template <> inline int16_t ConvTo< int16_t >::From< uint32_t >(uint32_t v) template <> template <> inline signed short ConvTo< signed short >::From< unsigned int >(unsigned int v)
{ {
return (v >= static_cast< uint16_t >(Max)) ? Max : static_cast< int16_t >(v); return (v >= static_cast< unsigned short >(Max)) ? Max : static_cast< signed short >(v);
} }
template <> template <> inline int16_t ConvTo< int16_t >::From< uint64_t >(uint64_t v) template <> template <> inline signed short ConvTo< signed short >::From< unsigned long long >(unsigned long long v)
{ {
return (v >= static_cast< uint16_t >(Max)) ? Max : static_cast< int16_t >(v); return (v >= static_cast< unsigned short >(Max)) ? Max : static_cast< signed short >(v);
} }
template <> template <> inline int16_t ConvTo< int16_t >::From< unsigned long >(unsigned long v) template <> template <> inline signed short ConvTo< signed short >::From< unsigned long >(unsigned long v)
{ {
return (v >= static_cast< uint16_t >(Max)) ? Max : static_cast< int16_t >(v); return (v >= static_cast< unsigned short >(Max)) ? Max : static_cast< signed short >(v);
} }
/* ------------------------------------------------------------------------------------------------ /* ------------------------------------------------------------------------------------------------
* Convert to 32 bit signed integer from any unsigned integer. * Convert to 32 bit signed integer from any unsigned integer.
*/ */
template <> template <> inline int32_t ConvTo< int32_t >::From< uint8_t >(uint8_t v) template <> template <> inline signed int ConvTo< signed int >::From< unsigned char >(unsigned char v)
{ {
return static_cast< int32_t >(v); return static_cast< signed int >(v);
} }
template <> template <> inline int32_t ConvTo< int32_t >::From< uint16_t >(uint16_t v) template <> template <> inline signed int ConvTo< signed int >::From< unsigned short >(unsigned short v)
{ {
return static_cast< int32_t >(v); return static_cast< signed int >(v);
} }
template <> template <> inline int32_t ConvTo< int32_t >::From< uint32_t >(uint32_t v) template <> template <> inline signed int ConvTo< signed int >::From< unsigned int >(unsigned int v)
{ {
return (v >= static_cast< uint32_t >(Max)) ? Max : static_cast< int32_t >(v); return (v >= static_cast< unsigned int >(Max)) ? Max : static_cast< signed int >(v);
} }
template <> template <> inline int32_t ConvTo< int32_t >::From< uint64_t >(uint64_t v) template <> template <> inline signed int ConvTo< signed int >::From< unsigned long long >(unsigned long long v)
{ {
return (v >= static_cast< uint32_t >(Max)) ? Max : static_cast< int32_t >(v); return (v >= static_cast< unsigned int >(Max)) ? Max : static_cast< signed int >(v);
} }
template <> template <> inline int32_t ConvTo< int32_t >::From< unsigned long >(unsigned long v) template <> template <> inline signed int ConvTo< signed int >::From< unsigned long >(unsigned long v)
{ {
return (v >= static_cast< uint32_t >(Max)) ? Max : static_cast< int32_t >(v); return (v >= static_cast< unsigned int >(Max)) ? Max : static_cast< signed int >(v);
} }
/* ------------------------------------------------------------------------------------------------ /* ------------------------------------------------------------------------------------------------
* Convert to 8 bit unsigned integer from any signed integer. * Convert to 8 bit unsigned integer from any signed integer.
*/ */
template <> template <> inline uint8_t ConvTo< uint8_t >::From< int8_t >(int8_t v) template <> template <> inline unsigned char ConvTo< unsigned char >::From< signed char >(signed char v)
{ {
return (v <= 0) ? static_cast< uint8_t >(0) : static_cast< uint8_t >(v); return (v <= 0) ? static_cast< unsigned char >(0) : static_cast< unsigned char >(v);
} }
template <> template <> inline uint8_t ConvTo< uint8_t >::From< int16_t >(int16_t v) template <> template <> inline unsigned char ConvTo< unsigned char >::From< signed short >(signed short v)
{ {
if (v <= 0) if (v <= 0)
{ {
return 0; return 0;
} }
else if (v >= static_cast< int16_t >(Max)) else if (v >= static_cast< signed short >(Max))
{ {
return Max; return Max;
} }
return static_cast< uint8_t >(v); return static_cast< unsigned char >(v);
} }
template <> template <> inline uint8_t ConvTo< uint8_t >::From< int32_t >(int32_t v) template <> template <> inline unsigned char ConvTo< unsigned char >::From< signed int >(signed int v)
{ {
if (v <= 0) if (v <= 0)
{ {
return 0; return 0;
} }
else if (v >= static_cast< int16_t >(Max)) else if (v >= static_cast< signed short >(Max))
{ {
return Max; return Max;
} }
return static_cast< uint8_t >(v); return static_cast< unsigned char >(v);
} }
template <> template <> inline uint8_t ConvTo< uint8_t >::From< int64_t >(int64_t v) template <> template <> inline unsigned char ConvTo< unsigned char >::From< signed long long >(signed long long v)
{ {
if (v <= 0) if (v <= 0)
{ {
return 0; return 0;
} }
else if (v >= static_cast< int16_t >(Max)) else if (v >= static_cast< signed short >(Max))
{ {
return Max; return Max;
} }
return static_cast< uint8_t >(v); return static_cast< unsigned char >(v);
} }
template <> template <> inline uint8_t ConvTo< uint8_t >::From< long >(long v) template <> template <> inline unsigned char ConvTo< unsigned char >::From< long >(long v)
{ {
if (v <= 0) if (v <= 0)
{ {
return 0; return 0;
} }
else if (v >= static_cast< int16_t >(Max)) else if (v >= static_cast< signed short >(Max))
{ {
return Max; return Max;
} }
return static_cast< uint8_t >(v); return static_cast< unsigned char >(v);
} }
/* ------------------------------------------------------------------------------------------------ /* ------------------------------------------------------------------------------------------------
* Convert to 16 bit unsigned integer from any signed integer. * Convert to 16 bit unsigned integer from any signed integer.
*/ */
template <> template <> inline uint16_t ConvTo< uint16_t >::From< int8_t >(int8_t v) template <> template <> inline unsigned short ConvTo< unsigned short >::From< signed char >(signed char v)
{ {
return (v <= 0) ? static_cast< uint16_t >(0) : static_cast< uint16_t >(v); return (v <= 0) ? static_cast< unsigned short >(0) : static_cast< unsigned short >(v);
} }
template <> template <> inline uint16_t ConvTo< uint16_t >::From< int16_t >(int16_t v) template <> template <> inline unsigned short ConvTo< unsigned short >::From< signed short >(signed short v)
{ {
return (v <= 0) ? static_cast< uint16_t >(0) : static_cast< uint16_t >(v); return (v <= 0) ? static_cast< unsigned short >(0) : static_cast< unsigned short >(v);
} }
template <> template <> inline uint16_t ConvTo< uint16_t >::From< int32_t >(int32_t v) template <> template <> inline unsigned short ConvTo< unsigned short >::From< signed int >(signed int v)
{ {
if (v <= 0) if (v <= 0)
{ {
return 0; return 0;
} }
else if (v >= static_cast< int32_t >(Max)) else if (v >= static_cast< signed int >(Max))
{ {
return Max; return Max;
} }
return static_cast< uint16_t >(v); return static_cast< unsigned short >(v);
} }
template <> template <> inline uint16_t ConvTo< uint16_t >::From< int64_t >(int64_t v) template <> template <> inline unsigned short ConvTo< unsigned short >::From< signed long long >(signed long long v)
{ {
if (v <= 0) if (v <= 0)
{ {
return 0; return 0;
} }
else if (v >= static_cast< int32_t >(Max)) else if (v >= static_cast< signed int >(Max))
{ {
return Max; return Max;
} }
return static_cast< uint16_t >(v); return static_cast< unsigned short >(v);
} }
template <> template <> inline uint16_t ConvTo< uint16_t >::From< long >(long v) template <> template <> inline unsigned short ConvTo< unsigned short >::From< long >(long v)
{ {
if (v <= 0) if (v <= 0)
{ {
return 0; return 0;
} }
else if (v >= static_cast< int32_t >(Max)) else if (v >= static_cast< signed int >(Max))
{ {
return Max; return Max;
} }
return static_cast< uint16_t >(v); return static_cast< unsigned short >(v);
} }
/* ------------------------------------------------------------------------------------------------ /* ------------------------------------------------------------------------------------------------
* Convert to 32 bit unsigned integer from any signed integer. * Convert to 32 bit unsigned integer from any signed integer.
*/ */
template <> template <> inline uint32_t ConvTo< uint32_t >::From< int8_t >(int8_t v) template <> template <> inline unsigned int ConvTo< unsigned int >::From< signed char >(signed char v)
{ {
return (v <= 0) ? 0 : static_cast< uint32_t >(v); return (v <= 0) ? 0 : static_cast< unsigned int >(v);
} }
template <> template <> inline uint32_t ConvTo< uint32_t >::From< int16_t >(int16_t v) template <> template <> inline unsigned int ConvTo< unsigned int >::From< signed short >(signed short v)
{ {
return (v <= 0) ? 0 : static_cast< uint32_t >(v); return (v <= 0) ? 0 : static_cast< unsigned int >(v);
} }
template <> template <> inline uint32_t ConvTo< uint32_t >::From< int32_t >(int32_t v) template <> template <> inline unsigned int ConvTo< unsigned int >::From< signed int >(signed int v)
{ {
return (v <= 0) ? 0 : static_cast< uint32_t >(v); return (v <= 0) ? 0 : static_cast< unsigned int >(v);
} }
template <> template <> inline uint32_t ConvTo< uint32_t >::From< int64_t >(int64_t v) template <> template <> inline unsigned int ConvTo< unsigned int >::From< signed long long >(signed long long v)
{ {
if (v <= 0) if (v <= 0)
{ {
return 0; return 0;
} }
else if (v >= static_cast< int64_t >(Max)) else if (v >= static_cast< signed long long >(Max))
{ {
return Max; return Max;
} }
return static_cast< uint32_t >(v); return static_cast< unsigned int >(v);
} }
template <> template <> inline uint32_t ConvTo< uint32_t >::From< long >(long v) template <> template <> inline unsigned int ConvTo< unsigned int >::From< long >(long v)
{ {
#if (ULONG_MAX > UINT_MAX) #if (ULONG_MAX > UINT_MAX)
@ -586,14 +586,14 @@ template <> template <> inline uint32_t ConvTo< uint32_t >::From< long >(long v)
{ {
return 0; return 0;
} }
else if (v >= static_cast< int64_t >(Max)) else if (v >= static_cast< signed long long >(Max))
{ {
return Max; return Max;
} }
return static_cast< uint32_t >(v); return static_cast< unsigned int >(v);
#else #else
return (v <= 0) ? 0 : static_cast< uint32_t >(v); return (v <= 0) ? 0 : static_cast< unsigned int >(v);
#endif #endif
} }
@ -601,7 +601,7 @@ template <> template <> inline uint32_t ConvTo< uint32_t >::From< long >(long v)
/* ------------------------------------------------------------------------------------------------ /* ------------------------------------------------------------------------------------------------
* Convert to signed integer from 32 bit floating point number. * Convert to signed integer from 32 bit floating point number.
*/ */
template <> template <> inline int8_t ConvTo< int8_t >::From< float >(float v) template <> template <> inline signed char ConvTo< signed char >::From< float >(float v)
{ {
if (EpsLt(v, Min)) if (EpsLt(v, Min))
{ {
@ -611,10 +611,10 @@ template <> template <> inline int8_t ConvTo< int8_t >::From< float >(float v)
{ {
return Max; return Max;
} }
return static_cast< int8_t >(v); return static_cast< signed char >(v);
} }
template <> template <> inline int16_t ConvTo< int16_t >::From< float >(float v) template <> template <> inline signed short ConvTo< signed short >::From< float >(float v)
{ {
if (EpsLt(v, Min)) if (EpsLt(v, Min))
{ {
@ -624,10 +624,10 @@ template <> template <> inline int16_t ConvTo< int16_t >::From< float >(float v)
{ {
return Max; return Max;
} }
return static_cast< int16_t >(v); return static_cast< signed short >(v);
} }
template <> template <> inline int32_t ConvTo< int32_t >::From< float >(float v) template <> template <> inline signed int ConvTo< signed int >::From< float >(float v)
{ {
if (EpsLt(v, Min)) if (EpsLt(v, Min))
{ {
@ -637,13 +637,13 @@ template <> template <> inline int32_t ConvTo< int32_t >::From< float >(float v)
{ {
return Max; return Max;
} }
return static_cast< int32_t >(v); return static_cast< signed int >(v);
} }
/* ------------------------------------------------------------------------------------------------ /* ------------------------------------------------------------------------------------------------
* Convert to signed integer from 64 bit floating point number. * Convert to signed integer from 64 bit floating point number.
*/ */
template <> template <> inline int8_t ConvTo< int8_t >::From< double >(double v) template <> template <> inline signed char ConvTo< signed char >::From< double >(double v)
{ {
if (EpsLt(v, Min)) if (EpsLt(v, Min))
{ {
@ -653,10 +653,10 @@ template <> template <> inline int8_t ConvTo< int8_t >::From< double >(double v)
{ {
return Max; return Max;
} }
return static_cast< int8_t >(v); return static_cast< signed char >(v);
} }
template <> template <> inline int16_t ConvTo< int16_t >::From< double >(double v) template <> template <> inline signed short ConvTo< signed short >::From< double >(double v)
{ {
if (EpsLt(v, Min)) if (EpsLt(v, Min))
{ {
@ -666,10 +666,10 @@ template <> template <> inline int16_t ConvTo< int16_t >::From< double >(double
{ {
return Max; return Max;
} }
return static_cast< int16_t >(v); return static_cast< signed short >(v);
} }
template <> template <> inline int32_t ConvTo< int32_t >::From< double >(double v) template <> template <> inline signed int ConvTo< signed int >::From< double >(double v)
{ {
if (EpsLt(v, Min)) if (EpsLt(v, Min))
{ {
@ -679,13 +679,13 @@ template <> template <> inline int32_t ConvTo< int32_t >::From< double >(double
{ {
return Max; return Max;
} }
return static_cast< int32_t >(v); return static_cast< signed int >(v);
} }
/* ------------------------------------------------------------------------------------------------ /* ------------------------------------------------------------------------------------------------
* Convert to unsigned integer from 32 bit floating point number. * Convert to unsigned integer from 32 bit floating point number.
*/ */
template <> template <> inline uint8_t ConvTo< uint8_t >::From< float >(float v) template <> template <> inline unsigned char ConvTo< unsigned char >::From< float >(float v)
{ {
if (EpsLt(v, Min)) if (EpsLt(v, Min))
{ {
@ -695,10 +695,10 @@ template <> template <> inline uint8_t ConvTo< uint8_t >::From< float >(float v)
{ {
return Max; return Max;
} }
return static_cast< uint8_t >(v); return static_cast< unsigned char >(v);
} }
template <> template <> inline uint16_t ConvTo< uint16_t >::From< float >(float v) template <> template <> inline unsigned short ConvTo< unsigned short >::From< float >(float v)
{ {
if (EpsLt(v, Min)) if (EpsLt(v, Min))
{ {
@ -708,10 +708,10 @@ template <> template <> inline uint16_t ConvTo< uint16_t >::From< float >(float
{ {
return Max; return Max;
} }
return static_cast< uint16_t >(v); return static_cast< unsigned short >(v);
} }
template <> template <> inline uint32_t ConvTo< uint32_t >::From< float >(float v) template <> template <> inline unsigned int ConvTo< unsigned int >::From< float >(float v)
{ {
if (EpsLt(v, Min)) if (EpsLt(v, Min))
{ {
@ -721,13 +721,13 @@ template <> template <> inline uint32_t ConvTo< uint32_t >::From< float >(float
{ {
return Max; return Max;
} }
return static_cast< uint32_t >(v); return static_cast< unsigned int >(v);
} }
/* ------------------------------------------------------------------------------------------------ /* ------------------------------------------------------------------------------------------------
* Convert to unsigned integer from 64 bit floating point number. * Convert to unsigned integer from 64 bit floating point number.
*/ */
template <> template <> inline uint8_t ConvTo< uint8_t >::From< double >(double v) template <> template <> inline unsigned char ConvTo< unsigned char >::From< double >(double v)
{ {
if (EpsLt(v, Min)) if (EpsLt(v, Min))
{ {
@ -737,10 +737,10 @@ template <> template <> inline uint8_t ConvTo< uint8_t >::From< double >(double
{ {
return Max; return Max;
} }
return static_cast< uint8_t >(v); return static_cast< unsigned char >(v);
} }
template <> template <> inline uint16_t ConvTo< uint16_t >::From< double >(double v) template <> template <> inline unsigned short ConvTo< unsigned short >::From< double >(double v)
{ {
if (EpsLt(v, Min)) if (EpsLt(v, Min))
{ {
@ -750,10 +750,10 @@ template <> template <> inline uint16_t ConvTo< uint16_t >::From< double >(doubl
{ {
return Max; return Max;
} }
return static_cast< uint16_t >(v); return static_cast< unsigned short >(v);
} }
template <> template <> inline uint32_t ConvTo< uint32_t >::From< double >(double v) template <> template <> inline unsigned int ConvTo< unsigned int >::From< double >(double v)
{ {
if (EpsLt(v, Min)) if (EpsLt(v, Min))
{ {
@ -763,43 +763,43 @@ template <> template <> inline uint32_t ConvTo< uint32_t >::From< double >(doubl
{ {
return Max; return Max;
} }
return static_cast< uint32_t >(v); return static_cast< unsigned int >(v);
} }
/* ------------------------------------------------------------------------------------------------ /* ------------------------------------------------------------------------------------------------
* Convert other numeric values to 64 bit signed integer. * Convert other numeric values to 64 bit signed integer.
*/ */
template <> struct ConvTo< int64_t > template <> struct ConvTo< signed long long >
{ {
// -------------------------------------------------------------------------------------------- // --------------------------------------------------------------------------------------------
static constexpr int64_t Min = std::numeric_limits< int64_t >::min(); static constexpr signed long long Min = std::numeric_limits< signed long long >::min();
static constexpr int64_t Max = std::numeric_limits< int64_t >::max(); static constexpr signed long long Max = std::numeric_limits< signed long long >::max();
// -------------------------------------------------------------------------------------------- // --------------------------------------------------------------------------------------------
template < typename T > static inline int64_t From(T v) template < typename T > static inline signed long long From(T v)
{ {
return static_cast< int64_t >(v); return static_cast< signed long long >(v);
} }
}; };
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <> inline int64_t ConvTo< int64_t >::From< const char * >(const char * v) template <> inline signed long long ConvTo< signed long long >::From< const char * >(const char * v)
{ {
return ConvNum< int64_t >::FromStr(v); return ConvNum< signed long long >::FromStr(v);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <> inline int64_t ConvTo< int64_t >::From< uint64_t >(uint64_t v) template <> inline signed long long ConvTo< signed long long >::From< unsigned long long >(unsigned long long v)
{ {
return (v >= static_cast< uint64_t >(Max)) ? Max : static_cast< int64_t >(v); return (v >= static_cast< unsigned long long >(Max)) ? Max : static_cast< signed long long >(v);
} }
#if (ULONG_MAX > UINT_MAX) #if (ULONG_MAX > UINT_MAX)
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <> inline int64_t ConvTo< int64_t >::From< unsigned long >(unsigned long v) template <> inline signed long long ConvTo< signed long long >::From< unsigned long >(unsigned long v)
{ {
return (v >= static_cast< unsigned long >(Max)) ? Max : static_cast< int64_t >(v); return (v >= static_cast< unsigned long >(Max)) ? Max : static_cast< signed long long >(v);
} }
#endif #endif
@ -807,35 +807,35 @@ template <> inline int64_t ConvTo< int64_t >::From< unsigned long >(unsigned lon
/* ------------------------------------------------------------------------------------------------ /* ------------------------------------------------------------------------------------------------
* Convert other numeric values to 64 bit unsigned integer. * Convert other numeric values to 64 bit unsigned integer.
*/ */
template <> struct ConvTo< uint64_t > template <> struct ConvTo< unsigned long long >
{ {
// -------------------------------------------------------------------------------------------- // --------------------------------------------------------------------------------------------
static constexpr uint64_t Min = std::numeric_limits< uint64_t >::min(); static constexpr unsigned long long Min = std::numeric_limits< unsigned long long >::min();
static constexpr uint64_t Max = std::numeric_limits< uint64_t >::max(); static constexpr unsigned long long Max = std::numeric_limits< unsigned long long >::max();
// -------------------------------------------------------------------------------------------- // --------------------------------------------------------------------------------------------
template < typename T > static inline uint64_t From(T v) template < typename T > static inline unsigned long long From(T v)
{ {
return (v <= static_cast< T >(0)) ? 0 : static_cast< uint64_t >(v); return (v <= static_cast< T >(0)) ? 0 : static_cast< unsigned long long >(v);
} }
}; };
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <> inline uint64_t ConvTo< uint64_t >::From< const char * >(const char * v) template <> inline unsigned long long ConvTo< unsigned long long >::From< const char * >(const char * v)
{ {
return ConvNum< uint64_t >::FromStr(v); return ConvNum< unsigned long long >::FromStr(v);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <> inline uint64_t ConvTo< uint64_t >::From< float >(float v) template <> inline unsigned long long ConvTo< unsigned long long >::From< float >(float v)
{ {
return From(ConvTo< int64_t >::From(v)); return From(ConvTo< signed long long >::From(v));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <> inline uint64_t ConvTo< uint64_t >::From< double >(double v) template <> inline unsigned long long ConvTo< unsigned long long >::From< double >(double v)
{ {
return From(ConvTo< int64_t >::From(v)); return From(ConvTo< signed long long >::From(v));
} }
/* ------------------------------------------------------------------------------------------------ /* ------------------------------------------------------------------------------------------------
@ -863,17 +863,17 @@ template <> inline long ConvTo< long >::From< const char * >(const char * v)
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
#if (ULONG_MAX <= UINT_MAX) #if (ULONG_MAX <= UINT_MAX)
template <> inline long ConvTo< long >::From< uint32_t >(uint32_t v) template <> inline long ConvTo< long >::From< unsigned int >(unsigned int v)
{ {
return (v >= static_cast< uint32_t >(Max)) ? Max : static_cast< long >(v); return (v >= static_cast< unsigned int >(Max)) ? Max : static_cast< long >(v);
} }
#endif #endif
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <> inline long ConvTo< long >::From< uint64_t >(uint64_t v) template <> inline long ConvTo< long >::From< unsigned long long >(unsigned long long v)
{ {
return (v >= static_cast< uint64_t >(Max)) ? Max : static_cast< long >(v); return (v >= static_cast< unsigned long long >(Max)) ? Max : static_cast< long >(v);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -907,20 +907,20 @@ template <> inline unsigned long ConvTo< unsigned long >::From< const char * >(c
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
#if (ULONG_MAX <= UINT_MAX) #if (ULONG_MAX <= UINT_MAX)
template <> inline unsigned long ConvTo< unsigned long >::From< int64_t >(int64_t v) template <> inline unsigned long ConvTo< unsigned long >::From< signed long long >(signed long long v)
{ {
if (v <= 0) if (v <= 0)
{ {
return Min; return Min;
} }
else if (v >= static_cast< int64_t >(Max)) else if (v >= static_cast< signed long long >(Max))
{ {
return Max; return Max;
} }
return static_cast< unsigned long >(v); return static_cast< unsigned long >(v);
} }
template <> inline unsigned long ConvTo< unsigned long >::From< uint64_t >(uint64_t v) template <> inline unsigned long ConvTo< unsigned long >::From< unsigned long long >(unsigned long long v)
{ {
return (v >= Max) ? Max : static_cast< unsigned long >(v); return (v >= Max) ? Max : static_cast< unsigned long >(v);
} }
@ -1240,9 +1240,9 @@ public:
}; };
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
typedef BitGuard< uint8_t > BitGuardU8; typedef BitGuard< unsigned char > BitGuardU8;
typedef BitGuard< uint16_t > BitGuardU16; typedef BitGuard< unsigned short > BitGuardU16;
typedef BitGuard< uint32_t > BitGuardU32; typedef BitGuard< unsigned int > BitGuardU32;
/* ------------------------------------------------------------------------------------------------ /* ------------------------------------------------------------------------------------------------
* RAII approach to make sure a value is assigned regardless of what exceptions are thrown. * RAII approach to make sure a value is assigned regardless of what exceptions are thrown.