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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

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

//! The [`Write`] trait.

use oct::serdes::Result;

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

#[cfg(not(feature = "std"))]
use core::mem::take;

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

#[cfg(all(not(feature = "std"), feature = "alloc"))]
use alloc::vec::Vec;

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

	/// Writes the entirety of provided buffer into the
	/// writer.
	///
	/// *See also [`std::io::Write::write_all`].*
	///
	#[cfg_attr(not(feature = "std"), doc = "[`std::io::Write::write_all`]: <https://doc.rust-lang.org/nightly/std/io/trait.Write.html#tymethod.write_all>")]
	///
	/// # Errors
	///
	/// This method should return an appropriate error
	/// if the writer could not be written to
	/// completely.
	fn write_all(&mut self, buf: &[u8]) -> Result<()>;
}

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

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

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

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

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

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

		*self = remaining;
		Ok(count)
	}

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

#[cfg(all(feature = "alloc", not(feature = "std")))]
impl Write for Vec<u8> {
	fn write(&mut self, buf: &[u8]) -> Result<usize> {
		self.extend_from_slice(buf);
		Ok(buf.len())
	}

	#[inline]
	fn write_all(&mut self, buf: &[u8]) -> Result<()> {
		// NOTE: This always writes the entire buffer.
		self.write(buf)?;
		Ok(())
	}
}