datex_core/utils/
buffers.rs

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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
use byteorder::{LittleEndian, ReadBytesExt};
use itertools::Itertools;
use core::fmt::Write;

/*
read functions for primitive data types on a u8 array, also increments the index
 */

pub fn read_u8(buffer: &[u8], index: &mut usize) -> u8 {
	let val = buffer[*index];
	*index += 1;
	return val;
}


pub fn read_i8(buffer: &[u8], index: &mut usize) -> i8 {
	let mut slice = &buffer[*index..*index+1];
	*index += 1;
	return slice.read_i8().unwrap();
}

pub fn read_u16(buffer: &[u8], index: &mut usize) -> u16 {
	let mut slice = &buffer[*index..*index+2];
	*index += 2;
	return slice.read_u16::<LittleEndian>().unwrap();
}
pub fn read_i16(buffer: &[u8], index: &mut usize) -> i16 {
	let mut slice = &buffer[*index..*index+2];
	*index += 2;
	return slice.read_i16::<LittleEndian>().unwrap();
}

pub fn read_i32(buffer: &[u8], index: &mut usize) -> i32 {
	let mut slice = &buffer[*index..*index+4];
	*index += 4;
	return slice.read_i32::<LittleEndian>().unwrap();
}
pub fn read_u32(buffer: &[u8], index: &mut usize) -> u32 {
	let mut slice = &buffer[*index..*index+4];
	*index += 4;
	return slice.read_u32::<LittleEndian>().unwrap();
}

pub fn read_u64(buffer: &[u8], index: &mut usize) -> u64 {
	let mut slice = &buffer[*index..*index+8];
	*index += 8;
	return slice.read_u64::<LittleEndian>().unwrap();
}
pub fn read_i64(buffer: &[u8], index: &mut usize) -> i64 {
	let mut slice = &buffer[*index..*index+8];
	*index += 8;
	return slice.read_i64::<LittleEndian>().unwrap();
}

pub fn read_f64(buffer: &[u8], index: &mut usize) -> f64 {
	let mut slice = &buffer[*index..*index+8];
	*index += 8;
	return slice.read_f64::<LittleEndian>().unwrap();
}


pub fn read_string_utf8(buffer: &[u8], index: &mut usize, size: usize) -> String {
	// end is min(index+size, buffer len)
	let end = if *index+size > buffer.len() {buffer.len()} else {*index+size};
	let slice = &buffer[*index..end];
	*index = end;
	return String::from_utf8(slice.to_vec()).unwrap_or("⎣INVALID UTF8 STRING⎤".to_string());
}

pub fn read_slice(buffer: &[u8], index: &mut usize, size: usize) -> Vec<u8> {
	let slice = &buffer[*index..*index+size];
	*index += size;
	return slice.to_vec();
}



/*
write functions: set value at specific index in byte vector, vector length must be big enough
append functions: appends the value at the end of the byte vector, automatically increases size
 */


pub fn write_u8(buffer: &mut Vec<u8>, index: &mut usize, val: u8) {
	buffer[*index] = val;
	*index += 1;
}
pub fn append_u8(buffer: &mut Vec<u8>, val: u8) {
	buffer.extend_from_slice(&[val]);
}
pub fn write_i8(buffer: &mut Vec<u8>, index: &mut usize, val: i8) {
	let bytes = val.to_le_bytes();
	for b in bytes {
		buffer[*index] = b;
		*index += 1;
	}
}
pub fn append_i8(buffer: &mut Vec<u8>, val: i8) {
	buffer.extend_from_slice(&val.to_le_bytes());
}

pub fn write_u16(buffer: &mut Vec<u8>, index: &mut usize, val: u16) {
	let bytes = val.to_le_bytes();
	for b in bytes {
		buffer[*index] = b;
		*index += 1;
	}
}
pub fn append_u16(buffer: &mut Vec<u8>, val: u16) {
	buffer.extend_from_slice(&val.to_le_bytes());
}
pub fn write_i16(buffer: &mut Vec<u8>, index: &mut usize, val: i16) {
	let bytes = val.to_le_bytes();
	for b in bytes {
		buffer[*index] = b;
		*index += 1;
	}
}
pub fn append_i16(buffer: &mut Vec<u8>, val: i16) {
	buffer.extend_from_slice(&val.to_le_bytes());
}

pub fn write_u32(buffer: &mut Vec<u8>, index: &mut usize, val: u32) {
	let bytes = val.to_le_bytes();
	for b in bytes {
		buffer[*index] = b;
		*index += 1;
	}
}
pub fn append_u32(buffer: &mut Vec<u8>, val: u32) {
	buffer.extend_from_slice(&val.to_le_bytes());
}
pub fn write_i32(buffer: &mut Vec<u8>, index: &mut usize, val: i32) {
	let bytes = val.to_le_bytes();
	for b in bytes {
		buffer[*index] = b;
		*index += 1;
	}
}
pub fn append_i32(buffer: &mut Vec<u8>, val: i32) {
	buffer.extend_from_slice(&val.to_le_bytes());
}

pub fn write_u64(buffer: &mut Vec<u8>, index: &mut usize, val: u64) {
	let bytes = val.to_le_bytes();
	for b in bytes {
		buffer[*index] = b;
		*index += 1;
	}
}
pub fn append_u64(buffer: &mut Vec<u8>, val: u64) {
	buffer.extend_from_slice(&val.to_le_bytes());
}
pub fn write_i64(buffer: &mut Vec<u8>, index: &mut usize, val: i64) {
	let bytes = val.to_le_bytes();
	for b in bytes {
		buffer[*index] = b;
		*index += 1;
	}
}
pub fn append_i64(buffer: &mut Vec<u8>, val: i64) {
	buffer.extend_from_slice(&val.to_le_bytes());
}

pub fn write_f64(buffer: &mut Vec<u8>, index: &mut usize, val: f64) {
	let bytes = val.to_le_bytes();
	for b in bytes {
		buffer[*index] = b;
		*index += 1;
	}
}
pub fn append_f64(buffer: &mut Vec<u8>, val: f64) {
	buffer.extend_from_slice(&val.to_le_bytes());
}

pub fn append_string_utf8(buffer: &mut Vec<u8>, val: &str) {
	buffer.extend_from_slice(val.as_bytes());
}

// hex - buffer conversions

pub fn buffer_to_hex(buffer:Vec<u8>) -> String {
	let n = buffer.len();

	let mut s = String::with_capacity(2 * n);
	for byte in buffer {
		write!(s, "{:02X}", byte).expect("could not parse buffer")
	}
	return s;
}

/**
 * seperator: char sequence inserted between each byte
 * pad_size_bytes: if 0, it is ignored
 * x_shorthand: collapse multiple 0 bytes to "xC", with C being the number of zero bytes
 */
pub fn buffer_to_hex_advanced(buffer:Vec<u8>, seperator:&str, pad_size_bytes:usize, x_shorthand:bool) -> String {
	let n = if pad_size_bytes==0 {buffer.len()} else {pad_size_bytes};

	let buf_len = buffer.len();

	let mut s = String::with_capacity(2 * n);
	let mut i = 0;
	while i < n {
		// next byte
		let byte = if i<buf_len {buffer[i]} else {0};
		i += 1;
		// multiple (>=2) zero bytes - x shorthand
		if x_shorthand && byte == 0 && i < n && if i<buf_len {buffer[i]} else {0} == 0 {
			let mut zero_count:u8 = 2;
			let initial_i = i;
			while i+1 < n && buffer[i+1] == 0 {
				i += 1;
				zero_count += 1;
			}
			// 0 count, max 15
			if zero_count <= 0xf {
				i += 1;
				write!(s, "x{:01X}", zero_count).expect("could not parse buffer");
			}
			else {
				i = initial_i;
				write!(s, "{:02X}", byte).expect("could not parse buffer");
			}

		}
		// normal
		else {
			write!(s, "{:02X}", byte).expect("could not parse buffer");
		}

		// seperator?
		if seperator.len()!=0 && i<n {
			s += seperator;
		}
	}

	return s;
}


pub fn hex_to_buffer(hex:String) -> Vec<u8> {
	let mut buffer = Vec::<u8>::new();

	for chunk in &hex.chars().chunks(2) {
		buffer.push(u8::from_str_radix(&String::from_iter(chunk), 16).expect("invalid hex buffer"));
    };

	return buffer;
}

pub fn hex_to_buffer_advanced(hex:String, seperator:&str) -> Vec<u8> {
	let mut buffer = Vec::<u8>::new();

	let raw_hex = hex.replace(seperator, "");

	for chunk in &raw_hex.chars().chunks(2) {
		let part = &String::from_iter(chunk);
		if part.starts_with("x") {
			let count = u8::from_str_radix(part.split_at(1).1, 16).expect("invalid x shortcut");
			for _i in 0..count {
				buffer.push(0);
			}
		}
		else {
			buffer.push(u8::from_str_radix(part, 16).expect("invalid hex buffer"));
		}
    };

	return buffer;
}