tuxtrain 0.0.4

An easy-to-use generic trainer for Linux
Documentation 
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

use serde::de::Error;
use serde::de::{Deserialize, Deserializer};
use std::fmt;
use std::num::ParseIntError;
use std::ops::Index;
use std::slice::Iter;

pub struct Pattern {
	string: String,
	bytes: Vec<Option<u8>>,
}

impl Pattern {
	pub fn new(pattern: String) -> Result<Self, ParseIntError> {
		Ok(Self {
			bytes: as_bytes(&pattern)?,
			string: pattern,
		})
	}

	pub fn len(&self) -> usize {
		self.bytes.len()
	}

	pub fn iter(&self) -> Iter<'_, Option<u8>> {
		self.bytes.iter()
	}
}

impl fmt::Display for Pattern {
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
		write!(f, "{}", self.string)
	}
}

impl Index<usize> for Pattern {
	type Output = Option<u8>;

	fn index(&self, idx: usize) -> &Self::Output {
		&self.bytes[idx]
	}
}

pub fn as_bytes(pattern: &str) -> Result<Vec<Option<u8>>, ParseIntError> {
	let mut bytes = vec![];
	for hex in pattern.split(' ') {
		bytes.push(match hex {
			// __ is considered ignored
			"__" => None,
			_ => Some(u8::from_str_radix(hex, 16)?),
		});
	}

	Ok(bytes)
}

pub fn deserialize<'de, D>(deserializer: D) -> Result<Pattern, D::Error>
where
	D: Deserializer<'de>,
{
	let pattern = String::deserialize(deserializer)?;
	Pattern::new(pattern).map_err(Error::custom)
}