1use std::sync::atomic::{AtomicU64, Ordering};
10
11pub trait RangeReader {
13 fn len(&self) -> u64;
15
16 fn is_empty(&self) -> bool {
18 self.len() == 0
19 }
20
21 fn read_at(&self, offset: u64, len: u64) -> std::io::Result<Vec<u8>>;
24
25 fn read_many(&self, ranges: &[(u64, u64)]) -> std::io::Result<Vec<Vec<u8>>> {
31 ranges
32 .iter()
33 .map(|&(offset, len)| self.read_at(offset, len))
34 .collect()
35 }
36
37 fn concurrency(&self) -> usize {
43 1
44 }
45
46 fn resident_prefix(&self) -> u64 {
54 0
55 }
56}
57
58impl<R: RangeReader + ?Sized> RangeReader for std::sync::Arc<R> {
61 fn len(&self) -> u64 {
62 (**self).len()
63 }
64
65 fn read_at(&self, offset: u64, len: u64) -> std::io::Result<Vec<u8>> {
66 (**self).read_at(offset, len)
67 }
68
69 fn read_many(&self, ranges: &[(u64, u64)]) -> std::io::Result<Vec<Vec<u8>>> {
70 (**self).read_many(ranges)
71 }
72
73 fn concurrency(&self) -> usize {
74 (**self).concurrency()
75 }
76
77 fn resident_prefix(&self) -> u64 {
78 (**self).resident_prefix()
79 }
80}
81
82pub struct SliceReader<'a> {
84 data: &'a [u8],
85}
86
87impl<'a> SliceReader<'a> {
88 pub fn new(data: &'a [u8]) -> Self {
89 Self { data }
90 }
91}
92
93impl RangeReader for SliceReader<'_> {
94 fn len(&self) -> u64 {
95 self.data.len() as u64
96 }
97
98 fn read_at(&self, offset: u64, len: u64) -> std::io::Result<Vec<u8>> {
99 let range = usize::try_from(offset).ok().and_then(|start| {
102 let end = start.checked_add(usize::try_from(len).ok()?)?;
103 (end <= self.data.len()).then_some(start..end)
104 });
105 let range = range.ok_or_else(|| {
106 std::io::Error::new(std::io::ErrorKind::UnexpectedEof, "range out of bounds")
107 })?;
108 Ok(self.data[range].to_vec())
109 }
110}
111
112pub struct CountingReader<R> {
117 inner: R,
118 requests: AtomicU64,
119 bytes: AtomicU64,
120}
121
122impl<R: RangeReader> CountingReader<R> {
123 pub fn new(inner: R) -> Self {
124 Self {
125 inner,
126 requests: AtomicU64::new(0),
127 bytes: AtomicU64::new(0),
128 }
129 }
130
131 pub fn requests(&self) -> u64 {
133 self.requests.load(Ordering::Relaxed)
134 }
135
136 pub fn bytes_read(&self) -> u64 {
138 self.bytes.load(Ordering::Relaxed)
139 }
140}
141
142impl<R: RangeReader> RangeReader for CountingReader<R> {
143 fn len(&self) -> u64 {
144 self.inner.len()
145 }
146
147 fn read_at(&self, offset: u64, len: u64) -> std::io::Result<Vec<u8>> {
148 let out = self.inner.read_at(offset, len)?;
149 self.requests.fetch_add(1, Ordering::Relaxed);
150 self.bytes.fetch_add(out.len() as u64, Ordering::Relaxed);
151 Ok(out)
152 }
153
154 fn read_many(&self, ranges: &[(u64, u64)]) -> std::io::Result<Vec<Vec<u8>>> {
158 let out = self.inner.read_many(ranges)?;
159 self.requests.fetch_add(out.len() as u64, Ordering::Relaxed);
160 self.bytes
161 .fetch_add(out.iter().map(|b| b.len() as u64).sum(), Ordering::Relaxed);
162 Ok(out)
163 }
164
165 fn concurrency(&self) -> usize {
166 self.inner.concurrency()
167 }
168
169 fn resident_prefix(&self) -> u64 {
170 self.inner.resident_prefix()
171 }
172}
173
174pub struct OffsetReader<R> {
180 inner: R,
181 base: u64,
182}
183
184impl<R> OffsetReader<R> {
185 pub fn new(inner: R, base: u64) -> Self {
186 Self { inner, base }
187 }
188 pub fn base(&self) -> u64 {
189 self.base
190 }
191 pub fn into_inner(self) -> R {
192 self.inner
193 }
194}
195
196impl<R: RangeReader> RangeReader for OffsetReader<R> {
197 fn len(&self) -> u64 {
198 self.inner.len().saturating_sub(self.base)
199 }
200
201 fn read_at(&self, offset: u64, len: u64) -> std::io::Result<Vec<u8>> {
202 self.inner.read_at(self.base + offset, len)
203 }
204
205 fn read_many(&self, ranges: &[(u64, u64)]) -> std::io::Result<Vec<Vec<u8>>> {
206 let shifted: Vec<(u64, u64)> = ranges.iter().map(|&(o, l)| (self.base + o, l)).collect();
207 self.inner.read_many(&shifted)
208 }
209
210 fn concurrency(&self) -> usize {
211 self.inner.concurrency()
212 }
213
214 fn resident_prefix(&self) -> u64 {
215 self.inner.resident_prefix().saturating_sub(self.base)
216 }
217}
218
219pub const POLYGLOT_MARKER: &[u8] = b"RETE-BASE:";
225pub const POLYGLOT_DIGITS: usize = 16;
227
228pub fn detect_polyglot_base(head: &[u8]) -> Option<u64> {
231 let pos = head
232 .windows(POLYGLOT_MARKER.len())
233 .position(|w| w == POLYGLOT_MARKER)?;
234 let start = pos + POLYGLOT_MARKER.len();
235 let digits = head.get(start..start + POLYGLOT_DIGITS)?;
236 std::str::from_utf8(digits).ok()?.parse::<u64>().ok()
237}
238
239pub struct BytesReader(pub std::sync::Arc<[u8]>);
243
244impl RangeReader for BytesReader {
245 fn len(&self) -> u64 {
246 self.0.len() as u64
247 }
248
249 fn read_at(&self, offset: u64, len: u64) -> std::io::Result<Vec<u8>> {
250 let end = offset
251 .checked_add(len)
252 .filter(|&e| e <= self.0.len() as u64)
253 .ok_or_else(|| {
254 std::io::Error::new(std::io::ErrorKind::UnexpectedEof, "range out of bounds")
255 })?;
256 Ok(self.0[offset as usize..end as usize].to_vec())
257 }
258}
259
260pub struct PrefixReader<R> {
265 inner: R,
266 prefix: std::sync::Arc<[u8]>,
267}
268
269impl<R: RangeReader> PrefixReader<R> {
270 pub fn new(inner: R, prefix: std::sync::Arc<[u8]>) -> Self {
272 PrefixReader { inner, prefix }
273 }
274
275 fn cut(&self, offset: u64, len: u64) -> Option<Vec<u8>> {
276 let end = offset.checked_add(len)?;
277 (end <= self.prefix.len() as u64)
278 .then(|| self.prefix[offset as usize..end as usize].to_vec())
279 }
280}
281
282impl<R: RangeReader> RangeReader for PrefixReader<R> {
283 fn len(&self) -> u64 {
284 self.inner.len()
285 }
286
287 fn read_at(&self, offset: u64, len: u64) -> std::io::Result<Vec<u8>> {
288 match self.cut(offset, len) {
289 Some(b) => Ok(b),
290 None => self.inner.read_at(offset, len),
291 }
292 }
293
294 fn read_many(&self, ranges: &[(u64, u64)]) -> std::io::Result<Vec<Vec<u8>>> {
295 let mut out: Vec<Option<Vec<u8>>> = ranges.iter().map(|&(o, l)| self.cut(o, l)).collect();
296 let rest: Vec<(u64, u64)> = ranges
297 .iter()
298 .zip(&out)
299 .filter(|(_, b)| b.is_none())
300 .map(|(r, _)| *r)
301 .collect();
302 if !rest.is_empty() {
303 let mut fetched = self.inner.read_many(&rest)?.into_iter();
304 for slot in out.iter_mut().filter(|b| b.is_none()) {
305 *slot = fetched.next();
306 }
307 }
308 out.into_iter()
309 .map(|b| b.ok_or_else(|| std::io::Error::other("read_many left a range unfetched")))
310 .collect()
311 }
312
313 fn concurrency(&self) -> usize {
314 self.inner.concurrency()
315 }
316
317 fn resident_prefix(&self) -> u64 {
318 (self.prefix.len() as u64).max(self.inner.resident_prefix())
319 }
320}
321
322#[cfg(test)]
323mod tests {
324 use super::*;
325
326 #[test]
327 fn slice_reader_serves_ranges_and_bounds_check() {
328 let data = (0u8..=255).collect::<Vec<_>>();
329 let r = SliceReader::new(&data);
330 assert_eq!(r.len(), 256);
331 assert_eq!(r.read_at(10, 4).unwrap(), vec![10, 11, 12, 13]);
332 assert!(r.read_at(254, 10).is_err()); }
334
335 #[test]
336 fn counting_reader_tallies() {
337 let data = vec![0u8; 100];
338 let r = CountingReader::new(SliceReader::new(&data));
339 r.read_at(0, 10).unwrap();
340 r.read_at(50, 20).unwrap();
341 assert_eq!(r.requests(), 2);
342 assert_eq!(r.bytes_read(), 30);
343 }
344}