diff options
Diffstat (limited to 'LibOVR/Src/Kernel/OVR_Alg.h')
| -rw-r--r-- | LibOVR/Src/Kernel/OVR_Alg.h | 370 |
1 files changed, 186 insertions, 184 deletions
diff --git a/LibOVR/Src/Kernel/OVR_Alg.h b/LibOVR/Src/Kernel/OVR_Alg.h index e03cea0..00264b5 100644 --- a/LibOVR/Src/Kernel/OVR_Alg.h +++ b/LibOVR/Src/Kernel/OVR_Alg.h @@ -1,6 +1,6 @@ /************************************************************************************ -PublicHeader: OVR.h +PublicHeader: OVR_Kernel.h Filename : OVR_Alg.h Content : Simple general purpose algorithms: Sort, Binary Search, etc. Created : September 19, 2012 @@ -66,12 +66,12 @@ template <typename T> OVR_FORCE_INLINE T Lerp(T a, T b, T f) // absolutelly the same as regular gmin/gmax. template <typename T> OVR_FORCE_INLINE const T PMin(const T a, const T b) { - OVR_COMPILER_ASSERT(sizeof(T) == sizeof(UPInt)); + OVR_COMPILER_ASSERT(sizeof(T) == sizeof(size_t)); return (a < b) ? a : b; } template <typename T> OVR_FORCE_INLINE const T PMax(const T a, const T b) { - OVR_COMPILER_ASSERT(sizeof(T) == sizeof(UPInt)); + OVR_COMPILER_ASSERT(sizeof(T) == sizeof(size_t)); return (b < a) ? a : b; } @@ -99,7 +99,7 @@ template<class T> struct OperatorLess // The range is specified with start, end, where "end" is exclusive! // The comparison predicate must be specified. template<class Array, class Less> -void QuickSortSliced(Array& arr, UPInt start, UPInt end, Less less) +void QuickSortSliced(Array& arr, size_t start, size_t end, Less less) { enum { @@ -108,15 +108,15 @@ void QuickSortSliced(Array& arr, UPInt start, UPInt end, Less less) if(end - start < 2) return; - SPInt stack[80]; - SPInt* top = stack; - SPInt base = (SPInt)start; - SPInt limit = (SPInt)end; + intptr_t stack[80]; + intptr_t* top = stack; + intptr_t base = (intptr_t)start; + intptr_t limit = (intptr_t)end; for(;;) { - SPInt len = limit - base; - SPInt i, j, pivot; + intptr_t len = limit - base; + intptr_t i, j, pivot; if(len > Threshold) { @@ -201,7 +201,7 @@ void QuickSortSliced(Array& arr, UPInt start, UPInt end, Less less) // The range is specified with start, end, where "end" is exclusive! // The data type must have a defined "<" operator. template<class Array> -void QuickSortSliced(Array& arr, UPInt start, UPInt end) +void QuickSortSliced(Array& arr, size_t start, size_t end) { typedef typename Array::ValueType ValueType; QuickSortSliced(arr, start, end, OperatorLess<ValueType>::Compare); @@ -210,7 +210,7 @@ void QuickSortSliced(Array& arr, UPInt start, UPInt end) // Same as corresponding G_QuickSortSliced but with checking array limits to avoid // crash in the case of wrong comparator functor. template<class Array, class Less> -bool QuickSortSlicedSafe(Array& arr, UPInt start, UPInt end, Less less) +bool QuickSortSlicedSafe(Array& arr, size_t start, size_t end, Less less) { enum { @@ -219,15 +219,15 @@ bool QuickSortSlicedSafe(Array& arr, UPInt start, UPInt end, Less less) if(end - start < 2) return true; - SPInt stack[80]; - SPInt* top = stack; - SPInt base = (SPInt)start; - SPInt limit = (SPInt)end; + intptr_t stack[80]; + intptr_t* top = stack; + intptr_t base = (intptr_t)start; + intptr_t limit = (intptr_t)end; for(;;) { - SPInt len = limit - base; - SPInt i, j, pivot; + intptr_t len = limit - base; + intptr_t i, j, pivot; if(len > Threshold) { @@ -316,7 +316,7 @@ bool QuickSortSlicedSafe(Array& arr, UPInt start, UPInt end, Less less) } template<class Array> -bool QuickSortSlicedSafe(Array& arr, UPInt start, UPInt end) +bool QuickSortSlicedSafe(Array& arr, size_t start, size_t end) { typedef typename Array::ValueType ValueType; return QuickSortSlicedSafe(arr, start, end, OperatorLess<ValueType>::Compare); @@ -374,11 +374,11 @@ bool QuickSortSafe(Array& arr) // an array with all equal elements will remain "untouched", while // Quick Sort will considerably shuffle the elements in this case. template<class Array, class Less> -void InsertionSortSliced(Array& arr, UPInt start, UPInt end, Less less) +void InsertionSortSliced(Array& arr, size_t start, size_t end, Less less) { - UPInt j = start; - UPInt i = j + 1; - UPInt limit = end; + size_t j = start; + size_t i = j + 1; + size_t limit = end; for(; i < limit; j = i, i++) { @@ -401,7 +401,7 @@ void InsertionSortSliced(Array& arr, UPInt start, UPInt end, Less less) // The range is specified with start, end, where "end" is exclusive! // The data type must have a defined "<" operator. template<class Array> -void InsertionSortSliced(Array& arr, UPInt start, UPInt end) +void InsertionSortSliced(Array& arr, size_t start, size_t end) { typedef typename Array::ValueType ValueType; InsertionSortSliced(arr, start, end, OperatorLess<ValueType>::Compare); @@ -442,14 +442,14 @@ void InsertionSort(Array& arr) template<class Array> typename Array::ValueType& Median(Array& arr) { - UPInt count = arr.GetSize(); - UPInt mid = (count - 1) / 2; + size_t count = arr.GetSize(); + size_t mid = (count - 1) / 2; OVR_ASSERT(count > 0); - for (UPInt j = 0; j <= mid; j++) + for (size_t j = 0; j <= mid; j++) { - UPInt min = j; - for (UPInt k = j + 1; k < count; k++) + size_t min = j; + for (size_t k = j + 1; k < count; k++) if (arr[k] < arr[min]) min = k; Swap(arr[j], arr[min]); @@ -461,12 +461,12 @@ typename Array::ValueType& Median(Array& arr) // ***** LowerBoundSliced // template<class Array, class Value, class Less> -UPInt LowerBoundSliced(const Array& arr, UPInt start, UPInt end, const Value& val, Less less) +size_t LowerBoundSliced(const Array& arr, size_t start, size_t end, const Value& val, Less less) { - SPInt first = (SPInt)start; - SPInt len = (SPInt)(end - start); - SPInt half; - SPInt middle; + intptr_t first = (intptr_t)start; + intptr_t len = (intptr_t)(end - start); + intptr_t half; + intptr_t middle; while(len > 0) { @@ -482,7 +482,7 @@ UPInt LowerBoundSliced(const Array& arr, UPInt start, UPInt end, const Value& va len = half; } } - return (UPInt)first; + return (size_t)first; } @@ -490,7 +490,7 @@ UPInt LowerBoundSliced(const Array& arr, UPInt start, UPInt end, const Value& va // ***** LowerBoundSliced // template<class Array, class Value> -UPInt LowerBoundSliced(const Array& arr, UPInt start, UPInt end, const Value& val) +size_t LowerBoundSliced(const Array& arr, size_t start, size_t end, const Value& val) { return LowerBoundSliced(arr, start, end, val, OperatorLess<Value>::Compare); } @@ -499,7 +499,7 @@ UPInt LowerBoundSliced(const Array& arr, UPInt start, UPInt end, const Value& va // ***** LowerBoundSized // template<class Array, class Value> -UPInt LowerBoundSized(const Array& arr, UPInt size, const Value& val) +size_t LowerBoundSized(const Array& arr, size_t size, const Value& val) { return LowerBoundSliced(arr, 0, size, val, OperatorLess<Value>::Compare); } @@ -508,7 +508,7 @@ UPInt LowerBoundSized(const Array& arr, UPInt size, const Value& val) // ***** LowerBound // template<class Array, class Value, class Less> -UPInt LowerBound(const Array& arr, const Value& val, Less less) +size_t LowerBound(const Array& arr, const Value& val, Less less) { return LowerBoundSliced(arr, 0, arr.GetSize(), val, less); } @@ -518,7 +518,7 @@ UPInt LowerBound(const Array& arr, const Value& val, Less less) // ***** LowerBound // template<class Array, class Value> -UPInt LowerBound(const Array& arr, const Value& val) +size_t LowerBound(const Array& arr, const Value& val) { return LowerBoundSliced(arr, 0, arr.GetSize(), val, OperatorLess<Value>::Compare); } @@ -529,12 +529,12 @@ UPInt LowerBound(const Array& arr, const Value& val) // ***** UpperBoundSliced // template<class Array, class Value, class Less> -UPInt UpperBoundSliced(const Array& arr, UPInt start, UPInt end, const Value& val, Less less) +size_t UpperBoundSliced(const Array& arr, size_t start, size_t end, const Value& val, Less less) { - SPInt first = (SPInt)start; - SPInt len = (SPInt)(end - start); - SPInt half; - SPInt middle; + intptr_t first = (intptr_t)start; + intptr_t len = (intptr_t)(end - start); + intptr_t half; + intptr_t middle; while(len > 0) { @@ -550,7 +550,7 @@ UPInt UpperBoundSliced(const Array& arr, UPInt start, UPInt end, const Value& va len = len - half - 1; } } - return (UPInt)first; + return (size_t)first; } @@ -558,7 +558,7 @@ UPInt UpperBoundSliced(const Array& arr, UPInt start, UPInt end, const Value& va // ***** UpperBoundSliced // template<class Array, class Value> -UPInt UpperBoundSliced(const Array& arr, UPInt start, UPInt end, const Value& val) +size_t UpperBoundSliced(const Array& arr, size_t start, size_t end, const Value& val) { return UpperBoundSliced(arr, start, end, val, OperatorLess<Value>::Compare); } @@ -568,7 +568,7 @@ UPInt UpperBoundSliced(const Array& arr, UPInt start, UPInt end, const Value& va // ***** UpperBoundSized // template<class Array, class Value> -UPInt UpperBoundSized(const Array& arr, UPInt size, const Value& val) +size_t UpperBoundSized(const Array& arr, size_t size, const Value& val) { return UpperBoundSliced(arr, 0, size, val, OperatorLess<Value>::Compare); } @@ -578,7 +578,7 @@ UPInt UpperBoundSized(const Array& arr, UPInt size, const Value& val) // ***** UpperBound // template<class Array, class Value, class Less> -UPInt UpperBound(const Array& arr, const Value& val, Less less) +size_t UpperBound(const Array& arr, const Value& val, Less less) { return UpperBoundSliced(arr, 0, arr.GetSize(), val, less); } @@ -588,7 +588,7 @@ UPInt UpperBound(const Array& arr, const Value& val, Less less) // ***** UpperBound // template<class Array, class Value> -UPInt UpperBound(const Array& arr, const Value& val) +size_t UpperBound(const Array& arr, const Value& val) { return UpperBoundSliced(arr, 0, arr.GetSize(), val, OperatorLess<Value>::Compare); } @@ -599,8 +599,8 @@ UPInt UpperBound(const Array& arr, const Value& val) // template<class Array> void ReverseArray(Array& arr) { - SPInt from = 0; - SPInt to = arr.GetSize() - 1; + intptr_t from = 0; + intptr_t to = arr.GetSize() - 1; while(from < to) { Swap(arr[from], arr[to]); @@ -615,7 +615,7 @@ template<class Array> void ReverseArray(Array& arr) template<class CDst, class CSrc> void AppendArray(CDst& dst, const CSrc& src) { - UPInt i; + size_t i; for(i = 0; i < src.GetSize(); i++) dst.PushBack(src[i]); } @@ -630,13 +630,14 @@ template<class T> class ArrayAdaptor public: typedef T ValueType; ArrayAdaptor() : Data(0), Size(0) {} - ArrayAdaptor(T* ptr, UPInt size) : Data(ptr), Size(size) {} - UPInt GetSize() const { return Size; } - const T& operator [] (UPInt i) const { return Data[i]; } - T& operator [] (UPInt i) { return Data[i]; } + ArrayAdaptor(T* ptr, size_t size) : Data(ptr), Size(size) {} + size_t GetSize() const { return Size; } + int GetSizeI() const { return (int)GetSize(); } + const T& operator [] (size_t i) const { return Data[i]; } + T& operator [] (size_t i) { return Data[i]; } private: T* Data; - UPInt Size; + size_t Size; }; @@ -650,24 +651,25 @@ template<class T> class ConstArrayAdaptor public: typedef T ValueType; ConstArrayAdaptor() : Data(0), Size(0) {} - ConstArrayAdaptor(const T* ptr, UPInt size) : Data(ptr), Size(size) {} - UPInt GetSize() const { return Size; } - const T& operator [] (UPInt i) const { return Data[i]; } + ConstArrayAdaptor(const T* ptr, size_t size) : Data(ptr), Size(size) {} + size_t GetSize() const { return Size; } + int GetSizeI() const { return (int)GetSize(); } + const T& operator [] (size_t i) const { return Data[i]; } private: const T* Data; - UPInt Size; + size_t Size; }; //----------------------------------------------------------------------------------- -extern const UByte UpperBitTable[256]; -extern const UByte LowerBitTable[256]; +extern const uint8_t UpperBitTable[256]; +extern const uint8_t LowerBitTable[256]; //----------------------------------------------------------------------------------- -inline UByte UpperBit(UPInt val) +inline uint8_t UpperBit(size_t val) { #ifndef OVR_64BIT_POINTERS @@ -712,7 +714,7 @@ inline UByte UpperBit(UPInt val) } //----------------------------------------------------------------------------------- -inline UByte LowerBit(UPInt val) +inline uint8_t LowerBit(size_t val) { #ifndef OVR_64BIT_POINTERS @@ -765,18 +767,18 @@ class MemUtil public: // Memory compare - static int Cmp (const void* p1, const void* p2, UPInt byteCount) { return memcmp(p1, p2, byteCount); } - static int Cmp16(const void* p1, const void* p2, UPInt int16Count); - static int Cmp32(const void* p1, const void* p2, UPInt int32Count); - static int Cmp64(const void* p1, const void* p2, UPInt int64Count); + static int Cmp (const void* p1, const void* p2, size_t byteCount) { return memcmp(p1, p2, byteCount); } + static int Cmp16(const void* p1, const void* p2, size_t int16Count); + static int Cmp32(const void* p1, const void* p2, size_t int32Count); + static int Cmp64(const void* p1, const void* p2, size_t int64Count); }; // ** Inline Implementation -inline int MemUtil::Cmp16(const void* p1, const void* p2, UPInt int16Count) +inline int MemUtil::Cmp16(const void* p1, const void* p2, size_t int16Count) { - SInt16* pa = (SInt16*)p1; - SInt16* pb = (SInt16*)p2; + int16_t* pa = (int16_t*)p1; + int16_t* pb = (int16_t*)p2; unsigned ic = 0; if (int16Count == 0) return 0; @@ -785,10 +787,10 @@ inline int MemUtil::Cmp16(const void* p1, const void* p2, UPInt int16Count) return 0; return pa[ic] > pb[ic] ? 1 : -1; } -inline int MemUtil::Cmp32(const void* p1, const void* p2, UPInt int32Count) +inline int MemUtil::Cmp32(const void* p1, const void* p2, size_t int32Count) { - SInt32* pa = (SInt32*)p1; - SInt32* pb = (SInt32*)p2; + int32_t* pa = (int32_t*)p1; + int32_t* pb = (int32_t*)p2; unsigned ic = 0; if (int32Count == 0) return 0; @@ -797,10 +799,10 @@ inline int MemUtil::Cmp32(const void* p1, const void* p2, UPInt int32Count) return 0; return pa[ic] > pb[ic] ? 1 : -1; } -inline int MemUtil::Cmp64(const void* p1, const void* p2, UPInt int64Count) +inline int MemUtil::Cmp64(const void* p1, const void* p2, size_t int64Count) { - SInt64* pa = (SInt64*)p1; - SInt64* pb = (SInt64*)p2; + int64_t* pa = (int64_t*)p1; + int64_t* pb = (int64_t*)p2; unsigned ic = 0; if (int64Count == 0) return 0; @@ -822,8 +824,8 @@ namespace ByteUtil { // Swap the byte order of a byte array inline void SwapOrder(void* pv, int size) { - UByte* pb = (UByte*)pv; - UByte temp; + uint8_t* pb = (uint8_t*)pv; + uint8_t temp; for (int i = 0; i < size>>1; i++) { temp = pb[size-1-i]; @@ -833,29 +835,29 @@ namespace ByteUtil { } // Swap the byte order of primitive types - inline UByte SwapOrder(UByte v) { return v; } - inline SByte SwapOrder(SByte v) { return v; } - inline UInt16 SwapOrder(UInt16 v) { return UInt16(v>>8)|UInt16(v<<8); } - inline SInt16 SwapOrder(SInt16 v) { return SInt16((UInt16(v)>>8)|(v<<8)); } - inline UInt32 SwapOrder(UInt32 v) { return (v>>24)|((v&0x00FF0000)>>8)|((v&0x0000FF00)<<8)|(v<<24); } - inline SInt32 SwapOrder(SInt32 p) { return (SInt32)SwapOrder(UInt32(p)); } - inline UInt64 SwapOrder(UInt64 v) + inline uint8_t SwapOrder(uint8_t v) { return v; } + inline int8_t SwapOrder(int8_t v) { return v; } + inline uint16_t SwapOrder(uint16_t v) { return uint16_t(v>>8)|uint16_t(v<<8); } + inline int16_t SwapOrder(int16_t v) { return int16_t((uint16_t(v)>>8)|(v<<8)); } + inline uint32_t SwapOrder(uint32_t v) { return (v>>24)|((v&0x00FF0000)>>8)|((v&0x0000FF00)<<8)|(v<<24); } + inline int32_t SwapOrder(int32_t p) { return (int32_t)SwapOrder(uint32_t(p)); } + inline uint64_t SwapOrder(uint64_t v) { return (v>>56) | - ((v&UInt64(0x00FF000000000000ULL))>>40) | - ((v&UInt64(0x0000FF0000000000ULL))>>24) | - ((v&UInt64(0x000000FF00000000ULL))>>8) | - ((v&UInt64(0x00000000FF000000ULL))<<8) | - ((v&UInt64(0x0000000000FF0000ULL))<<24) | - ((v&UInt64(0x000000000000FF00ULL))<<40) | + ((v&uint64_t(0x00FF000000000000ULL))>>40) | + ((v&uint64_t(0x0000FF0000000000ULL))>>24) | + ((v&uint64_t(0x000000FF00000000ULL))>>8) | + ((v&uint64_t(0x00000000FF000000ULL))<<8) | + ((v&uint64_t(0x0000000000FF0000ULL))<<24) | + ((v&uint64_t(0x000000000000FF00ULL))<<40) | (v<<56); } - inline SInt64 SwapOrder(SInt64 v) { return (SInt64)SwapOrder(UInt64(v)); } + inline int64_t SwapOrder(int64_t v) { return (int64_t)SwapOrder(uint64_t(v)); } inline float SwapOrder(float p) { union { float p; - UInt32 v; + uint32_t v; } u; u.p = p; u.v = SwapOrder(u.v); @@ -866,7 +868,7 @@ namespace ByteUtil { { union { double p; - UInt64 v; + uint64_t v; } u; u.p = p; u.v = SwapOrder(u.v); @@ -877,99 +879,99 @@ namespace ByteUtil { #if (OVR_BYTE_ORDER == OVR_LITTLE_ENDIAN) // Little Endian to System (LE) - inline UByte LEToSystem(UByte v) { return v; } - inline SByte LEToSystem(SByte v) { return v; } - inline UInt16 LEToSystem(UInt16 v) { return v; } - inline SInt16 LEToSystem(SInt16 v) { return v; } - inline UInt32 LEToSystem(UInt32 v) { return v; } - inline SInt32 LEToSystem(SInt32 v) { return v; } - inline UInt64 LEToSystem(UInt64 v) { return v; } - inline SInt64 LEToSystem(SInt64 v) { return v; } + inline uint8_t LEToSystem(uint8_t v) { return v; } + inline int8_t LEToSystem(int8_t v) { return v; } + inline uint16_t LEToSystem(uint16_t v) { return v; } + inline int16_t LEToSystem(int16_t v) { return v; } + inline uint32_t LEToSystem(uint32_t v) { return v; } + inline int32_t LEToSystem(int32_t v) { return v; } + inline uint64_t LEToSystem(uint64_t v) { return v; } + inline int64_t LEToSystem(int64_t v) { return v; } inline float LEToSystem(float v) { return v; } inline double LEToSystem(double v) { return v; } // Big Endian to System (LE) - inline UByte BEToSystem(UByte v) { return SwapOrder(v); } - inline SByte BEToSystem(SByte v) { return SwapOrder(v); } - inline UInt16 BEToSystem(UInt16 v) { return SwapOrder(v); } - inline SInt16 BEToSystem(SInt16 v) { return SwapOrder(v); } - inline UInt32 BEToSystem(UInt32 v) { return SwapOrder(v); } - inline SInt32 BEToSystem(SInt32 v) { return SwapOrder(v); } - inline UInt64 BEToSystem(UInt64 v) { return SwapOrder(v); } - inline SInt64 BEToSystem(SInt64 v) { return SwapOrder(v); } + inline uint8_t BEToSystem(uint8_t v) { return SwapOrder(v); } + inline int8_t BEToSystem(int8_t v) { return SwapOrder(v); } + inline uint16_t BEToSystem(uint16_t v) { return SwapOrder(v); } + inline int16_t BEToSystem(int16_t v) { return SwapOrder(v); } + inline uint32_t BEToSystem(uint32_t v) { return SwapOrder(v); } + inline int32_t BEToSystem(int32_t v) { return SwapOrder(v); } + inline uint64_t BEToSystem(uint64_t v) { return SwapOrder(v); } + inline int64_t BEToSystem(int64_t v) { return SwapOrder(v); } inline float BEToSystem(float v) { return SwapOrder(v); } inline double BEToSystem(double v) { return SwapOrder(v); } // System (LE) to Little Endian - inline UByte SystemToLE(UByte v) { return v; } - inline SByte SystemToLE(SByte v) { return v; } - inline UInt16 SystemToLE(UInt16 v) { return v; } - inline SInt16 SystemToLE(SInt16 v) { return v; } - inline UInt32 SystemToLE(UInt32 v) { return v; } - inline SInt32 SystemToLE(SInt32 v) { return v; } - inline UInt64 SystemToLE(UInt64 v) { return v; } - inline SInt64 SystemToLE(SInt64 v) { return v; } + inline uint8_t SystemToLE(uint8_t v) { return v; } + inline int8_t SystemToLE(int8_t v) { return v; } + inline uint16_t SystemToLE(uint16_t v) { return v; } + inline int16_t SystemToLE(int16_t v) { return v; } + inline uint32_t SystemToLE(uint32_t v) { return v; } + inline int32_t SystemToLE(int32_t v) { return v; } + inline uint64_t SystemToLE(uint64_t v) { return v; } + inline int64_t SystemToLE(int64_t v) { return v; } inline float SystemToLE(float v) { return v; } inline double SystemToLE(double v) { return v; } // System (LE) to Big Endian - inline UByte SystemToBE(UByte v) { return SwapOrder(v); } - inline SByte SystemToBE(SByte v) { return SwapOrder(v); } - inline UInt16 SystemToBE(UInt16 v) { return SwapOrder(v); } - inline SInt16 SystemToBE(SInt16 v) { return SwapOrder(v); } - inline UInt32 SystemToBE(UInt32 v) { return SwapOrder(v); } - inline SInt32 SystemToBE(SInt32 v) { return SwapOrder(v); } - inline UInt64 SystemToBE(UInt64 v) { return SwapOrder(v); } - inline SInt64 SystemToBE(SInt64 v) { return SwapOrder(v); } + inline uint8_t SystemToBE(uint8_t v) { return SwapOrder(v); } + inline int8_t SystemToBE(int8_t v) { return SwapOrder(v); } + inline uint16_t SystemToBE(uint16_t v) { return SwapOrder(v); } + inline int16_t SystemToBE(int16_t v) { return SwapOrder(v); } + inline uint32_t SystemToBE(uint32_t v) { return SwapOrder(v); } + inline int32_t SystemToBE(int32_t v) { return SwapOrder(v); } + inline uint64_t SystemToBE(uint64_t v) { return SwapOrder(v); } + inline int64_t SystemToBE(int64_t v) { return SwapOrder(v); } inline float SystemToBE(float v) { return SwapOrder(v); } inline double SystemToBE(double v) { return SwapOrder(v); } #elif (OVR_BYTE_ORDER == OVR_BIG_ENDIAN) // Little Endian to System (BE) - inline UByte LEToSystem(UByte v) { return SwapOrder(v); } - inline SByte LEToSystem(SByte v) { return SwapOrder(v); } - inline UInt16 LEToSystem(UInt16 v) { return SwapOrder(v); } - inline SInt16 LEToSystem(SInt16 v) { return SwapOrder(v); } - inline UInt32 LEToSystem(UInt32 v) { return SwapOrder(v); } - inline SInt32 LEToSystem(SInt32 v) { return SwapOrder(v); } - inline UInt64 LEToSystem(UInt64 v) { return SwapOrder(v); } - inline SInt64 LEToSystem(SInt64 v) { return SwapOrder(v); } + inline uint8_t LEToSystem(uint8_t v) { return SwapOrder(v); } + inline int8_t LEToSystem(int8_t v) { return SwapOrder(v); } + inline uint16_t LEToSystem(uint16_t v) { return SwapOrder(v); } + inline int16_t LEToSystem(int16_t v) { return SwapOrder(v); } + inline uint32_t LEToSystem(uint32_t v) { return SwapOrder(v); } + inline int32_t LEToSystem(int32_t v) { return SwapOrder(v); } + inline uint64_t LEToSystem(uint64_t v) { return SwapOrder(v); } + inline int64_t LEToSystem(int64_t v) { return SwapOrder(v); } inline float LEToSystem(float v) { return SwapOrder(v); } inline double LEToSystem(double v) { return SwapOrder(v); } // Big Endian to System (BE) - inline UByte BEToSystem(UByte v) { return v; } - inline SByte BEToSystem(SByte v) { return v; } - inline UInt16 BEToSystem(UInt16 v) { return v; } - inline SInt16 BEToSystem(SInt16 v) { return v; } - inline UInt32 BEToSystem(UInt32 v) { return v; } - inline SInt32 BEToSystem(SInt32 v) { return v; } - inline UInt64 BEToSystem(UInt64 v) { return v; } - inline SInt64 BEToSystem(SInt64 v) { return v; } + inline uint8_t BEToSystem(uint8_t v) { return v; } + inline int8_t BEToSystem(int8_t v) { return v; } + inline uint16_t BEToSystem(uint16_t v) { return v; } + inline int16_t BEToSystem(int16_t v) { return v; } + inline uint32_t BEToSystem(uint32_t v) { return v; } + inline int32_t BEToSystem(int32_t v) { return v; } + inline uint64_t BEToSystem(uint64_t v) { return v; } + inline int64_t BEToSystem(int64_t v) { return v; } inline float BEToSystem(float v) { return v; } inline double BEToSystem(double v) { return v; } // System (BE) to Little Endian - inline UByte SystemToLE(UByte v) { return SwapOrder(v); } - inline SByte SystemToLE(SByte v) { return SwapOrder(v); } - inline UInt16 SystemToLE(UInt16 v) { return SwapOrder(v); } - inline SInt16 SystemToLE(SInt16 v) { return SwapOrder(v); } - inline UInt32 SystemToLE(UInt32 v) { return SwapOrder(v); } - inline SInt32 SystemToLE(SInt32 v) { return SwapOrder(v); } - inline UInt64 SystemToLE(UInt64 v) { return SwapOrder(v); } - inline SInt64 SystemToLE(SInt64 v) { return SwapOrder(v); } + inline uint8_t SystemToLE(uint8_t v) { return SwapOrder(v); } + inline int8_t SystemToLE(int8_t v) { return SwapOrder(v); } + inline uint16_t SystemToLE(uint16_t v) { return SwapOrder(v); } + inline int16_t SystemToLE(int16_t v) { return SwapOrder(v); } + inline uint32_t SystemToLE(uint32_t v) { return SwapOrder(v); } + inline int32_t SystemToLE(int32_t v) { return SwapOrder(v); } + inline uint64_t SystemToLE(uint64_t v) { return SwapOrder(v); } + inline int64_t SystemToLE(int64_t v) { return SwapOrder(v); } inline float SystemToLE(float v) { return SwapOrder(v); } inline double SystemToLE(double v) { return SwapOrder(v); } // System (BE) to Big Endian - inline UByte SystemToBE(UByte v) { return v; } - inline SByte SystemToBE(SByte v) { return v; } - inline UInt16 SystemToBE(UInt16 v) { return v; } - inline SInt16 SystemToBE(SInt16 v) { return v; } - inline UInt32 SystemToBE(UInt32 v) { return v; } - inline SInt32 SystemToBE(SInt32 v) { return v; } - inline UInt64 SystemToBE(UInt64 v) { return v; } - inline SInt64 SystemToBE(SInt64 v) { return v; } + inline uint8_t SystemToBE(uint8_t v) { return v; } + inline int8_t SystemToBE(int8_t v) { return v; } + inline uint16_t SystemToBE(uint16_t v) { return v; } + inline int16_t SystemToBE(int16_t v) { return v; } + inline uint32_t SystemToBE(uint32_t v) { return v; } + inline int32_t SystemToBE(int32_t v) { return v; } + inline uint64_t SystemToBE(uint64_t v) { return v; } + inline int64_t SystemToBE(int64_t v) { return v; } inline float SystemToBE(float v) { return v; } inline double SystemToBE(double v) { return v; } @@ -983,30 +985,30 @@ namespace ByteUtil { // Used primarily for hardware interfacing such as sensor reports, firmware, etc. // Reported data is all little-endian. -inline UInt16 DecodeUInt16(const UByte* buffer) +inline uint16_t DecodeUInt16(const uint8_t* buffer) { - return ByteUtil::LEToSystem ( *(const UInt16*)buffer ); + return ByteUtil::LEToSystem ( *(const uint16_t*)buffer ); } -inline SInt16 DecodeSInt16(const UByte* buffer) +inline int16_t DecodeSInt16(const uint8_t* buffer) { - return ByteUtil::LEToSystem ( *(const SInt16*)buffer ); + return ByteUtil::LEToSystem ( *(const int16_t*)buffer ); } -inline UInt32 DecodeUInt32(const UByte* buffer) +inline uint32_t DecodeUInt32(const uint8_t* buffer) { - return ByteUtil::LEToSystem ( *(const UInt32*)buffer ); + return ByteUtil::LEToSystem ( *(const uint32_t*)buffer ); } -inline SInt32 DecodeSInt32(const UByte* buffer) +inline int32_t DecodeSInt32(const uint8_t* buffer) { - return ByteUtil::LEToSystem ( *(const SInt32*)buffer ); + return ByteUtil::LEToSystem ( *(const int32_t*)buffer ); } -inline float DecodeFloat(const UByte* buffer) +inline float DecodeFloat(const uint8_t* buffer) { union { - UInt32 U; + uint32_t U; float F; }; @@ -1014,30 +1016,30 @@ inline float DecodeFloat(const UByte* buffer) return F; } -inline void EncodeUInt16(UByte* buffer, UInt16 val) +inline void EncodeUInt16(uint8_t* buffer, uint16_t val) { - *(UInt16*)buffer = ByteUtil::SystemToLE ( val ); + *(uint16_t*)buffer = ByteUtil::SystemToLE ( val ); } -inline void EncodeSInt16(UByte* buffer, SInt16 val) +inline void EncodeSInt16(uint8_t* buffer, int16_t val) { - *(SInt16*)buffer = ByteUtil::SystemToLE ( val ); + *(int16_t*)buffer = ByteUtil::SystemToLE ( val ); } -inline void EncodeUInt32(UByte* buffer, UInt32 val) +inline void EncodeUInt32(uint8_t* buffer, uint32_t val) { - *(UInt32*)buffer = ByteUtil::SystemToLE ( val ); + *(uint32_t*)buffer = ByteUtil::SystemToLE ( val ); } -inline void EncodeSInt32(UByte* buffer, SInt32 val) +inline void EncodeSInt32(uint8_t* buffer, int32_t val) { - *(SInt32*)buffer = ByteUtil::SystemToLE ( val ); + *(int32_t*)buffer = ByteUtil::SystemToLE ( val ); } -inline void EncodeFloat(UByte* buffer, float val) +inline void EncodeFloat(uint8_t* buffer, float val) { union { - UInt32 U; + uint32_t U; float F; }; @@ -1046,12 +1048,12 @@ inline void EncodeFloat(UByte* buffer, float val) } // Converts an 8-bit binary-coded decimal -inline SByte DecodeBCD(UByte byte) +inline int8_t DecodeBCD(uint8_t byte) { - UByte digit1 = (byte >> 4) & 0x0f; - UByte digit2 = byte & 0x0f; + uint8_t digit1 = (byte >> 4) & 0x0f; + uint8_t digit2 = byte & 0x0f; int decimal = digit1 * 10 + digit2; // maximum value = 99 - return (SByte)decimal; + return (int8_t)decimal; } |