1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
|
#pragma once
#include "StarMemory.hpp"
namespace Star {
enum class ByteOrder {
BigEndian,
LittleEndian,
NoConversion
};
ByteOrder platformByteOrder();
void swapByteOrder(void* ptr, size_t len);
void swapByteOrder(void* dest, void const* src, size_t len);
void toByteOrder(ByteOrder order, void* ptr, size_t len);
void toByteOrder(ByteOrder order, void* dest, void const* src, size_t len);
void fromByteOrder(ByteOrder order, void* ptr, size_t len);
void fromByteOrder(ByteOrder order, void* dest, void const* src, size_t len);
template <typename T>
T toByteOrder(ByteOrder order, T const& t) {
T ret;
toByteOrder(order, &ret, &t, sizeof(t));
return ret;
}
template <typename T>
T fromByteOrder(ByteOrder order, T const& t) {
T ret;
fromByteOrder(order, &ret, &t, sizeof(t));
return ret;
}
template <typename T>
T toBigEndian(T const& t) {
return toByteOrder(ByteOrder::BigEndian, t);
}
template <typename T>
T fromBigEndian(T const& t) {
return fromByteOrder(ByteOrder::BigEndian, t);
}
template <typename T>
T toLittleEndian(T const& t) {
return toByteOrder(ByteOrder::LittleEndian, t);
}
template <typename T>
T fromLittleEndian(T const& t) {
return fromByteOrder(ByteOrder::LittleEndian, t);
}
inline ByteOrder platformByteOrder() {
#if STAR_LITTLE_ENDIAN
return ByteOrder::LittleEndian;
#else
return ByteOrder::BigEndian;
#endif
}
inline void swapByteOrder(void* ptr, size_t len) {
uint8_t* data = static_cast<uint8_t*>(ptr);
uint8_t spare;
for (size_t i = 0; i < len / 2; ++i) {
spare = data[len - 1 - i];
data[len - 1 - i] = data[i];
data[i] = spare;
}
}
inline void swapByteOrder(void* dest, const void* src, size_t len) {
const uint8_t* srcdata = static_cast<const uint8_t*>(src);
uint8_t* destdata = static_cast<uint8_t*>(dest);
for (size_t i = 0; i < len; ++i)
destdata[len - 1 - i] = srcdata[i];
}
inline void toByteOrder(ByteOrder order, void* ptr, size_t len) {
if (order != ByteOrder::NoConversion && platformByteOrder() != order)
swapByteOrder(ptr, len);
}
inline void toByteOrder(ByteOrder order, void* dest, void const* src, size_t len) {
if (order != ByteOrder::NoConversion && platformByteOrder() != order)
swapByteOrder(dest, src, len);
else
memcpy(dest, src, len);
}
inline void fromByteOrder(ByteOrder order, void* ptr, size_t len) {
if (order != ByteOrder::NoConversion && platformByteOrder() != order)
swapByteOrder(ptr, len);
}
inline void fromByteOrder(ByteOrder order, void* dest, void const* src, size_t len) {
if (order != ByteOrder::NoConversion && platformByteOrder() != order)
swapByteOrder(dest, src, len);
else
memcpy(dest, src, len);
}
}
|