Skip to main content

se_io/
serialization.rs

1use byteorder::ByteOrder;
2use byteorder::{BigEndian, LittleEndian};
3
4/// Read a `u16` from a buffer. (Little Endian)
5pub fn read_u16(buf: &[u8]) -> u16 {
6    LittleEndian::read_u16(buf)
7}
8/// Read a `u32` from a buffer. (Little Endian)
9pub fn read_u32(buf: &[u8]) -> u32 {
10    LittleEndian::read_u32(buf)
11}
12/// Read a `u64` from a buffer. (Little Endian)
13pub fn read_u64(buf: &[u8]) -> u64 {
14    LittleEndian::read_u64(buf)
15}
16/// Read a `u128` from a buffer. (Little Endian)
17pub fn read_u128(buf: &[u8]) -> u128 {
18    LittleEndian::read_u128(buf)
19}
20
21/// Read a `i16` from a buffer. (Little Endian)
22pub fn read_i16(buf: &[u8]) -> i16 {
23    LittleEndian::read_i16(buf)
24}
25/// Read a `i32` from a buffer. (Little Endian)
26pub fn read_i32(buf: &[u8]) -> i32 {
27    LittleEndian::read_i32(buf)
28}
29/// Read a `i64` from a buffer. (Little Endian)
30pub fn read_i64(buf: &[u8]) -> i64 {
31    LittleEndian::read_i64(buf)
32}
33/// Read a `i128` from a buffer. (Little Endian)
34pub fn read_i128(buf: &[u8]) -> i128 {
35    LittleEndian::read_i128(buf)
36}
37
38/// Read a `f32` from a buffer. (Little Endian)
39pub fn read_f32(buf: &[u8]) -> f32 {
40    LittleEndian::read_f32(buf)
41}
42/// Read a `f64` from a buffer. (Little Endian)
43pub fn read_f64(buf: &[u8]) -> f64 {
44    LittleEndian::read_f64(buf)
45}
46
47/// Read a `u16` from a buffer. (Big Endian)
48pub fn read_u16_be(buf: &[u8]) -> u16 {
49    BigEndian::read_u16(buf)
50}
51/// Read a `u32` from a buffer. (Big Endian)
52pub fn read_u32_be(buf: &[u8]) -> u32 {
53    BigEndian::read_u32(buf)
54}
55/// Read a `u64` from a buffer. (Big Endian)
56pub fn read_u64_be(buf: &[u8]) -> u64 {
57    BigEndian::read_u64(buf)
58}
59/// Read a `u128` from a buffer. (Big Endian)
60pub fn read_u128_be(buf: &[u8]) -> u128 {
61    BigEndian::read_u128(buf)
62}
63
64/// Read a `i16` from a buffer. (Big Endian)
65pub fn read_i16_be(buf: &[u8]) -> i16 {
66    BigEndian::read_i16(buf)
67}
68/// Read a `i32` from a buffer. (Big Endian)
69pub fn read_i32_be(buf: &[u8]) -> i32 {
70    BigEndian::read_i32(buf)
71}
72/// Read a `i64` from a buffer. (Big Endian)
73pub fn read_i64_be(buf: &[u8]) -> i64 {
74    BigEndian::read_i64(buf)
75}
76/// Read a `i128` from a buffer. (Big Endian)
77pub fn read_i128_be(buf: &[u8]) -> i128 {
78    BigEndian::read_i128(buf)
79}
80
81/// Read a `f32` from a buffer. (Big Endian)
82pub fn read_f32_be(buf: &[u8]) -> f32 {
83    BigEndian::read_f32(buf)
84}
85/// Read a `f64` from a buffer. (Big Endian)
86pub fn read_f64_be(buf: &[u8]) -> f64 {
87    BigEndian::read_f64(buf)
88}
89
90/// Write a `u16` to a buffer. (Little Endian)
91pub fn write_u16(buf: &mut [u8], n: u16) {
92    LittleEndian::write_u16(buf, n);
93}
94/// Write a `u32` to a buffer. (Little Endian)
95pub fn write_u32(buf: &mut [u8], n: u32) {
96    LittleEndian::write_u32(buf, n);
97}
98/// Write a `u64` to a buffer. (Little Endian)
99pub fn write_u64(buf: &mut [u8], n: u64) {
100    LittleEndian::write_u64(buf, n);
101}
102/// Write a `u64` to a buffer. (Little Endian)
103pub fn write_u128(buf: &mut [u8], n: u128) {
104    LittleEndian::write_u128(buf, n);
105}
106
107/// Write a `i16` to a buffer. (Little Endian)
108pub fn write_i16(buf: &mut [u8], n: i16) {
109    LittleEndian::write_i16(buf, n);
110}
111/// Write a `i32` to a buffer. (Little Endian)
112pub fn write_i32(buf: &mut [u8], n: i32) {
113    LittleEndian::write_i32(buf, n);
114}
115/// Write a `i64` to a buffer. (Little Endian)
116pub fn write_i64(buf: &mut [u8], n: i64) {
117    LittleEndian::write_i64(buf, n);
118}
119/// Write a `i64` to a buffer. (Little Endian)
120pub fn write_i128(buf: &mut [u8], n: i128) {
121    LittleEndian::write_i128(buf, n);
122}
123
124/// Write a `f32` to a buffer. (Little Endian)
125pub fn write_f32(buf: &mut [u8], n: f32) {
126    LittleEndian::write_f32(buf, n);
127}
128/// Write a `f64` to a buffer. (Little Endian)
129pub fn write_f64(buf: &mut [u8], n: f64) {
130    LittleEndian::write_f64(buf, n);
131}
132
133/// Write a `u16` to a buffer. (Big Endian)
134pub fn write_u16_be(buf: &mut [u8], n: u16) {
135    BigEndian::write_u16(buf, n);
136}
137/// Write a `u32` to a buffer. (Big Endian)
138pub fn write_u32_be(buf: &mut [u8], n: u32) {
139    BigEndian::write_u32(buf, n);
140}
141/// Write a `u64` to a buffer. (Big Endian)
142pub fn write_u64_be(buf: &mut [u8], n: u64) {
143    BigEndian::write_u64(buf, n);
144}
145/// Write a `u64` to a buffer. (Big Endian)
146pub fn write_u128_be(buf: &mut [u8], n: u128) {
147    BigEndian::write_u128(buf, n);
148}
149
150/// Write a `i16` to a buffer. (Big Endian)
151pub fn write_i16_be(buf: &mut [u8], n: i16) {
152    BigEndian::write_i16(buf, n);
153}
154/// Write a `i32` to a buffer. (Big Endian)
155pub fn write_i32_be(buf: &mut [u8], n: i32) {
156    BigEndian::write_i32(buf, n);
157}
158/// Write a `i64` to a buffer. (Big Endian)
159pub fn write_i64_be(buf: &mut [u8], n: i64) {
160    BigEndian::write_i64(buf, n);
161}
162/// Write a `i64` to a buffer. (Big Endian)
163pub fn write_i128_be(buf: &mut [u8], n: i128) {
164    BigEndian::write_i128(buf, n);
165}
166
167/// Write a `f32` to a buffer. (Big Endian)
168pub fn write_f32_be(buf: &mut [u8], n: f32) {
169    BigEndian::write_f32(buf, n);
170}
171/// Write a `f64` to a buffer. (Big Endian)
172pub fn write_f64_be(buf: &mut [u8], n: f64) {
173    BigEndian::write_f64(buf, n);
174}