diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-19 00:47:55 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-19 00:47:55 +0000 |
commit | 26a029d407be480d791972afb5975cf62c9360a6 (patch) | |
tree | f435a8308119effd964b339f76abb83a57c29483 /third_party/rust/serde_json/src/io | |
parent | Initial commit. (diff) | |
download | firefox-26a029d407be480d791972afb5975cf62c9360a6.tar.xz firefox-26a029d407be480d791972afb5975cf62c9360a6.zip |
Adding upstream version 124.0.1.upstream/124.0.1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to '')
-rw-r--r-- | third_party/rust/serde_json/src/io/core.rs | 79 | ||||
-rw-r--r-- | third_party/rust/serde_json/src/io/mod.rs | 20 |
2 files changed, 99 insertions, 0 deletions
diff --git a/third_party/rust/serde_json/src/io/core.rs b/third_party/rust/serde_json/src/io/core.rs new file mode 100644 index 0000000000..465ab8b249 --- /dev/null +++ b/third_party/rust/serde_json/src/io/core.rs @@ -0,0 +1,79 @@ +//! Reimplements core logic and types from `std::io` in an `alloc`-friendly +//! fashion. + +use alloc::vec::Vec; +use core::fmt::{self, Display}; +use core::result; + +pub enum ErrorKind { + Other, +} + +// IO errors can never occur in no-std mode. All our no-std IO implementations +// are infallible. +pub struct Error; + +impl Display for Error { + fn fmt(&self, _formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + unreachable!() + } +} + +impl Error { + pub(crate) fn new(_kind: ErrorKind, _error: &'static str) -> Error { + Error + } +} + +pub type Result<T> = result::Result<T, Error>; + +pub trait Write { + fn write(&mut self, buf: &[u8]) -> Result<usize>; + + fn write_all(&mut self, buf: &[u8]) -> Result<()> { + // All our Write impls in no_std mode always write the whole buffer in + // one call infallibly. + let result = self.write(buf); + debug_assert!(result.is_ok()); + debug_assert_eq!(result.unwrap_or(0), buf.len()); + Ok(()) + } + + fn flush(&mut self) -> Result<()>; +} + +impl<W: Write> Write for &mut W { + #[inline] + fn write(&mut self, buf: &[u8]) -> Result<usize> { + (*self).write(buf) + } + + #[inline] + fn write_all(&mut self, buf: &[u8]) -> Result<()> { + (*self).write_all(buf) + } + + #[inline] + fn flush(&mut self) -> Result<()> { + (*self).flush() + } +} + +impl Write for Vec<u8> { + #[inline] + 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<()> { + self.extend_from_slice(buf); + Ok(()) + } + + #[inline] + fn flush(&mut self) -> Result<()> { + Ok(()) + } +} diff --git a/third_party/rust/serde_json/src/io/mod.rs b/third_party/rust/serde_json/src/io/mod.rs new file mode 100644 index 0000000000..9dee4a0685 --- /dev/null +++ b/third_party/rust/serde_json/src/io/mod.rs @@ -0,0 +1,20 @@ +//! A tiny, `no_std`-friendly facade around `std::io`. +//! Reexports types from `std` when available; otherwise reimplements and +//! provides some of the core logic. +//! +//! The main reason that `std::io` hasn't found itself reexported as part of +//! the `core` crate is the `std::io::{Read, Write}` traits' reliance on +//! `std::io::Error`, which may contain internally a heap-allocated `Box<Error>` +//! and/or now relying on OS-specific `std::backtrace::Backtrace`. + +pub use self::imp::{Error, ErrorKind, Result, Write}; + +#[cfg(not(feature = "std"))] +#[path = "core.rs"] +mod imp; + +#[cfg(feature = "std")] +use std::io as imp; + +#[cfg(feature = "std")] +pub use std::io::{Bytes, Read}; |