oct 0.36.2

Octonary transcodings.
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

// Copyright 2024-2026 Gabriel Bjørnager Jensen.
//
// SPDX: MIT OR Apache-2.0

//! The [`Read`] trait.

use oct::serdes::Result;

#[cfg(feature = "std")]
use std::io;

#[cfg(not(feature = "std"))]
use oct::serdes::Error;

/// Trait for deserialisation buffers.
///
/// This trait serves as a stripped-down version of
/// [`std::io::Read`] intended only for
/// deserialisation.
///
#[cfg_attr(not(feature = "std"), doc = "[`std::io::Read`]: <https://doc.rust-lang.org/nightly/std/io/trait.Read.html>")]
pub trait Read {
	/// Reads from the reader into the provided buffer.
	///
	/// *See also [`std::io::Read::read`].*
	///
	#[cfg_attr(not(feature = "std"), doc = "[`std::io::Read::read`]: <https://doc.rust-lang.org/nightly/std/io/trait.Read.html#tymethod.read>")]
	///
	/// # Errors
	///
	/// This method should forward any errors that might
	/// arise from reading. An inexact read is not
	/// considered an error.
	fn read(&mut self, buf: &mut [u8]) -> Result<usize>;

	/// Reads from the reader into the provided buffer,
	/// filling it exactly.
	///
	/// *See also [`std::io::Read::read_exact`].*
	///
	#[cfg_attr(not(feature = "std"), doc = "[`std::io::Read::reaD_exact`]: <https://doc.rust-lang.org/nightly/std/io/trait.Read.html#tymethod.read_exact>")]
	///
	/// # Errors
	///
	/// This method should return an appropriate error
	/// if the buffer could not be filled exactly.
	fn read_exact(&mut self, buf: &mut [u8]) -> Result<()>;
}

#[cfg(feature = "std")]
impl<T: ?Sized + io::Read> Read for T {
	#[inline]
	fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
		io::Read::read(self, buf).map_err(Into::into)
	}

	#[inline]
	fn read_exact(&mut self, buf: &mut [u8]) -> Result<()> {
		io::Read::read_exact(self, buf).map_err(Into::into)
	}
}

// SORT: reference
#[cfg(not(feature = "std"))]
impl<T: ?Sized + Read> Read for &mut T {
	#[inline]
	fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
		T::read(*self, buf)
	}

	#[inline]
	fn read_exact(&mut self, buf: &mut [u8]) -> Result<()> {
		T::read_exact(*self, buf)
	}
}

// SORT: slice
#[cfg(not(feature = "std"))]
impl Read for &[u8] {
	fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
		let count = buf.len().min(self.len());

		let (slot, remaining) = self.split_at(count);
		buf.copy_from_slice(slot);

		*self = remaining;
		Ok(count)
	}

	#[inline]
	fn read_exact(&mut self, buf: &mut [u8]) -> Result<()> {
		if self.read(buf)? == buf.len() {
			Ok(())
		} else {
			Err(Error::unexpected_eof())
		}
	}
}