Namespaces
namespace	Core

namespace	Internal

Classes
struct	BitMask

union	Bits16

union	Bits32

union	Bits64

struct	Bits8

class	MallocaDeleter

Concepts
concept	CharType

concept	ApiCharType

concept	SimpleSpanLike
	Matches most containers with sequential memory layout.

concept	SimpleCharSpanLike
	Matches most common string classes with sequential memory layout. Do not assume that they are zero terminated.

concept	SimpleAnsiCharSpanLike
	Matches most common char string classes with sequential memory layout. Do not assume that they are zero terminated.

concept	SimpleWideCharSpanLike
	Matches most common wchar_t string classes with sequential memory layout. Do not assume that they are zero terminated.

concept	SimpleByteSpanLike
	Matches most common container classes with sequential memory layout.

concept	SpanLike

concept	CharSpanLike
	Matches most common string classes with sequential memory layout. Do not assume that they are zero terminated.

concept	AnsiCharSpanLike
	Matches most common char string classes with sequential memory layout. Do not assume that they are zero terminated.

concept	WideCharSpanLike
	Matches most common wchar_t string classes with sequential memory layout. Do not assume that they are zero terminated.

concept	SimpleStringLike
	Matches most common zero terminated C++ string classes with sequential memory layout.

concept	SimpleWideStringLike
	Matches most common zero terminated C++ wchar_t string classes with sequential memory layout.

concept	SimpleAnsiStringLike
	Matches most common zero terminated C++ char string classes with sequential memory layout.

concept	StringLike
	Matches zero terminated C++ string classes with sequential memory layout that implements an API similar to std::basic_string instantiated for either char or wchar_t.

concept	WideStringLike
	Matches zero terminated C++ string classes with sequential memory layout that implements an API similar to std::basic_string instantiated for wchar_t.

concept	AnsiStringLike
	Matches zero terminated C++ string classes with sequential memory layout that implements an API similar to std::basic_string instantiated for char.

concept	SimpleComLike

concept	BinaryLike

concept	BooleanType

concept	FloatingPointType

concept	IntegerType

concept	SignedIntegerType

concept	UnsignedIntegerType

concept	UnsignedIntegerOrBooleanType

concept	ArithmeticType

Typedefs
using	Boolean = bool

using	Int8 = signed char

using	SByte = signed char

using	UInt8 = unsigned char

using	Byte = unsigned char

using	Int16 = short

using	UInt16 = unsigned short

using	ushort = unsigned short

using	Int32 = int

using	Int = int

using	UInt32 = unsigned int

using	UInt = unsigned int

using	ULong32 = unsigned long

using	Long32 = long

using	uint = unsigned int

using	DWord32 = unsigned long

using	DWord = unsigned long

using	Int64 = long long

using	Long64 = long long

using	LongLong = long long

using	UInt64 = unsigned long long

using	ULong64 = unsigned long long

using	ULongLong = unsigned long long

using	DWord64 = unsigned long

using	ssize_t = std::make_signed_t<size_t>

using	SSizeT = ssize_t

using	SizeT = size_t

using	Char = char

using	WideChar = wchar_t

using	Char8 = char

using	Char16 = wchar_t

using	Char32 = UInt32

using	Single = float

using	Double = double

template<typename T >
using	Nullable = std::optional<T>

template<typename T >
using	MakeUnsigned = typename Internal::MakeUnsignedHelper< sizeof( T ) >::Type

template<size_t N>
using	BitMask_t = typename BitMask<N>::type

Functions
template<typename EnumT , typename ... Args> requires std::is_enum_v<EnumT>&& std::conjunction_v<std::is_same<std::remove_cvref_t<EnumT>, std::remove_cvref_t<Args>>...> && ( sizeof...( Args ) > 0 )
constexpr bool	ContainsAllOf (EnumT flags, Args &&... args)

template<typename EnumT , typename ... Args> requires std::is_enum_v<EnumT>&& std::conjunction_v<std::is_same<std::remove_cvref_t<EnumT>, std::remove_cvref_t<Args>>...> && ( sizeof...( Args ) > 0 )
constexpr bool	ContainsNoneOf (EnumT flags, Args ... args)

template<typename EnumT , typename ... Args> requires std::is_enum_v<EnumT>&& std::conjunction_v<std::is_same<std::remove_cvref_t<EnumT>, std::remove_cvref_t<Args>>...> && ( sizeof...( Args ) > 0 )
constexpr bool	ContainsAnyOf (EnumT flags, Args ... args)

template<typename EnumT , typename ... Args> requires std::is_enum_v<EnumT>&& std::conjunction_v<std::is_same<std::remove_cvref_t<EnumT>, std::remove_cvref_t<Args>>...> && ( sizeof...( Args ) > 0 )
constexpr bool	IsSet (EnumT flags, Args &&... args)

template<typename EnumT , typename ... Args> requires std::is_enum_v<EnumT>&& std::conjunction_v<std::is_same<std::remove_cvref_t<EnumT>, std::remove_cvref_t<Args>>...> && ( sizeof...( Args ) > 0 )
constexpr bool	IsNotSet (EnumT flags, Args ... args)

constexpr unsigned long long	operator""_gb (unsigned long long value)

constexpr unsigned long long	operator""_mb (unsigned long long value)

constexpr unsigned long long	operator""_kb (unsigned long long value)

template<IntegerType T>
constexpr T	ByteSwap (T value)
	Reverses the order of bytes in an integer.

template<UnsignedIntegerType T, size_t N> requires ( N <= CHAR_BIT * sizeof( T ) )
constexpr T	MaskTrailingOnes ()
	Creates a bitmask with the `N` right-most bits set to 1, and all other bits set to 0.

template<UnsignedIntegerType T, size_t N> requires ( N <= CHAR_BIT * sizeof( T ) )
constexpr T	MaskLeadingOnes ()
	Creates a bitmask with the `N` left-most bits set to 1, and all other bits set to 0.

template<UnsignedIntegerType T, size_t N> requires ( N <= CHAR_BIT * sizeof( T ) )
constexpr T	MaskTrailingZeros ()
	Creates a bitmask with the `N` right-most bits set to 0, and all other bits set to 1.

template<UnsignedIntegerType T, size_t N> requires ( N <= CHAR_BIT * sizeof( T ) )
constexpr T	MaskLeadingZeros ()
	Creates a bitmask with the `N` left-most bits set to 0, and all other bits set to 1.

constexpr Byte	ReverseBits (Byte b) noexcept
	Reverses the order of the bits of a byte.

constexpr SByte	ReverseBits (SByte b) noexcept
	Reverses the order of the bits of a SByte.

constexpr char	ReverseBits (char b) noexcept
	Reverses the order of the bits of a char.

constexpr UInt16	ReverseBits (UInt16 val) noexcept
	Reverses the order of the bits of an UInt16.

constexpr Int16	ReverseBits (Int16 val) noexcept
	Reverses the order of the bits of an Int16.

constexpr wchar_t	ReverseBits (wchar_t val) noexcept

constexpr UInt32	ReverseBits (UInt32 val) noexcept
	Reverses the order of the bits of an UInt32.

constexpr Int32	ReverseBits (Int32 val) noexcept
	Reverses the order of the bits of an Int32.

constexpr long	ReverseBits (long val) noexcept
	Reverses the order of the bits of a long.

constexpr unsigned long	ReverseBits (unsigned long val) noexcept
	Reverses the order of the bits of an unsigned long.

constexpr UInt64	ReverseBits (UInt64 val) noexcept
	Reverses the order of the bits of an UInt64.

constexpr Int64	ReverseBits (Int64 val) noexcept
	Reverses the order of the bits of an Int64.

constexpr Single	ReverseBits (float val) noexcept
	Reverses the order of the bits of a float.

constexpr Double	ReverseBits (double val) noexcept
	Reverses the order of the bits of a double.

template<IntegerType T>
constexpr bool	IndexOfBitFromLSB (unsigned long *index, T bits)
	Search the mask data from least significant bit (LSB) to the most significant bit (MSB) for a set bit (1).

template<IntegerType T>
constexpr std::optional< unsigned long >	IndexOfBitFromLSB (T bits)
	Search the mask data from least significant bit (LSB) to the most significant bit (MSB) for a set bit (1).

template<IntegerType T>
constexpr bool	IndexOfBitFromMSB (unsigned long *index, T bits)
	Search the mask data from most significant bit (MSB) to least significant bit (LSB) for a set bit (1).

template<IntegerType T>
constexpr std::optional< unsigned long >	IndexOfBitFromMSB (T bits)
	Search the mask data from most significant bit (MSB) to least significant bit (LSB) for a set bit (1).

constexpr UInt64	CreateBitMask64 (unsigned numberOfBitsToSet) noexcept
	Creates a bit-mask.

constexpr UInt32	CreateBitMask32 (unsigned numberOfBitsToSet) noexcept
	Creates a bit-mask with all the bits - up to, and including, the bit at bitIndex.

constexpr UInt64	ExtractBits64 (UInt64 value, UInt32 start, UInt32 len) noexcept
	Extracts contiguous bits from value.

constexpr UInt32	ExtractBits32 (UInt32 value, UInt32 start, UInt32 len) noexcept
	Extracts contiguous bits from value.

template<size_t N>
const void *	AlignTo (const void *address)
	Calculates the address that is aligned on an `N` byte boundary greater, or equal, to `address`.

template<size_t N>
void *	AlignTo (void *address)
	Calculates the address that is aligned on an `N` byte boundary greater, or equal, to `address`.

template<size_t N>
size_t	AlignedPaddingFor (const void *address)
	Calculates the number of bytes between the argument `address` and an address that is aligned on an `N` byte boundary greater, or equal, to `address`.

template<typename T > requires ( IsFloatingPoint<std::remove_cvref_t<T>> \|\| std::is_enum_v<std::remove_cvref_t<T>> )
constexpr T	ByteSwap (const T value) noexcept
	Reverses the bytes of a floating point value, or an enum.

template<typename T1 , typename T2 > requires ( sizeof( T2 ) == 8 ) && ( std::is_same_v<Int32, T1> \|\| std::is_same_v<UInt32, T1> ) && requires( T2 t2 ) { { std::bit_cast< UInt64 >( t2 ) }->std::convertible_to<UInt64>; }
constexpr T1	GetHigh32Bits (T2 val) noexcept

template<typename T1 , typename T2 > requires ( sizeof( T2 ) == 8 ) && ( std::is_same_v<Int32, T1> \|\| std::is_same_v<UInt32, T1> ) && requires( T2 t2 ) { { std::bit_cast< UInt64 >( t2 ) }->std::convertible_to<UInt64>; }
constexpr T2	SetHigh32Bits (T2 x, T1 value) noexcept

template<typename T1 , typename T2 > requires ( sizeof( T2 ) == 8 ) && ( std::is_same_v<Int32, T1> \|\| std::is_same_v<UInt32, T1> ) && requires( T2 t2 ) { { std::bit_cast< UInt64 >( t2 ) }->std::convertible_to<UInt64>; }
constexpr T1	GetLow32Bits (T2 val) noexcept

template<typename T1 , typename T2 > requires ( sizeof( T2 ) == 8 ) && ( std::is_same_v<Int32, T1> \|\| std::is_same_v<UInt32, T1> ) && requires( T2 t2 ) { { std::bit_cast< UInt64 >( t2 ) }->std::convertible_to<UInt64>; }
constexpr T2	SetLow32Bits (T2 x, T1 value) noexcept

template<typename T1 , typename T2 , typename T3 > requires ( sizeof( T1 ) == 8 ) && ( std::is_same_v<Int32, T2> \|\| std::is_same_v<UInt32, T2> ) && ( std::is_same_v<Int32, T3> \|\| std::is_same_v<UInt32, T3> ) && requires( UInt64 v1 ) { { std::bit_cast< T1 >( v1 ) }->std::same_as<T1>; }
constexpr T1	From32BitsTo64Bits (T2 high32Bits, T3 low32Bits) noexcept

constexpr int	Exponent (double value) noexcept

constexpr int	Exponent (float v) noexcept

constexpr UInt64	Significand (double value) noexcept

constexpr UInt32	Significand (float v) noexcept

constexpr UInt64	FastSignBit (double value)

constexpr UInt32	FastSignBit (float v)

void	MemCopy (char dest, const char source, size_t length) noexcept

void	MemCopy (wchar_t dest, const wchar_t source, size_t length) noexcept

void	MemMove (char dest, const char source, size_t length) noexcept

void	MemMove (wchar_t dest, const wchar_t source, size_t length) noexcept

void	MemSet (char *dest, char value, size_t length) noexcept

void	MemSet (wchar_t *dest, wchar_t value, size_t length) noexcept

int	MemCmp (const char first, const char second, size_t length)

int	MemCmp (const wchar_t first, const wchar_t second, size_t length)

char *	MemChr (char *buffer, int value, size_t bufferSize) noexcept

const char *	MemChr (const char *buffer, int value, size_t bufferSize) noexcept

wchar_t *	MemChr (wchar_t *buffer, int value, size_t bufferSize) noexcept

const wchar_t *	MemChr (const wchar_t *buffer, int value, size_t bufferSize) noexcept

template<typename T , size_t N> requires ( std::is_same_v<char, std::remove_cv_t<T>> == false && std::is_same_v<wchar_t, std::remove_cv_t<T>> == false )
constexpr size_t	LengthOf (T(&array)[N]) noexcept

template<typename T > requires requires( T container ) { { container.size( ) } -> std::convertible_to<size_t>; }
constexpr size_t	LengthOf (const T &container) noexcept

template<typename T > requires std::is_same_v<T, char> \|\| std::is_same_v<T, wchar_t>
constexpr size_t	LengthOf (const T *str) noexcept

constexpr int	Compare (nullptr_t s1, nullptr_t s2) noexcept

constexpr int	Compare (nullptr_t s1, const char *s2) noexcept

constexpr int	Compare (const char *s1, nullptr_t s2) noexcept

constexpr int	Compare (const char s1, const char s2) noexcept

constexpr int	Compare (nullptr_t s1, const wchar_t *s2) noexcept

constexpr int	Compare (const wchar_t *s1, nullptr_t s2) noexcept

constexpr int	Compare (const wchar_t s1, const wchar_t s2) noexcept

template<typename T > requires std::is_integral_v<T> \|\| std::is_floating_point_v<T>
constexpr int	Compare (T v1, T v2) noexcept

template<typename T > requires requires ( const T& t1, const T& t2 ) { { t1.CompareTo( t2 ) } ->std::convertible_to<int>; }
constexpr int	Compare (T first, T second) noexcept

template<typename T1 , typename T2 > requires requires( const T1& t1, const T2& t2 ) { { t1.compare( t2 ) } ->std::convertible_to<int>; }
int	Compare (const T1 &v1, const T2 &v2) noexcept

template<typename T > requires std::is_floating_point_v<T>
constexpr bool	AreNearlyEqual (T a, T b, T smallNumber=static_cast< T >(0.0001)) noexcept

template<typename T > requires IsInteger<T>
constexpr bool	IsPowerOfTwo (T v) noexcept

template<typename T > requires IsInteger<T>
constexpr bool	IsPowerOf2 (T v) noexcept

template<typename T > requires std::is_enum_v<std::remove_cvref_t<T>>
constexpr bool	IsPowerOfTwo (T v) noexcept

template<typename T > requires std::is_enum_v<std::remove_cvref_t<T>>
constexpr bool	IsPowerOf2 (T v) noexcept

constexpr Byte	NextPowerOfTwo (Byte v) noexcept

constexpr SByte	NextPowerOfTwo (SByte v) noexcept

constexpr Int16	NextPowerOfTwo (Int16 v) noexcept

constexpr UInt16	NextPowerOfTwo (UInt16 v) noexcept

constexpr Int32	NextPowerOfTwo (Int32 v) noexcept

constexpr UInt32	NextPowerOfTwo (UInt32 v) noexcept

constexpr Int64	NextPowerOfTwo (Int64 v) noexcept

constexpr UInt64	NextPowerOfTwo (UInt64 v) noexcept

template<typename Fn >
Internal::FinallyImpl< Fn >	Finally (Fn &&Func)

Variables
constexpr UInt8	MaxUInt8 = ( ( UInt8 )~( ( UInt8 )0 ) )

constexpr Int8	MaxInt8 = ( ( Int8 )( MaxUInt8 >> 1 ) )

constexpr Int8	MinInt8 = ( ( Int8 )~MaxInt8 )

constexpr UInt16	MaxUInt16 = ( ( UInt16 )~( ( UInt16 )0 ) )

constexpr Int16	MaxInt16 = ( ( Int16 )( MaxUInt16 >> 1 ) )

constexpr Int16	MinInt16 = ( ( Int16 )~MaxInt16 )

constexpr UInt32	MaxUInt32 = ( ( UInt32 )~( ( UInt32 )0 ) )

constexpr Int32	MaxInt32 = ( ( Int32 )( MaxUInt32 >> 1 ) )

constexpr Int32	MinInt32 = ( ( Int32 )~MaxInt32 )

constexpr UInt64	MaxUInt64 = ( ( UInt64 )~( ( UInt64 )0 ) )

constexpr Int64	MaxInt64 = ( ( Int64 )( MaxUInt64 >> 1 ) )

constexpr Int64	MinInt64 = ( ( Int64 )~MaxInt64 )

constexpr ULong32	MaxULong32 = ( ( ULong32 )~( ( ULong32 )0 ) )

constexpr Long32	MaxLong32 = ( ( Long32 )( MaxULong32 >> 1 ) )

constexpr Long32	MinLong32 = ( ( Long32 )~MaxLong32 )

constexpr ULong64	MaxULong64 = ( ( ULong64 )~( ( ULong64 )0 ) )

constexpr Long64	MaxLong64 = ( ( Long64 )( MaxULong64 >> 1 ) )

constexpr Long64	MinLong64 = ( ( Long64 )~MaxLong64 )

constexpr ULongLong	MaxULongLong = ( ( ULongLong )~( ( ULongLong )0 ) )

constexpr LongLong	MaxLongLong = ( ( LongLong )( MaxULongLong >> 1 ) )

constexpr LongLong	MinLongLong = ( ( LongLong )~MaxLongLong )

constexpr SizeT	MaxSizeT = ( ( SizeT )~( ( SizeT )0 ) )

constexpr SSizeT	MaxSSizeT = ( ( SSizeT )( MaxSizeT >> 1 ) )

constexpr SSizeT	MinSSizeT = ( ( SSizeT )~MaxSSizeT )

constexpr UInt	MaxUInt = ( ( UInt )~( ( UInt )0 ) )

constexpr Int	MaxInt = ( ( Int )( MaxUInt >> 1 ) )

constexpr Int	MinInt = ( ( Int )~MaxInt )

constexpr DWord32	MaxDWord32 = ( ( DWord32 )~( ( DWord32 )0 ) )

constexpr DWord64	MaxDWord64 = ( ( DWord64 )~( ( DWord64 )0 ) )

template<typename T >
constexpr bool	IsNotBoolean = std::is_same_v<std::remove_cvref_t<T>, bool> == false

template<typename T >
constexpr bool	IsBoolean = std::is_same_v<std::remove_cvref_t<T>, bool>

template<typename T >
constexpr bool	IsInteger = std::is_integral_v<std::remove_cvref_t<T>> && IsBoolean<T> == false

template<typename T >
constexpr bool	IsSignedInteger = IsInteger<std::remove_cvref_t<T>> && std::is_signed_v<std::remove_cvref_t<T>>

template<typename T >
constexpr bool	IsUnsignedInteger = IsInteger<T> && std::is_unsigned_v<std::remove_cvref_t<T>>

template<typename T >
constexpr bool	IsFloatingPoint = std::is_floating_point_v<std::remove_cvref_t<T>>

template<typename T >
constexpr bool	IsArithmetic = IsInteger<T> \|\| IsFloatingPoint<T>

template<typename T , typename U = MakeUnsigned< std::remove_cvref_t<T> >>
constexpr U	FractionMask = std::numeric_limits<std::remove_cvref_t<T>>::max( )

template<typename T , typename U = MakeUnsigned< std::remove_cvref_t<T> >>
constexpr U	ExponentMask = 0

template<>
constexpr UInt32	FractionMask< float, UInt32 > = std::bit_cast< UInt32 >( 0b00000000011111111111111111111111 )

template<>
constexpr UInt32	ExponentMask< float, UInt32 > = std::bit_cast< UInt32 >( 0b01111111100000000000000000000000 )

template<>
constexpr UInt64	FractionMask< double, UInt64 > = std::bit_cast< UInt64 >( 0b0000000000001111111111111111111111111111111111111111111111111111 )

template<>
constexpr UInt64	ExponentMask< double, UInt64 > = std::bit_cast< UInt64 >( 0b0111111111110000000000000000000000000000000000000000000000000000 )

template<size_t N>
constexpr auto	BitMask_v = BitMask<N>::value

Typedef Documentation

◆ BitMask_t

template<size_t N>

using Harlinn::Common::BitMask_t = typename BitMask<N>::type

◆ Boolean

using Harlinn::Common::Boolean = bool

◆ Byte

using Harlinn::Common::Byte = unsigned char

◆ Char

using Harlinn::Common::Char = char

◆ Char16

using Harlinn::Common::Char16 = wchar_t

◆ Char32

using Harlinn::Common::Char32 = UInt32

◆ Char8

using Harlinn::Common::Char8 = char

◆ Double

using Harlinn::Common::Double = double

◆ DWord

using Harlinn::Common::DWord = unsigned long

◆ DWord32

using Harlinn::Common::DWord32 = unsigned long

◆ DWord64

using Harlinn::Common::DWord64 = unsigned long

◆ Int

using Harlinn::Common::Int = int

◆ Int16

using Harlinn::Common::Int16 = short

◆ Int32

using Harlinn::Common::Int32 = int

◆ Int64

using Harlinn::Common::Int64 = long long

◆ Int8

using Harlinn::Common::Int8 = signed char

◆ Long32

using Harlinn::Common::Long32 = long

◆ Long64

using Harlinn::Common::Long64 = long long

◆ LongLong

using Harlinn::Common::LongLong = long long

◆ MakeUnsigned

template<typename T >

using Harlinn::Common::MakeUnsigned = typename Internal::MakeUnsignedHelper< sizeof( T ) >::Type

◆ Nullable

template<typename T >

using Harlinn::Common::Nullable = std::optional<T>

◆ SByte

using Harlinn::Common::SByte = signed char

◆ Single

using Harlinn::Common::Single = float

◆ SizeT

using Harlinn::Common::SizeT = size_t

◆ ssize_t

using Harlinn::Common::ssize_t = std::make_signed_t<size_t>

◆ SSizeT

using Harlinn::Common::SSizeT = ssize_t

◆ UInt

using Harlinn::Common::UInt = unsigned int

◆ uint

using Harlinn::Common::uint = unsigned int

◆ UInt16

using Harlinn::Common::UInt16 = unsigned short

◆ UInt32

using Harlinn::Common::UInt32 = unsigned int

◆ UInt64

using Harlinn::Common::UInt64 = unsigned long long

◆ UInt8

using Harlinn::Common::UInt8 = unsigned char

◆ ULong32

using Harlinn::Common::ULong32 = unsigned long

◆ ULong64

using Harlinn::Common::ULong64 = unsigned long long

◆ ULongLong

using Harlinn::Common::ULongLong = unsigned long long

◆ ushort

using Harlinn::Common::ushort = unsigned short

◆ WideChar

using Harlinn::Common::WideChar = wchar_t

Function Documentation

◆ AlignedPaddingFor()

template<size_t N>

size_t Harlinn::Common::AlignedPaddingFor ( const void * address )

inline

Calculates the number of bytes between the argument address and an address that is aligned on an N byte boundary greater, or equal, to address.

Template Parameters

N

Parameters

address

Returns

◆ AlignTo() [1/2]

template<size_t N>

const void * Harlinn::Common::AlignTo ( const void * address )

inline

Calculates the address that is aligned on an N byte boundary greater, or equal, to address.

Template Parameters

N	The requested alignment.

Parameters

address The address to calculate the alignment for.

Returns: The aligned address.

◆ AlignTo() [2/2]

template<size_t N>

void * Harlinn::Common::AlignTo ( void * address )

inline

Calculates the address that is aligned on an N byte boundary greater, or equal, to address.

Template Parameters

N	The requested alignment.

Parameters

address The address to calculate the alignment for.

Returns: The aligned address.

◆ AreNearlyEqual()

template<typename T >
requires std::is_floating_point_v<T>

bool Harlinn::Common::AreNearlyEqual	(	T	a,
		T	b,
		T	smallNumber = static_cast< T >( 0.0001 ) )

constexprnoexcept

◆ ByteSwap() [1/2]

template<typename T >
requires ( IsFloatingPoint<std::remove_cvref_t<T>> || std::is_enum_v<std::remove_cvref_t<T>> )

T Harlinn::Common::ByteSwap ( const T value )

inlineconstexprnoexcept

Reverses the bytes of a floating point value, or an enum.

Template Parameters

T	A floating point type, or an enum type.

Parameters

value The value.

Returns: The result.

◆ ByteSwap() [2/2]

template<IntegerType T>

T Harlinn::Common::ByteSwap ( T value )

inlineconstexpr

Reverses the order of bytes in an integer.

Template Parameters

T	An integral type, normally deduced from the argument.

Parameters

value An integral value.

Returns: An integral value calculated by reversing the order of the bytes from the argument.

◆ Compare() [1/10]

int Harlinn::Common::Compare	(	const char *	s1,
		const char *	s2 )

inlineconstexprnoexcept

◆ Compare() [2/10]

int Harlinn::Common::Compare	(	const char *	s1,
		nullptr_t	s2 )

inlineconstexprnoexcept

◆ Compare() [3/10]

template<typename T1 , typename T2 >
requires requires( const T1& t1, const T2& t2 ) { { t1.compare( t2 ) } ->std::convertible_to<int>; }

int Harlinn::Common::Compare	(	const T1 &	v1,
		const T2 &	v2 )

inlinenoexcept

◆ Compare() [4/10]

int Harlinn::Common::Compare	(	const wchar_t *	s1,
		const wchar_t *	s2 )

inlineconstexprnoexcept

◆ Compare() [5/10]

int Harlinn::Common::Compare	(	const wchar_t *	s1,
		nullptr_t	s2 )

inlineconstexprnoexcept

◆ Compare() [6/10]

int Harlinn::Common::Compare	(	nullptr_t	s1,
		const char *	s2 )

inlineconstexprnoexcept

◆ Compare() [7/10]

int Harlinn::Common::Compare	(	nullptr_t	s1,
		const wchar_t *	s2 )

inlineconstexprnoexcept

◆ Compare() [8/10]

int Harlinn::Common::Compare	(	nullptr_t	s1,
		nullptr_t	s2 )

inlineconstexprnoexcept

◆ Compare() [9/10]

template<typename T >
requires requires ( const T& t1, const T& t2 ) { { t1.CompareTo( t2 ) } ->std::convertible_to<int>; }

int Harlinn::Common::Compare	(	T	first,
		T	second )

inlineconstexprnoexcept

◆ Compare() [10/10]

template<typename T >
requires std::is_integral_v<T> || std::is_floating_point_v<T>

int Harlinn::Common::Compare	(	T	v1,
		T	v2 )

inlineconstexprnoexcept

◆ ContainsAllOf()

template<typename EnumT , typename ... Args>
requires std::is_enum_v<EnumT>&& std::conjunction_v<std::is_same<std::remove_cvref_t<EnumT>, std::remove_cvref_t<Args>>...> && ( sizeof...( Args ) > 0 )

bool Harlinn::Common::ContainsAllOf	(	EnumT	flags,
		Args &&...	args )

constexpr

◆ ContainsAnyOf()

template<typename EnumT , typename ... Args>
requires std::is_enum_v<EnumT>&& std::conjunction_v<std::is_same<std::remove_cvref_t<EnumT>, std::remove_cvref_t<Args>>...> && ( sizeof...( Args ) > 0 )

bool Harlinn::Common::ContainsAnyOf	(	EnumT	flags,
		Args ...	args )

constexpr

◆ ContainsNoneOf()

template<typename EnumT , typename ... Args>
requires std::is_enum_v<EnumT>&& std::conjunction_v<std::is_same<std::remove_cvref_t<EnumT>, std::remove_cvref_t<Args>>...> && ( sizeof...( Args ) > 0 )

bool Harlinn::Common::ContainsNoneOf	(	EnumT	flags,
		Args ...	args )

constexpr

◆ CreateBitMask32()

UInt32 Harlinn::Common::CreateBitMask32 ( unsigned numberOfBitsToSet )

inlineconstexprnoexcept

Creates a bit-mask with all the bits - up to, and including, the bit at bitIndex.

set.

Parameters

bitIndex The number of bits to set. The value of numberOfBitsToSet must be in the range [1,32]

Returns: The generated bit-mask

◆ CreateBitMask64()

UInt64 Harlinn::Common::CreateBitMask64 ( unsigned numberOfBitsToSet )

inlineconstexprnoexcept

Creates a bit-mask.

Parameters

bitIndex The number of bits to set. The value of numberOfBitsToSet must be in the range [1,64]

Returns: The generated bit-mask

◆ Exponent() [1/2]

int Harlinn::Common::Exponent ( double value )

inlineconstexprnoexcept

◆ Exponent() [2/2]

int Harlinn::Common::Exponent ( float v )

inlineconstexprnoexcept

◆ ExtractBits32()

UInt32 Harlinn::Common::ExtractBits32	(	UInt32	value,
		UInt32	start,
		UInt32	len )

inlineconstexprnoexcept

Extracts contiguous bits from value.

Parameters

value
start	0 based index of the least significant bit to extract.
len	Number of bits to extract,

Returns: the extracted bits, with the first extracted bit at position 0, the least significant bit in the returned value.

◆ ExtractBits64()

UInt64 Harlinn::Common::ExtractBits64	(	UInt64	value,
		UInt32	start,
		UInt32	len )

inlineconstexprnoexcept

Extracts contiguous bits from value.

Parameters

value
start	0 based index of the least significant bit to extract.
len	Number of bits to extract,

Returns: the extracted bits, with the first extracted bit at position 0, the least significant bit in the returned value.

◆ FastSignBit() [1/2]

UInt64 Harlinn::Common::FastSignBit ( double value )

inlineconstexpr

◆ FastSignBit() [2/2]

UInt32 Harlinn::Common::FastSignBit ( float v )

constexpr

◆ Finally()

template<typename Fn >

Internal::FinallyImpl< Fn > Harlinn::Common::Finally ( Fn && Func )

inline

◆ From32BitsTo64Bits()

template<typename T1 , typename T2 , typename T3 >
requires ( sizeof( T1 ) == 8 ) && ( std::is_same_v<Int32, T2> || std::is_same_v<UInt32, T2> ) && ( std::is_same_v<Int32, T3> || std::is_same_v<UInt32, T3> ) && requires( UInt64 v1 ) { { std::bit_cast< T1 >( v1 ) }->std::same_as<T1>; }

T1 Harlinn::Common::From32BitsTo64Bits	(	T2	high32Bits,
		T3	low32Bits )

inlineconstexprnoexcept

◆ GetHigh32Bits()

template<typename T1 , typename T2 >
requires ( sizeof( T2 ) == 8 ) && ( std::is_same_v<Int32, T1> || std::is_same_v<UInt32, T1> ) && requires( T2 t2 ) { { std::bit_cast< UInt64 >( t2 ) }->std::convertible_to<UInt64>; }

T1 Harlinn::Common::GetHigh32Bits ( T2 val )

inlineconstexprnoexcept

◆ GetLow32Bits()

template<typename T1 , typename T2 >
requires ( sizeof( T2 ) == 8 ) && ( std::is_same_v<Int32, T1> || std::is_same_v<UInt32, T1> ) && requires( T2 t2 ) { { std::bit_cast< UInt64 >( t2 ) }->std::convertible_to<UInt64>; }

T1 Harlinn::Common::GetLow32Bits ( T2 val )

inlineconstexprnoexcept

◆ IndexOfBitFromLSB() [1/2]

template<IntegerType T>

std::optional< unsigned long > Harlinn::Common::IndexOfBitFromLSB ( T bits )

constexpr

Search the mask data from least significant bit (LSB) to the most significant bit (MSB) for a set bit (1).

Parameters

bits	The value to search.

Returns: An std::optional with an assigned value if a set bit was found.

◆ IndexOfBitFromLSB() [2/2]

template<IntegerType T>

bool Harlinn::Common::IndexOfBitFromLSB	(	unsigned long *	index,
		T	bits )

constexpr

Search the mask data from least significant bit (LSB) to the most significant bit (MSB) for a set bit (1).

Parameters

index	Pointer to a value that will receive the zero based index of the of the bit, if found.
bits	The value to search.

Returns: Returns true if a set bit was found and the value pointed to by index is valid.

◆ IndexOfBitFromMSB() [1/2]

template<IntegerType T>

std::optional< unsigned long > Harlinn::Common::IndexOfBitFromMSB ( T bits )

constexpr

Search the mask data from most significant bit (MSB) to least significant bit (LSB) for a set bit (1).

Parameters

bits	The value to search.

Returns: An std::optional with an assigned value if a set bit was found.

◆ IndexOfBitFromMSB() [2/2]

template<IntegerType T>

bool Harlinn::Common::IndexOfBitFromMSB	(	unsigned long *	index,
		T	bits )

constexpr

Search the mask data from most significant bit (MSB) to least significant bit (LSB) for a set bit (1).

Parameters

index	Pointer to a value that will receive the zero based index of the of the bit, if found.
bits	The value to search.

Returns: Returns true if a set bit was found and the value pointed to by index is valid.

◆ IsNotSet()

template<typename EnumT , typename ... Args>
requires std::is_enum_v<EnumT>&& std::conjunction_v<std::is_same<std::remove_cvref_t<EnumT>, std::remove_cvref_t<Args>>...> && ( sizeof...( Args ) > 0 )

bool Harlinn::Common::IsNotSet	(	EnumT	flags,
		Args ...	args )

constexpr

◆ IsPowerOf2() [1/2]

template<typename T >
requires IsInteger<T>

bool Harlinn::Common::IsPowerOf2 ( T v )

inlineconstexprnoexcept

◆ IsPowerOf2() [2/2]

template<typename T >
requires std::is_enum_v<std::remove_cvref_t<T>>

bool Harlinn::Common::IsPowerOf2 ( T v )

inlineconstexprnoexcept

◆ IsPowerOfTwo() [1/2]

template<typename T >
requires IsInteger<T>

bool Harlinn::Common::IsPowerOfTwo ( T v )

inlineconstexprnoexcept

◆ IsPowerOfTwo() [2/2]

template<typename T >
requires std::is_enum_v<std::remove_cvref_t<T>>

bool Harlinn::Common::IsPowerOfTwo ( T v )

inlineconstexprnoexcept

◆ IsSet()

template<typename EnumT , typename ... Args>
requires std::is_enum_v<EnumT>&& std::conjunction_v<std::is_same<std::remove_cvref_t<EnumT>, std::remove_cvref_t<Args>>...> && ( sizeof...( Args ) > 0 )

bool Harlinn::Common::IsSet	(	EnumT	flags,
		Args &&...	args )

constexpr

◆ LengthOf() [1/3]

template<typename T >
requires requires( T container ) { { container.size( ) } -> std::convertible_to<size_t>; }

size_t Harlinn::Common::LengthOf ( const T & container )

inlinenodiscardconstexprnoexcept

◆ LengthOf() [2/3]

template<typename T >
requires std::is_same_v<T, char> || std::is_same_v<T, wchar_t>

size_t Harlinn::Common::LengthOf ( const T * str )

inlinenodiscardconstexprnoexcept

◆ LengthOf() [3/3]

template<typename T , size_t N>
requires ( std::is_same_v<char, std::remove_cv_t<T>> == false && std::is_same_v<wchar_t, std::remove_cv_t<T>> == false )

size_t Harlinn::Common::LengthOf ( T(&) array[N] )

inlinenodiscardconstexprnoexcept

◆ MaskLeadingOnes()

template<UnsignedIntegerType T, size_t N>
requires ( N <= CHAR_BIT * sizeof( T ) )

T Harlinn::Common::MaskLeadingOnes ( )

constexpr

Creates a bitmask with the N left-most bits set to 1, and all other bits set to 0.

Template Parameters

T	An unsigned integral type.
N	The number if rightmost bits to set.

Returns: The bitmask.

◆ MaskLeadingZeros()

template<UnsignedIntegerType T, size_t N>
requires ( N <= CHAR_BIT * sizeof( T ) )

T Harlinn::Common::MaskLeadingZeros ( )

constexpr

Creates a bitmask with the N left-most bits set to 0, and all other bits set to 1.

Template Parameters

T	An unsigned integral type.
N	The number if rightmost bits to clear.

Returns: The bitmask.

◆ MaskTrailingOnes()

template<UnsignedIntegerType T, size_t N>
requires ( N <= CHAR_BIT * sizeof( T ) )

T Harlinn::Common::MaskTrailingOnes ( )

constexpr

Creates a bitmask with the N right-most bits set to 1, and all other bits set to 0.

Template Parameters

T	An unsigned integral type.
N	The number if rightmost bits to set.

Returns: The bitmask.

◆ MaskTrailingZeros()

template<UnsignedIntegerType T, size_t N>
requires ( N <= CHAR_BIT * sizeof( T ) )

T Harlinn::Common::MaskTrailingZeros ( )

constexpr

Creates a bitmask with the N right-most bits set to 0, and all other bits set to 1.

Template Parameters

T	An unsigned integral type.
N	The number if rightmost bits to clear.

Returns: The bitmask.

◆ MemChr() [1/4]

char * Harlinn::Common::MemChr	(	char *	buffer,
		int	value,
		size_t	bufferSize )

inlinenodiscardnoexcept

◆ MemChr() [2/4]

const char * Harlinn::Common::MemChr	(	const char *	buffer,
		int	value,
		size_t	bufferSize )

inlinenodiscardnoexcept

◆ MemChr() [3/4]

const wchar_t * Harlinn::Common::MemChr	(	const wchar_t *	buffer,
		int	value,
		size_t	bufferSize )

inlinenodiscardnoexcept

◆ MemChr() [4/4]

wchar_t * Harlinn::Common::MemChr	(	wchar_t *	buffer,
		int	value,
		size_t	bufferSize )

inlinenodiscardnoexcept

◆ MemCmp() [1/2]

int Harlinn::Common::MemCmp	(	const char *	first,
		const char *	second,
		size_t	length )

inlinenodiscard

◆ MemCmp() [2/2]

int Harlinn::Common::MemCmp	(	const wchar_t *	first,
		const wchar_t *	second,
		size_t	length )

inlinenodiscard

◆ MemCopy() [1/2]

void Harlinn::Common::MemCopy	(	char *	dest,
		const char *	source,
		size_t	length )

inlinenoexcept

◆ MemCopy() [2/2]

void Harlinn::Common::MemCopy	(	wchar_t *	dest,
		const wchar_t *	source,
		size_t	length )

inlinenoexcept

◆ MemMove() [1/2]

void Harlinn::Common::MemMove	(	char *	dest,
		const char *	source,
		size_t	length )

inlinenoexcept

◆ MemMove() [2/2]

void Harlinn::Common::MemMove	(	wchar_t *	dest,
		const wchar_t *	source,
		size_t	length )

inlinenoexcept

◆ MemSet() [1/2]

void Harlinn::Common::MemSet	(	char *	dest,
		char	value,
		size_t	length )

inlinenoexcept

◆ MemSet() [2/2]

void Harlinn::Common::MemSet	(	wchar_t *	dest,
		wchar_t	value,
		size_t	length )

inlinenoexcept

◆ NextPowerOfTwo() [1/8]

Byte Harlinn::Common::NextPowerOfTwo ( Byte v )

inlineconstexprnoexcept

◆ NextPowerOfTwo() [2/8]

Int16 Harlinn::Common::NextPowerOfTwo ( Int16 v )

inlineconstexprnoexcept

◆ NextPowerOfTwo() [3/8]

Int32 Harlinn::Common::NextPowerOfTwo ( Int32 v )

inlineconstexprnoexcept

◆ NextPowerOfTwo() [4/8]

Int64 Harlinn::Common::NextPowerOfTwo ( Int64 v )

inlineconstexprnoexcept

◆ NextPowerOfTwo() [5/8]

SByte Harlinn::Common::NextPowerOfTwo ( SByte v )

inlineconstexprnoexcept

◆ NextPowerOfTwo() [6/8]

UInt16 Harlinn::Common::NextPowerOfTwo ( UInt16 v )

inlineconstexprnoexcept

◆ NextPowerOfTwo() [7/8]

UInt32 Harlinn::Common::NextPowerOfTwo ( UInt32 v )

inlineconstexprnoexcept

◆ NextPowerOfTwo() [8/8]

UInt64 Harlinn::Common::NextPowerOfTwo ( UInt64 v )

inlineconstexprnoexcept

◆ operator""_gb()

unsigned long long Harlinn::Common::operator""_gb ( unsigned long long value )

constexpr

◆ operator""_kb()

unsigned long long Harlinn::Common::operator""_kb ( unsigned long long value )

constexpr

◆ operator""_mb()

unsigned long long Harlinn::Common::operator""_mb ( unsigned long long value )

constexpr

◆ ReverseBits() [1/14]

Byte Harlinn::Common::ReverseBits ( Byte b )

inlineconstexprnoexcept

Reverses the order of the bits of a byte.

◆ ReverseBits() [2/14]

char Harlinn::Common::ReverseBits ( char b )

inlineconstexprnoexcept

Reverses the order of the bits of a char.

◆ ReverseBits() [3/14]

Double Harlinn::Common::ReverseBits ( double val )

inlineconstexprnoexcept

Reverses the order of the bits of a double.

◆ ReverseBits() [4/14]

Single Harlinn::Common::ReverseBits ( float val )

inlineconstexprnoexcept

Reverses the order of the bits of a float.

◆ ReverseBits() [5/14]

Int16 Harlinn::Common::ReverseBits ( Int16 val )

inlineconstexprnoexcept

Reverses the order of the bits of an Int16.

◆ ReverseBits() [6/14]

Int32 Harlinn::Common::ReverseBits ( Int32 val )

inlineconstexprnoexcept

Reverses the order of the bits of an Int32.

◆ ReverseBits() [7/14]

Int64 Harlinn::Common::ReverseBits ( Int64 val )

inlineconstexprnoexcept

Reverses the order of the bits of an Int64.

◆ ReverseBits() [8/14]

long Harlinn::Common::ReverseBits ( long val )

inlineconstexprnoexcept

Reverses the order of the bits of a long.

◆ ReverseBits() [9/14]

SByte Harlinn::Common::ReverseBits ( SByte b )

inlineconstexprnoexcept

Reverses the order of the bits of a SByte.

◆ ReverseBits() [10/14]

UInt16 Harlinn::Common::ReverseBits ( UInt16 val )

inlineconstexprnoexcept

Reverses the order of the bits of an UInt16.

◆ ReverseBits() [11/14]

UInt32 Harlinn::Common::ReverseBits ( UInt32 val )

inlineconstexprnoexcept

Reverses the order of the bits of an UInt32.

◆ ReverseBits() [12/14]

UInt64 Harlinn::Common::ReverseBits ( UInt64 val )

inlineconstexprnoexcept

Reverses the order of the bits of an UInt64.

◆ ReverseBits() [13/14]

unsigned long Harlinn::Common::ReverseBits ( unsigned long val )

inlineconstexprnoexcept

Reverses the order of the bits of an unsigned long.

◆ ReverseBits() [14/14]

wchar_t Harlinn::Common::ReverseBits ( wchar_t val )

inlineconstexprnoexcept

◆ SetHigh32Bits()

template<typename T1 , typename T2 >
requires ( sizeof( T2 ) == 8 ) && ( std::is_same_v<Int32, T1> || std::is_same_v<UInt32, T1> ) && requires( T2 t2 ) { { std::bit_cast< UInt64 >( t2 ) }->std::convertible_to<UInt64>; }

T2 Harlinn::Common::SetHigh32Bits	(	T2	x,
		T1	value )

inlineconstexprnoexcept

◆ SetLow32Bits()

template<typename T1 , typename T2 >
requires ( sizeof( T2 ) == 8 ) && ( std::is_same_v<Int32, T1> || std::is_same_v<UInt32, T1> ) && requires( T2 t2 ) { { std::bit_cast< UInt64 >( t2 ) }->std::convertible_to<UInt64>; }

T2 Harlinn::Common::SetLow32Bits	(	T2	x,
		T1	value )

inlineconstexprnoexcept

◆ Significand() [1/2]

UInt64 Harlinn::Common::Significand ( double value )

inlineconstexprnoexcept

◆ Significand() [2/2]

UInt32 Harlinn::Common::Significand ( float v )

inlineconstexprnoexcept

Variable Documentation

◆ BitMask_v

template<size_t N>

auto Harlinn::Common::BitMask_v = BitMask<N>::value

inlineconstexpr

◆ ExponentMask

template<typename T , typename U = MakeUnsigned< std::remove_cvref_t<T> >>

U Harlinn::Common::ExponentMask = 0

inlineconstexpr

◆ ExponentMask< double, UInt64 >

template<>

UInt64 Harlinn::Common::ExponentMask< double, UInt64 > = std::bit_cast< UInt64 >( 0b0111111111110000000000000000000000000000000000000000000000000000 )

inlineconstexpr

◆ ExponentMask< float, UInt32 >

template<>

UInt32 Harlinn::Common::ExponentMask< float, UInt32 > = std::bit_cast< UInt32 >( 0b01111111100000000000000000000000 )

inlineconstexpr

◆ FractionMask

template<typename T , typename U = MakeUnsigned< std::remove_cvref_t<T> >>

U Harlinn::Common::FractionMask = std::numeric_limits<std::remove_cvref_t<T>>::max( )

inlineconstexpr

◆ FractionMask< double, UInt64 >

template<>

UInt64 Harlinn::Common::FractionMask< double, UInt64 > = std::bit_cast< UInt64 >( 0b0000000000001111111111111111111111111111111111111111111111111111 )

inlineconstexpr

◆ FractionMask< float, UInt32 >

template<>

UInt32 Harlinn::Common::FractionMask< float, UInt32 > = std::bit_cast< UInt32 >( 0b00000000011111111111111111111111 )

inlineconstexpr

◆ IsArithmetic

template<typename T >

bool Harlinn::Common::IsArithmetic = IsInteger<T> || IsFloatingPoint<T>

inlineconstexpr

◆ IsBoolean

template<typename T >

bool Harlinn::Common::IsBoolean = std::is_same_v<std::remove_cvref_t<T>, bool>

inlineconstexpr

◆ IsFloatingPoint

template<typename T >

bool Harlinn::Common::IsFloatingPoint = std::is_floating_point_v<std::remove_cvref_t<T>>

inlineconstexpr

◆ IsInteger

template<typename T >

bool Harlinn::Common::IsInteger = std::is_integral_v<std::remove_cvref_t<T>> && IsBoolean<T> == false

inlineconstexpr

◆ IsNotBoolean

template<typename T >

bool Harlinn::Common::IsNotBoolean = std::is_same_v<std::remove_cvref_t<T>, bool> == false

inlineconstexpr

◆ IsSignedInteger

template<typename T >

bool Harlinn::Common::IsSignedInteger = IsInteger<std::remove_cvref_t<T>> && std::is_signed_v<std::remove_cvref_t<T>>

inlineconstexpr

◆ IsUnsignedInteger

template<typename T >

bool Harlinn::Common::IsUnsignedInteger = IsInteger<T> && std::is_unsigned_v<std::remove_cvref_t<T>>

inlineconstexpr

◆ MaxDWord32

DWord32 Harlinn::Common::MaxDWord32 = ( ( DWord32 )~( ( DWord32 )0 ) )

constexpr

◆ MaxDWord64

DWord64 Harlinn::Common::MaxDWord64 = ( ( DWord64 )~( ( DWord64 )0 ) )

constexpr

◆ MaxInt

Int Harlinn::Common::MaxInt = ( ( Int )( MaxUInt >> 1 ) )

constexpr

◆ MaxInt16

Int16 Harlinn::Common::MaxInt16 = ( ( Int16 )( MaxUInt16 >> 1 ) )

constexpr

◆ MaxInt32

Int32 Harlinn::Common::MaxInt32 = ( ( Int32 )( MaxUInt32 >> 1 ) )

constexpr

◆ MaxInt64

Int64 Harlinn::Common::MaxInt64 = ( ( Int64 )( MaxUInt64 >> 1 ) )

constexpr

◆ MaxInt8

Int8 Harlinn::Common::MaxInt8 = ( ( Int8 )( MaxUInt8 >> 1 ) )

constexpr

◆ MaxLong32

Long32 Harlinn::Common::MaxLong32 = ( ( Long32 )( MaxULong32 >> 1 ) )

constexpr

◆ MaxLong64

Long64 Harlinn::Common::MaxLong64 = ( ( Long64 )( MaxULong64 >> 1 ) )

constexpr

◆ MaxLongLong

LongLong Harlinn::Common::MaxLongLong = ( ( LongLong )( MaxULongLong >> 1 ) )

constexpr

◆ MaxSizeT

SizeT Harlinn::Common::MaxSizeT = ( ( SizeT )~( ( SizeT )0 ) )

constexpr

◆ MaxSSizeT

SSizeT Harlinn::Common::MaxSSizeT = ( ( SSizeT )( MaxSizeT >> 1 ) )

constexpr

◆ MaxUInt

UInt Harlinn::Common::MaxUInt = ( ( UInt )~( ( UInt )0 ) )

constexpr

◆ MaxUInt16

UInt16 Harlinn::Common::MaxUInt16 = ( ( UInt16 )~( ( UInt16 )0 ) )

constexpr

◆ MaxUInt32

UInt32 Harlinn::Common::MaxUInt32 = ( ( UInt32 )~( ( UInt32 )0 ) )

constexpr

◆ MaxUInt64

UInt64 Harlinn::Common::MaxUInt64 = ( ( UInt64 )~( ( UInt64 )0 ) )

constexpr

◆ MaxUInt8

UInt8 Harlinn::Common::MaxUInt8 = ( ( UInt8 )~( ( UInt8 )0 ) )

constexpr

◆ MaxULong32

ULong32 Harlinn::Common::MaxULong32 = ( ( ULong32 )~( ( ULong32 )0 ) )

constexpr

◆ MaxULong64

ULong64 Harlinn::Common::MaxULong64 = ( ( ULong64 )~( ( ULong64 )0 ) )

constexpr

◆ MaxULongLong

ULongLong Harlinn::Common::MaxULongLong = ( ( ULongLong )~( ( ULongLong )0 ) )

constexpr

◆ MinInt

Int Harlinn::Common::MinInt = ( ( Int )~MaxInt )

constexpr

◆ MinInt16

Int16 Harlinn::Common::MinInt16 = ( ( Int16 )~MaxInt16 )

constexpr

◆ MinInt32

Int32 Harlinn::Common::MinInt32 = ( ( Int32 )~MaxInt32 )

constexpr

◆ MinInt64

Int64 Harlinn::Common::MinInt64 = ( ( Int64 )~MaxInt64 )

constexpr

◆ MinInt8

Int8 Harlinn::Common::MinInt8 = ( ( Int8 )~MaxInt8 )

constexpr

◆ MinLong32

Long32 Harlinn::Common::MinLong32 = ( ( Long32 )~MaxLong32 )

constexpr

◆ MinLong64

Long64 Harlinn::Common::MinLong64 = ( ( Long64 )~MaxLong64 )

constexpr

◆ MinLongLong

LongLong Harlinn::Common::MinLongLong = ( ( LongLong )~MaxLongLong )

constexpr

◆ MinSSizeT

SSizeT Harlinn::Common::MinSSizeT = ( ( SSizeT )~MaxSSizeT )

constexpr

Namespaces

Classes

Concepts

Typedefs

Functions

Variables

Typedef Documentation

◆ BitMask_t

◆ Boolean

◆ Byte

◆ Char

◆ Char16

◆ Char32

◆ Char8

◆ Double

◆ DWord

◆ DWord32

◆ DWord64

◆ Int

◆ Int16

◆ Int32

◆ Int64

◆ Int8

◆ Long32

◆ Long64

◆ LongLong

◆ MakeUnsigned

◆ Nullable

◆ SByte

◆ Single

◆ SizeT

◆ ssize_t

◆ SSizeT

◆ UInt

◆ uint

◆ UInt16

◆ UInt32

◆ UInt64

◆ UInt8

◆ ULong32

◆ ULong64

◆ ULongLong

◆ ushort

◆ WideChar

Function Documentation

◆ AlignedPaddingFor()

◆ AlignTo() [1/2]

◆ AlignTo() [2/2]

◆ AreNearlyEqual()

◆ ByteSwap() [1/2]

◆ ByteSwap() [2/2]

◆ Compare() [1/10]

◆ Compare() [2/10]

◆ Compare() [3/10]

◆ Compare() [4/10]

◆ Compare() [5/10]

◆ Compare() [6/10]

◆ Compare() [7/10]

◆ Compare() [8/10]

◆ Compare() [9/10]

◆ Compare() [10/10]

◆ ContainsAllOf()

◆ ContainsAnyOf()

◆ ContainsNoneOf()

◆ CreateBitMask32()

◆ CreateBitMask64()

◆ Exponent() [1/2]

◆ Exponent() [2/2]

◆ ExtractBits32()

◆ ExtractBits64()

◆ FastSignBit() [1/2]

◆ FastSignBit() [2/2]

◆ Finally()

◆ From32BitsTo64Bits()

◆ GetHigh32Bits()

◆ GetLow32Bits()

◆ IndexOfBitFromLSB() [1/2]

◆ IndexOfBitFromLSB() [2/2]

◆ IndexOfBitFromMSB() [1/2]

◆ IndexOfBitFromMSB() [2/2]