From 1b6a04ca5504955c571d1c97504fb45ea0befee4 Mon Sep 17 00:00:00 2001
From: Valentin Popov <valentin@popov.link>
Date: Mon, 8 Jan 2024 01:21:28 +0400
Subject: Initial vendor packages

Signed-off-by: Valentin Popov <valentin@popov.link>
---
 vendor/serde_json/src/io/core.rs | 79 ++++++++++++++++++++++++++++++++++++++++
 vendor/serde_json/src/io/mod.rs  | 20 ++++++++++
 2 files changed, 99 insertions(+)
 create mode 100644 vendor/serde_json/src/io/core.rs
 create mode 100644 vendor/serde_json/src/io/mod.rs

(limited to 'vendor/serde_json/src/io')

diff --git a/vendor/serde_json/src/io/core.rs b/vendor/serde_json/src/io/core.rs
new file mode 100644
index 0000000..54c8ddf
--- /dev/null
+++ b/vendor/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,
+}
+
+// I/O errors can never occur in no-std mode. All our no-std I/O 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/vendor/serde_json/src/io/mod.rs b/vendor/serde_json/src/io/mod.rs
new file mode 100644
index 0000000..9dee4a0
--- /dev/null
+++ b/vendor/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};
-- 
cgit v1.2.3