1 files changed, 0 insertions, 120 deletions
diff --git a/vendor/rustix/src/path/dec_int.rs b/vendor/rustix/src/path/dec_int.rs
deleted file mode 100644
index e9c46f4..0000000
--- a/vendor/rustix/src/path/dec_int.rs
+++ /dev/null
@@ -1,120 +0,0 @@
-//! Efficient decimal integer formatting.
-//!
-//! # Safety
-//!
-//! This uses `CStr::from_bytes_with_nul_unchecked` and
-//! `str::from_utf8_unchecked`on the buffer that it filled itself.
-#![allow(unsafe_code)]
-
-use crate::backend::fd::{AsFd, AsRawFd};
-use crate::ffi::CStr;
-use core::fmt::Write;
-use itoa::{Buffer, Integer};
-#[cfg(all(feature = "std", unix))]
-use std::os::unix::ffi::OsStrExt;
-#[cfg(all(feature = "std", target_os = "wasi"))]
-use std::os::wasi::ffi::OsStrExt;
-#[cfg(feature = "std")]
-use {core::fmt, std::ffi::OsStr, std::path::Path};
-
-/// Format an integer into a decimal `Path` component, without constructing a
-/// temporary `PathBuf` or `String`.
-///
-/// This is used for opening paths such as `/proc/self/fd/<fd>` on Linux.
-///
-/// # Examples
-///
-/// ```
-/// # #[cfg(any(feature = "fs", feature = "net"))]
-/// use rustix::path::DecInt;
-///
-/// # #[cfg(any(feature = "fs", feature = "net"))]
-/// assert_eq!(
-///     format!("hello {}", DecInt::new(9876).as_ref().display()),
-///     "hello 9876"
-/// );
-/// ```
-#[derive(Clone)]
-pub struct DecInt {
-    // 20 `u8`s is enough to hold the decimal ASCII representation of any
-    // `u64`, and we add one for a NUL terminator for `as_c_str`.
-    buf: [u8; 20 + 1],
-    len: usize,
-}
-
-impl DecInt {
-    /// Construct a new path component from an integer.
-    #[inline]
-    pub fn new<Int: Integer>(i: Int) -> Self {
-        let mut me = DecIntWriter(Self {
-            buf: [0; 20 + 1],
-            len: 0,
-        });
-        let mut buf = Buffer::new();
-        me.write_str(buf.format(i)).unwrap();
-        me.0
-    }
-
-    /// Construct a new path component from a file descriptor.
-    #[inline]
-    pub fn from_fd<Fd: AsFd>(fd: Fd) -> Self {
-        Self::new(fd.as_fd().as_raw_fd())
-    }
-
-    /// Return the raw byte buffer as a `&str`.
-    #[inline]
-    pub fn as_str(&self) -> &str {
-        // SAFETY: `DecInt` always holds a formatted decimal number, so it's
-        // always valid UTF-8.
-        unsafe { core::str::from_utf8_unchecked(self.as_bytes()) }
-    }
-
-    /// Return the raw byte buffer as a `&CStr`.
-    #[inline]
-    pub fn as_c_str(&self) -> &CStr {
-        let bytes_with_nul = &self.buf[..=self.len];
-        debug_assert!(CStr::from_bytes_with_nul(bytes_with_nul).is_ok());
-
-        // SAFETY: `self.buf` holds a single decimal ASCII representation and
-        // at least one extra NUL byte.
-        unsafe { CStr::from_bytes_with_nul_unchecked(bytes_with_nul) }
-    }
-
-    /// Return the raw byte buffer.
-    #[inline]
-    pub fn as_bytes(&self) -> &[u8] {
-        &self.buf[..self.len]
-    }
-}
-
-struct DecIntWriter(DecInt);
-
-impl core::fmt::Write for DecIntWriter {
-    #[inline]
-    fn write_str(&mut self, s: &str) -> core::fmt::Result {
-        match self.0.buf.get_mut(self.0.len..self.0.len + s.len()) {
-            Some(slice) => {
-                slice.copy_from_slice(s.as_bytes());
-                self.0.len += s.len();
-                Ok(())
-            }
-            None => Err(core::fmt::Error),
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-impl AsRef<Path> for DecInt {
-    #[inline]
-    fn as_ref(&self) -> &Path {
-        let as_os_str: &OsStr = OsStrExt::from_bytes(&self.buf[..self.len]);
-        Path::new(as_os_str)
-    }
-}
-
-#[cfg(feature = "std")]
-impl fmt::Debug for DecInt {
-    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.as_str().fmt(fmt)
-    }
-}