findfile 0.2.8

An ergonomic way to search for files
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
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

use std::fmt::{self, Display, Formatter};

mod suffix;
pub use suffix::Suffix;

// Note: by using `f64` instead of `u64` as the backing type, we _technically_
// could have rounding errors. However, `f64` can successfully store `u52`s natively, so unless
// a filesize is larger than 4,503,599,627,370,495 bytes (4.5 quadrillion, ie 4.5e15) it doesn't
// really matter.
#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct FileSize(u64);

impl FileSize {
	pub fn new(amount: f64, suffix: Suffix) -> Option<Self> {
		let integer = (amount * (suffix as u64 as f64)) as u64;

		// assert!(
		// 	integer == 0 || 10u64.checked_pow(precision.unwrap_or(0) as _).unwrap() <= integer,
		// 	"Todo: check for precision"
		// );
		/* n.ilog10()-p >= 2?  */

		// dbg!(integer as u64 as f64, integer, integer as u64);
		// if (integer as u64 as f64) != integer {
		// 	return None;
		// }

		Some(Self::from_bytes(integer))
	}

	pub const fn from_bytes(bytes: u64) -> Self {
		Self(bytes)
	}

	pub const fn bytes(self) -> u64 {
		self.0
	}

	pub const fn mul(self, rhs: u64) -> Self {
		Self::from_bytes(self.bytes() * rhs)
	}

	pub fn fuzzy_matches(self, tomatch: Self, precision: u8) -> bool {
		if self.bytes() < 10 {
			return self == tomatch;
		}

		let bytes = self.bytes();
		let offset = 10u64.pow(bytes.ilog10() - (precision as u32) - 1);
		(bytes..bytes + offset).contains(&tomatch.bytes())
	}
}

impl PartialEq<u64> for FileSize {
	fn eq(&self, rhs: &u64) -> bool {
		self.bytes() == *rhs
	}
}

impl PartialOrd<u64> for FileSize {
	fn partial_cmp(&self, rhs: &u64) -> Option<std::cmp::Ordering> {
		self.bytes().partial_cmp(rhs)
	}
}

impl Display for FileSize {
	// even tho we're using floating point numbers, there shouldn't be any errors until you hit
	// 1.0/f64::EPSILON, which will be in the yottabyte range.
	fn fmt(&self, f: &mut Formatter) -> fmt::Result {
		let is_byte = f.alternate();
		let bytes = self.bytes();

		let base = if is_byte { Suffix::KibiByte } else { Suffix::KiloByte } as u64;
		let mut pow = 0;
		while pow < Suffix::MAX_EXPONENT && base.pow(pow + 1) < bytes {
			pow += 1;
		}

		let ratio = (bytes as f64) / (base.pow(pow) as f64);
		let unit = Suffix::unit_for(pow, is_byte);
		let binary = if is_byte { "i" } else { "" };

		write!(
			f,
			"{ratio:.*}{unit}{binary}B",
			std::cmp::min(f.precision().unwrap_or(0), 3 * (pow as usize))
		)
	}
}

// impl Display for FileSize {
// 	// even tho we're using floating point numbers, there shouldn't be any errors until you hit
// 	// 1.0/f64::EPSILON, which will be in the yottabyte range.
// 	fn fmt(&self, f: &mut Formatter) -> fmt::Result {
// 		let base = if f.alternate() {
// 			Self::new(1.0, Suffix::KibiByte).unwrap()
// 		} else {
// 			Self::new(1.0, Suffix::KiloByte).unwrap()
// 		};

// 		let mut pow = 1;

// 		while pow <= 6 && *self > base.0.pow(pow) {
// 			pow += 1;
// 		}

// 		// assert_eq!(self.0.ilog2() / 10, pow - 1);

// 		pow -= 1;
// 		let ratio = self.fdiv(FileSize(base.0.pow(pow)));
// 		let unit = match pow {
// 			0 => "", // nothing
// 			1 => {
// 				// `KiB` vs `kB`
// 				if f.alternate() {
// 					"K"
// 				} else {
// 					"k"
// 				}
// 			}
// 			2 => "M",
// 			3 => "G",
// 			4 => "T",
// 			5 => "P",
// 			6 => "E",
// 			_ => unreachable!("power too large? {pow}"),
// 		};

// 		write!(
// 			f,
// 			"{ratio:.*}{unit}{binary}B",
// 			std::cmp::min(f.precision().unwrap_or(0), 3 * (pow as usize)),
// 			binary = if f.alternate() { "i" } else { "" },
// 		)
// 	}
// }

#[cfg(test)]
mod tests {
	use super::*;

	#[test]
	fn foo() {
		for x in 1..10_001 {
			let _ = FileSize::new(x as f64, Suffix::KiloByte, None).unwrap().to_string();
		}
		assert_eq!("12kB", FileSize::new(12.0, Suffix::KiloByte, None).unwrap().to_string());
		assert_eq!("1B", FileSize::new(1.0, Suffix::None, None).unwrap().to_string());
	}
}