para/GSL
1
0
Fork 0
mirror of https://github.com/microsoft/GSL.git synced 2024-11-03 17:56:43 -05:00
Code Issues Actions Packages Projects Releases Wiki Activity

Add alternative implementations of gsl::byte

Browse Source
This commit is contained in:
MikeGitb 2016-09-18 22:32:56 +02:00
parent 1869ff56b3
commit 31421d5cc3
3 changed files with 199 additions and 6 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

160
gsl/gsl_byte
View File

@ -41,8 +41,167 @@
#endif // _MSC_VER
#define GSL_BYTE_TYPE_ENUM 0
#define GSL_BYTE_TYPE_UCHAR 1
#define GSL_BYTE_TYPE_STRUCT 2
#ifndef GSL_USE_BYTE_TYPE
// currently clang++ as well as g++ don't allow a pointer to
//
// < enum class byte : unsigned char >
//
// to alias other types.
// so we have to use a typedef to unsigned char instead.
#ifdef _MSC_VER
#define GSL_USE_BYTE_TYPE GSL_BYTE_TYPE_ENUM
#else
#define GSL_USE_BYTE_TYPE GSL_BYTE_TYPE_STRUCT
#endif
#endif
namespace gsl
{
//################################### implemet byte as unsigned char ####################################
#if GSL_USE_BYTE_TYPE == GSL_BYTE_TYPE_UCHAR
using byte = unsigned char;
template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
inline constexpr IntegerType to_integer(byte b) noexcept
{
return{ b };
}
template<bool E, typename T>
inline constexpr byte to_byte_impl(T t) noexcept
{
static_assert(
E,
"gsl::to_byte(t) must be provided an unsigned char, otherwise data loss may occur. "
"If you are calling to_byte with an integer contant use: gsl::to_byte<t>() version."
);
return static_cast<byte>(t);
}
template<>
inline constexpr byte to_byte_impl<true, unsigned char>(unsigned char t) noexcept
{
return byte(t);
}
template<typename T>
inline constexpr byte to_byte(T t) noexcept
{
return to_byte_impl<std::is_same<T, unsigned char>::value, T>(t);
}
template <int I>
inline constexpr byte to_byte() noexcept
{
static_assert(I >= 0 && I <= 255, "gsl::byte only has 8 bits of storage, values must be in range 0-255");
return static_cast<byte>(I);
}
//################################### implemet byte as struct ####################################
#elif GSL_USE_BYTE_TYPE == GSL_BYTE_TYPE_STRUCT
// This is a simple definition for now that allows
// use of byte within span<> to be standards-compliant
struct byte {
unsigned char v;
explicit operator unsigned char&() { return v; }
explicit operator const unsigned char&() const { return v; }
friend bool operator==(byte l, byte r) { return l.v == r.v; }
friend bool operator!=(byte l, byte r) { return l.v != r.v; }
};
template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
inline constexpr byte& operator<<=(byte& b, IntegerType shift) noexcept
{
return b.v <<= shift, b;
}
template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
inline constexpr byte operator<<(byte b, IntegerType shift) noexcept
{
return byte{ static_cast<unsigned char>(b.v << shift) };
}
template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
inline constexpr byte& operator>>=(byte& b, IntegerType shift) noexcept
{
return b.v >>= shift, b;
}
template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
inline constexpr byte operator >> (byte b, IntegerType shift) noexcept
{
return byte{ static_cast<unsigned char>(b.v >> shift) };
}
inline constexpr byte& operator|=(byte& l, byte r) noexcept
{
return l.v |= r.v, l;
}
inline constexpr byte operator|(byte l, byte r) noexcept
{
return byte{ static_cast<unsigned char>(l.v | r.v) };
}
inline constexpr byte& operator&=(byte& l, byte r) noexcept
{
return l.v &= r.v, l;
}
inline constexpr byte operator&(byte l, byte r) noexcept
{
return byte{ static_cast<unsigned char>(l.v & r.v) };
}
inline constexpr byte& operator^=(byte& l, byte r) noexcept
{
return l.v ^= r.v, l;
}
inline constexpr byte operator^(byte l, byte r) noexcept
{
return byte{ static_cast<unsigned char>(l.v ^ r.v) };
}
inline constexpr byte operator~(byte b) noexcept { return byte{ static_cast<unsigned char>(~b.v) }; }
template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
inline constexpr IntegerType to_integer(byte b) noexcept
{
return static_cast<IntegerType>(b.v);
}
template<typename T>
inline constexpr byte to_byte(T t) noexcept
{
static_assert(
std::is_same<T, unsigned char>::value,
"gsl::to_byte(t) must be provided an unsigned char, otherwise data loss may occur. "
"If you are calling to_byte with an integer contant use: gsl::to_byte<t>() version."
);
return byte{ t };
}
template <int I>
inline constexpr byte to_byte() noexcept
{
static_assert(I >= 0 && I <= 255, "gsl::byte only has 8 bits of storage, values must be in range 0-255");
return byte{ static_cast<unsigned char>(I) };
}
//################################### implemet byte as enum ####################################
#elif GSL_USE_BYTE_TYPE == GSL_BYTE_TYPE_ENUM
// This is a simple definition for now that allows
// use of byte within span<> to be standards-compliant
enum class byte : unsigned char
@ -139,6 +298,7 @@ inline constexpr byte to_byte() noexcept
static_assert(I >= 0 && I <= 255, "gsl::byte only has 8 bits of storage, values must be in range 0-255");
return static_cast<byte>(I);
}
#endif // GSL_USE_ENUM_BYTE
} // namespace gsl

41
tests/byte_tests.cpp
View File

@ -34,6 +34,17 @@ SUITE(byte_tests)
{
TEST(construction)
{
#if GSL_USE_BYTE_TYPE == GSL_BYTE_TYPE_STRUCT
{
byte b{ 4 };
CHECK(static_cast<unsigned char>(b) == 4);
}
{
byte b = byte{ 12 };
CHECK(static_cast<unsigned char>(b) == 12);
}
#else
{
byte b = static_cast<byte>(4);
CHECK(static_cast<unsigned char>(b) == 4);
@ -43,6 +54,7 @@ SUITE(byte_tests)
byte b = byte(12);
CHECK(static_cast<unsigned char>(b) == 12);
}
#endif
{
byte b = to_byte<12>();
@ -78,32 +90,55 @@ SUITE(byte_tests)
TEST(bitwise_operations)
{
byte b = to_byte<0xFF>();
byte a = to_byte<0x00>();
#if GSL_USE_BYTE_TYPE == GSL_BYTE_TYPE_UCHAR
CHECK(static_cast<byte>(b | a) == to_byte<0xFF>());
#else
CHECK((b | a) == to_byte<0xFF>());
#endif
CHECK(a == to_byte<0x00>());
a |= b;
CHECK(a == to_byte<0xFF>());
a = to_byte<0x01>();
#if GSL_USE_BYTE_TYPE == GSL_BYTE_TYPE_UCHAR
CHECK(static_cast<byte>(b & a) == to_byte<0x01>());
#else
CHECK((b & a) == to_byte<0x01>());
#endif
a &= b;
CHECK(a == to_byte<0x01>());
#if GSL_USE_BYTE_TYPE == GSL_BYTE_TYPE_UCHAR
CHECK(static_cast<byte>(b ^ a) == to_byte<0xFE>());
#else
CHECK((b ^ a) == to_byte<0xFE>());
#endif
CHECK(a == to_byte<0x01>());
a ^= b;
CHECK(a == to_byte<0xFE>());
a = to_byte<0x01>();
#if GSL_USE_BYTE_TYPE == GSL_BYTE_TYPE_UCHAR
CHECK(static_cast<byte>(~a) == to_byte<0xFE>());
#else
CHECK(~a == to_byte<0xFE>());
#endif
a = to_byte<0xFF>();
#if GSL_USE_BYTE_TYPE == GSL_BYTE_TYPE_UCHAR
CHECK(static_cast<byte>(a << 4) == to_byte<0xF0>());
CHECK(static_cast<byte>(a >> 4) == to_byte<0x0F>());
#else
CHECK((a << 4) == to_byte<0xF0>());
CHECK((a >> 4) == to_byte<0x0F>());
#endif
a <<= 4;
CHECK(a == to_byte<0xF0>());
@ -129,7 +164,5 @@ SUITE(byte_tests)
// CHECK(0x12 == gsl::to_integer<double>(b)); // expect compile-time error
}
}
}
int main(int, const char* []) { return UnitTest::RunAllTests(); }

2
tests/multi_span_tests.cpp
View File

@ -1663,7 +1663,7 @@ SUITE(multi_span_tests)
multi_span<int, dynamic_range> av = a;
auto wav = as_writeable_bytes(av);
for (auto& b : wav) {
b = byte(0);
b = to_byte<0>();
}
for (size_t i = 0; i < 4; ++i) {
CHECK(a[i] == 0);