daemonic_error 0.2.0

use alloc::borrow::Cow;
use alloc::fmt;
use core::clone::CloneToUninit;
use crate::daemonic_path_buffer::DaemonicOsStr;
use super::*;
/// inner side of DaemonicPathBuf
/// `Path::new` and `impl CloneToUninit for Path` current implementation relies
/// on `Path` being layout-compatible with `DaemonicOsStr`.
/// However, `Path` layout is considered an implementation detail and must not be relied upon.
#[repr(transparent)]
pub struct DaemonicPath {
	pub(crate) inner: DaemonicOsStr,
}
impl AsRef<DaemonicPath> for DaemonicPath {
	fn as_ref(&self) -> &DaemonicPath {
		self
	}
}
/// An error returned from [`DaemonicPath::strip_prefix`] if the prefix was not found.
///
/// This `struct` is created by the [`strip_prefix`] method on [`DaemonicPath`].
/// See its documentation for more.
///
/// [`strip_prefix`]: DaemonicPath::strip_prefix
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct StripPrefixError(());

/// Helper struct for safely printing paths with [`format!`] and `{}`.
///
/// A [`Path`] might contain non-Unicode data. This `struct` implements the
/// [`Display`] trait in a way that mitigates that. It is created by the
/// [`display`](Path::display) method on [`Path`]. This may perform lossy
/// conversion, depending on the platform. If you would like an implementation
/// which escapes the path please use [`Debug`] instead.
///
/// # Examples
///
/// ```
/// use std::path::Path;
///
/// let path = Path::new("/tmp/foo.rs");
///
/// println!("{}", path.display());
/// ```
///
/// [`Display`]: fmt::Display
/// [`format!`]: crate::format
pub struct DaemonicOsStrDisplayOuter<'a> {
	inner: DaemonicOsStrDisplayInner<'a>,
}
/// Helper struct for safely printing an [`OsStr`] with [`format!`] and `{}`.
///
/// An [`OsStr`] might contain non-Unicode data. This `struct` implements the
/// [`Display`] trait in a way that mitigates that. It is created by the
/// [`display`](OsStr::display) method on [`OsStr`]. This may perform lossy
/// conversion, depending on the platform. If you would like an implementation
/// which escapes the [`OsStr`] please use [`Debug`] instead.
///
/// # Examples
///
/// ```
/// use std::ffi::OsStr;
///
/// let s = OsStr::new("Hello, world!");
/// println!("{}", s.display());
/// ```
///
/// [`Display`]: fmt::Display
/// [`format!`]: crate::format
#[derive(Debug)]
pub struct DaemonicOsStrDisplayInner<'a> {
	os_str: &'a DaemonicOsStr,
}
impl fmt::Display for DaemonicOsStrDisplayInner<'_>
	where
		DaemonicOsStr: fmt::Display,
{
	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
		fmt::Display::fmt(self.os_str, f)
	}
}

impl fmt::Debug for DaemonicOsStrDisplayOuter<'_> {
	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
		fmt::Debug::fmt(&self.inner, f)
	}
}

impl fmt::Display for DaemonicOsStrDisplayOuter<'_> {
	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
		fmt::Display::fmt(&self.inner, f)
	}
}
impl DaemonicPath {
	// The following (private!) function allows construction of a path from a u8
	// slice, which is only safe when it is known to follow the OsStr encoding.
	pub(crate) unsafe fn from_u8_slice(s: &[u8]) -> &DaemonicPath {
		unsafe { DaemonicPath::new(DaemonicOsStr::from_encoded_bytes_unchecked(s)) }
	}
	// The following (private!) function reveals the byte encoding used for OsStr.
	pub(crate) fn as_u8_slice(&self) -> &[u8] {
		self.inner.as_encoded_bytes()
	}
	
	/// Directly wraps a string slice as a `Path` slice.
	///
	/// This is a cost-free conversion.
	///
	/// # Examples
	///
	/// ```
	/// use std::path::Path;
	///
	/// Path::new("foo.txt");
	/// ```
	///
	/// You can create `Path`s from `String`s, or even other `Path`s:
	///
	/// ```
	/// use std::path::Path;
	///
	/// let string = String::from("foo.txt");
	/// let from_string = Path::new(&string);
	/// let from_path = Path::new(&from_string);
	/// assert_eq!(from_string, from_path);
	/// ```
	pub fn new<S: AsRef<DaemonicOsStr> + ?Sized>(s: &S) -> &DaemonicPath {
		unsafe { &*(s.as_ref() as *const DaemonicOsStr as *const DaemonicPath) }
	}
	
	pub(crate) fn from_inner_mut(inner: &mut DaemonicOsStr) -> &mut DaemonicPath {
		// SAFETY: Path is just a wrapper around OsStr,
		// therefore converting &mut OsStr to &mut Path is safe.
		unsafe { &mut *(inner as *mut DaemonicOsStr as *mut DaemonicPath) }
	}
	/// Yields the underlying [`OsStr`] slice.
	///
	/// # Examples
	///
	/// ```
	/// use std::path::Path;
	///
	/// let os_str = Path::new("foo.txt").as_os_str();
	/// assert_eq!(os_str, std::ffi::OsStr::new("foo.txt"));
	/// ```
	#[must_use]
	#[inline]
	pub fn as_os_str(&self) -> &DaemonicOsStr {
		&self.inner
	}
	
	/// Yields a mutable reference to the underlying [`OsStr`] slice.
	///
	/// # Examples
	///
	/// ```
	/// use std::path::{Path, PathBuf};
	///
	/// let mut path = PathBuf::from("Foo.TXT");
	///
	/// assert_ne!(path, Path::new("foo.txt"));
	///
	/// path.as_mut_os_str().make_ascii_lowercase();
	/// assert_eq!(path, Path::new("foo.txt"));
	/// ```
	#[must_use]
	#[inline]
	pub fn as_mut_os_str(&mut self) -> &mut DaemonicOsStr {
		&mut self.inner
	}
	
	/// Yields a [`&str`] slice if the `Path` is valid unicode.
	///
	/// This conversion may entail doing a check for UTF-8 validity.
	/// Note that validation is performed because non-UTF-8 strings are
	/// perfectly valid for some OS.
	///
	/// [`&str`]: str
	///
	/// # Examples
	///
	/// ```
	/// use std::path::Path;
	///
	/// let path = Path::new("foo.txt");
	/// assert_eq!(path.to_str(), Some("foo.txt"));
	/// ```
	#[must_use = "this returns the result of the operation, \
                  without modifying the original"]
	#[inline]
	pub fn to_str(&self) -> Option<&str> {
		self.inner.to_str()
	}
	
	/// Converts a `Path` to a [`Cow<str>`].
	///
	/// Any non-UTF-8 sequences are replaced with
	/// [`U+FFFD REPLACEMENT CHARACTER`][U+FFFD].
	///
	/// [U+FFFD]: super::char::REPLACEMENT_CHARACTER
	///
	/// # Examples
	///
	/// Calling `to_string_lossy` on a `Path` with valid unicode:
	///
	/// ```
	/// use std::path::Path;
	///
	/// let path = Path::new("foo.txt");
	/// assert_eq!(path.to_string_lossy(), "foo.txt");
	/// ```
	///
	/// Had `path` contained invalid unicode, the `to_string_lossy` call might
	/// have returned `"fo�.txt"`.
	#[must_use = "this returns the result of the operation, \
                  without modifying the original"]
	#[inline]
	pub fn to_string_lossy(&self) -> Cow<'_, str> {
		self.inner.to_string_lossy()
	}
	
	/// Converts a `Path` to an owned [`PathBuf`].
	///
	/// # Examples
	///
	/// ```
	/// use std::path::{Path, PathBuf};
	///
	/// let path_buf = Path::new("foo.txt").to_path_buf();
	/// assert_eq!(path_buf, PathBuf::from("foo.txt"));
	/// ```
	#[rustc_conversion_suggestion]
	#[must_use = "this returns the result of the operation, \
                  without modifying the original"]
	pub fn to_path_buf(&self) -> DaemonicPathBuf {
		DaemonicPathBuf::from(DaemonicPathBuf { inner: self.inner.to_os_string() })
	}
	
	/// Returns `true` if the `Path` is absolute, i.e., if it is independent of
	/// the current directory.
	///
	/// * On Unix, a path is absolute if it starts with the root, so
	/// `is_absolute` and [`has_root`] are equivalent.
	///
	/// * On Windows, a path is absolute if it has a prefix and starts with the
	/// root: `c:\windows` is absolute, while `c:temp` and `\temp` are not.
	///
	/// # Examples
	///
	/// ```
	/// use std::path::Path;
	///
	/// assert!(!Path::new("foo.txt").is_absolute());
	/// ```
	///
	/// [`has_root`]: Path::has_root
	#[must_use]
	#[allow(deprecated)]
	pub fn is_absolute(&self) -> bool {
		is_absolute(self)
	}
	
	/// Returns `true` if the `Path` is relative, i.e., not absolute.
	///
	/// See [`is_absolute`]'s documentation for more details.
	///
	/// # Examples
	///
	/// ```
	/// use std::path::Path;
	///
	/// assert!(Path::new("foo.txt").is_relative());
	/// ```
	///
	/// [`is_absolute`]: Path::is_absolute
	#[must_use]
	#[inline]
	pub fn is_relative(&self) -> bool {
		!self.is_absolute()
	}
	
	pub(crate) fn prefix(&self) -> Option<Prefix<'_>> {
		self.components().prefix
	}
	
	/// Returns `true` if the `Path` has a root.
	///
	/// * On Unix, a path has a root if it begins with `/`.
	///
	/// * On Windows, a path has a root if it:
	///     * has no prefix and begins with a separator, e.g., `\windows`
	///     * has a prefix followed by a separator, e.g., `c:\windows` but not `c:windows`
	///     * has any non-disk prefix, e.g., `\\server\share`
	///
	/// # Examples
	///
	/// ```
	/// use std::path::Path;
	///
	/// assert!(Path::new("/etc/passwd").has_root());
	/// ```
	#[must_use]
	#[inline]
	pub fn has_root(&self) -> bool {
		self.components().has_root()
	}
	
	/// Returns the `Path` without its final component, if there is one.
	///
	/// This means it returns `Some("")` for relative paths with one component.
	///
	/// Returns [`None`] if the path terminates in a root or prefix, or if it's
	/// the empty string.
	///
	/// # Examples
	///
	/// ```
	/// use std::path::Path;
	///
	/// let path = Path::new("/foo/bar");
	/// let parent = path.parent().unwrap();
	/// assert_eq!(parent, Path::new("/foo"));
	///
	/// let grand_parent = parent.parent().unwrap();
	/// assert_eq!(grand_parent, Path::new("/"));
	/// assert_eq!(grand_parent.parent(), None);
	///
	/// let relative_path = Path::new("foo/bar");
	/// let parent = relative_path.parent();
	/// assert_eq!(parent, Some(Path::new("foo")));
	/// let grand_parent = parent.and_then(Path::parent);
	/// assert_eq!(grand_parent, Some(Path::new("")));
	/// let great_grand_parent = grand_parent.and_then(Path::parent);
	/// assert_eq!(great_grand_parent, None);
	/// ```
	#[doc(alias = "dirname")]
	#[must_use]
	pub fn parent(&self) -> Option<&DaemonicPath> {
		let mut comps = self.components();
		let comp = comps.next_back();
		comp.and_then(|p| match p {
			Component::Normal(_) | Component::CurDir | Component::ParentDir => {
				Some(comps.as_path())
			}
			_ => None,
		})
	}
	
	/// Produces an iterator over `Path` and its ancestors.
	///
	/// The iterator will yield the `Path` that is returned if the [`parent`] method is used zero
	/// or more times. If the [`parent`] method returns [`None`], the iterator will do likewise.
	/// The iterator will always yield at least one value, namely `Some(&self)`. Next it will yield
	/// `&self.parent()`, `&self.parent().and_then(Path::parent)` and so on.
	/// [`parent`]: Path::parent
	#[inline]
	pub fn ancestors(&self) -> Ancestors<'_> {
		Ancestors { next: Some(&self) }
	}
	
	/// Returns the final component of the `Path`, if there is one.
	///
	/// If the path is a normal file, this is the file name. If it's the path of a directory, this
	/// is the directory name.
	///
	/// Returns [`None`] if the path terminates in `..`.
	///
	/// # Examples
	///
	/// ```
	/// use std::path::Path;
	/// use std::ffi::OsStr;
	///
	/// assert_eq!(Some(OsStr::new("bin")), Path::new("/usr/bin/").file_name());
	/// assert_eq!(Some(OsStr::new("foo.txt")), Path::new("tmp/foo.txt").file_name());
	/// assert_eq!(Some(OsStr::new("foo.txt")), Path::new("foo.txt/.").file_name());
	/// assert_eq!(Some(OsStr::new("foo.txt")), Path::new("foo.txt/.//").file_name());
	/// assert_eq!(None, Path::new("foo.txt/..").file_name());
	/// assert_eq!(None, Path::new("/").file_name());
	/// ```
	#[doc(alias = "basename")]
	#[must_use]
	pub fn file_name(&self) -> Option<&DaemonicOsStr> {
		self.components().next_back().and_then(|p| match p {
			Component::Normal(p) => Some(p),
			_ => None,
		})
	}
	
	/// Returns a path that, when joined onto `base`, yields `self`.
	///
	/// # Errors
	///
	/// If `base` is not a prefix of `self` (i.e., [`starts_with`]
	/// returns `false`), returns [`Err`].
	///
	/// [`starts_with`]: Path::starts_with
	///
	/// # Examples
	///
	/// ```
	/// use std::path::{Path, PathBuf};
	///
	/// let path = Path::new("/test/haha/foo.txt");
	///
	/// assert_eq!(path.strip_prefix("/"), Ok(Path::new("test/haha/foo.txt")));
	/// assert_eq!(path.strip_prefix("/test"), Ok(Path::new("haha/foo.txt")));
	/// assert_eq!(path.strip_prefix("/test/"), Ok(Path::new("haha/foo.txt")));
	/// assert_eq!(path.strip_prefix("/test/haha/foo.txt"), Ok(Path::new("")));
	/// assert_eq!(path.strip_prefix("/test/haha/foo.txt/"), Ok(Path::new("")));
	///
	/// assert!(path.strip_prefix("test").is_err());
	/// assert!(path.strip_prefix("/te").is_err());
	/// assert!(path.strip_prefix("/haha").is_err());
	///
	/// let prefix = PathBuf::from("/test/");
	/// assert_eq!(path.strip_prefix(prefix), Ok(Path::new("haha/foo.txt")));
	/// ```
	pub fn strip_prefix<P>(&self, base: P) -> Result<&DaemonicPath, StripPrefixError>
		where
			P: AsRef<DaemonicPath>,
	{
		self._strip_prefix(base.as_ref())
	}
	
	fn _strip_prefix(&self, base: &DaemonicPath) -> Result<&DaemonicPath, StripPrefixError> {
		iter_after(self.components(), base.components())
			.map(|c| c.as_path())
			.ok_or(StripPrefixError(()))
	}
	
	/// Determines whether `base` is a prefix of `self`.
	///
	/// Only considers whole path components to match.
	///
	/// # Examples
	///
	/// ```
	/// use std::path::Path;
	///
	/// let path = Path::new("/etc/passwd");
	///
	/// assert!(path.starts_with("/etc"));
	/// assert!(path.starts_with("/etc/"));
	/// assert!(path.starts_with("/etc/passwd"));
	/// assert!(path.starts_with("/etc/passwd/")); // extra slash is okay
	/// assert!(path.starts_with("/etc/passwd///")); // multiple extra slashes are okay
	///
	/// assert!(!path.starts_with("/e"));
	/// assert!(!path.starts_with("/etc/passwd.txt"));
	///
	/// assert!(!Path::new("/etc/foo.rs").starts_with("/etc/foo"));
	/// ```
	#[must_use]
	pub fn starts_with<P: AsRef<DaemonicPath>>(&self, base: P) -> bool {
		self._starts_with(base.as_ref())
	}
	
	fn _starts_with(&self, base: &DaemonicPath) -> bool {
		iter_after(self.components(), base.components()).is_some()
	}
	
	/// Determines whether `child` is a suffix of `self`.
	///
	/// Only considers whole path components to match.
	///
	/// # Examples
	///
	/// ```
	/// use std::path::Path;
	///
	/// let path = Path::new("/etc/resolv.conf");
	///
	/// assert!(path.ends_with("resolv.conf"));
	/// assert!(path.ends_with("etc/resolv.conf"));
	/// assert!(path.ends_with("/etc/resolv.conf"));
	///
	/// assert!(!path.ends_with("/resolv.conf"));
	/// assert!(!path.ends_with("conf")); // use .extension() instead
	/// ```
	#[must_use]
	pub fn ends_with<P: AsRef<DaemonicPath>>(&self, child: P) -> bool {
		self._ends_with(child.as_ref())
	}
	
	fn _ends_with(&self, child: &DaemonicPath) -> bool {
		iter_after(self.components().rev(), child.components().rev()).is_some()
	}
	
	/// Extracts the stem (non-extension) portion of [`self.file_name`].
	///
	/// [`self.file_name`]: Path::file_name
	///
	/// The stem is:
	///
	/// * [`None`], if there is no file name;
	/// * The entire file name if there is no embedded `.`;
	/// * The entire file name if the file name begins with `.` and has no other `.`s within;
	/// * Otherwise, the portion of the file name before the final `.`
	///
	/// # Examples
	///
	/// ```
	/// use std::path::Path;
	///
	/// assert_eq!("foo", Path::new("foo.rs").file_stem().unwrap());
	/// assert_eq!("foo.tar", Path::new("foo.tar.gz").file_stem().unwrap());
	/// ```
	///
	/// # See Also
	/// This method is similar to [`Path::file_prefix`], which extracts the portion of the file name
	/// before the *first* `.`
	///
	/// [`Path::file_prefix`]: Path::file_prefix
	///
	#[must_use]
	pub fn file_stem(&self) -> Option<&DaemonicOsStr> {
		self.file_name().map(rsplit_file_at_dot).and_then(|(before, after)| before.or(after))
	}
	
	/// Extracts the prefix of [`self.file_name`].
	///
	/// The prefix is:
	///
	/// * [`None`], if there is no file name;
	/// * The entire file name if there is no embedded `.`;
	/// * The portion of the file name before the first non-beginning `.`;
	/// * The entire file name if the file name begins with `.` and has no other `.`s within;
	/// * The portion of the file name before the second `.` if the file name begins with `.`
	///
	/// [`self.file_name`]: Path::file_name
	///
	/// # Examples
	///
	/// ```
	/// # #![feature(path_file_prefix)]
	/// use std::path::Path;
	///
	/// assert_eq!("foo", Path::new("foo.rs").file_prefix().unwrap());
	/// assert_eq!("foo", Path::new("foo.tar.gz").file_prefix().unwrap());
	/// ```
	///
	/// # See Also
	/// This method is similar to [`Path::file_stem`], which extracts the portion of the file name
	/// before the *last* `.`
	///
	/// [`Path::file_stem`]: Path::file_stem
	///
	#[must_use]
	pub fn file_prefix(&self) -> Option<&DaemonicOsStr> {
		self.file_name().map(split_file_at_dot).and_then(|(before, _after)| Some(before))
	}
	
	/// Extracts the extension (without the leading dot) of [`self.file_name`], if possible.
	///
	/// The extension is:
	///
	/// * [`None`], if there is no file name;
	/// * [`None`], if there is no embedded `.`;
	/// * [`None`], if the file name begins with `.` and has no other `.`s within;
	/// * Otherwise, the portion of the file name after the final `.`
	///
	/// [`self.file_name`]: Path::file_name
	///
	/// # Examples
	///
	/// ```
	/// use std::path::Path;
	///
	/// assert_eq!("rs", Path::new("foo.rs").extension().unwrap());
	/// assert_eq!("gz", Path::new("foo.tar.gz").extension().unwrap());
	/// ```
	#[must_use]
	pub fn extension(&self) -> Option<&DaemonicOsStr> {
		self.file_name().map(rsplit_file_at_dot).and_then(|(before, after)| before.and(after))
	}
	
	/// Creates an owned [`PathBuf`] with `path` adjoined to `self`.
	///
	/// If `path` is absolute, it replaces the current path.
	///
	/// See [`PathBuf::push`] for more details on what it means to adjoin a path.
	///
	/// # Examples
	///
	/// ```
	/// use std::path::{Path, PathBuf};
	///
	/// assert_eq!(Path::new("/etc").join("passwd"), PathBuf::from("/etc/passwd"));
	/// assert_eq!(Path::new("/etc").join("/bin/sh"), PathBuf::from("/bin/sh"));
	/// ```
	#[must_use]
	pub fn join<P: AsRef<DaemonicPath>>(&self, path: P) -> DaemonicPathBuf
		where
			DaemonicPathBuf: AsRef<DaemonicPathBuf>, // These 2 are here because this is a less invasive solution than blanket implementing AsRef for DaemonicPath and DaemonicPathBuf upstream.
			DaemonicPath: AsRef<DaemonicPath>,       // Yes, its ugly. No, i dont give a shit.
	{
		self._join(path.as_ref())
	}
	
	fn _join(&self, path: &DaemonicPath) -> DaemonicPathBuf
		where
			DaemonicPathBuf: AsRef<DaemonicPathBuf>, // These 2 are here because this is a less invasive solution than blanket implementing AsRef for DaemonicPath and DaemonicPathBuf upstream.
			DaemonicPath: AsRef<DaemonicPath>,       // Yes, its ugly. No, i dont give a shit.
	{
		let mut buf = self.to_path_buf();
		buf.push(path);
		buf
	}
	
	/// Creates an owned [`PathBuf`] like `self` but with the given file name.
	///
	/// See [`PathBuf::set_file_name`] for more details.
	///
	/// # Examples
	///
	/// ```
	/// use std::path::{Path, PathBuf};
	///
	/// let path = Path::new("/tmp/foo.png");
	/// assert_eq!(path.with_file_name("bar"), PathBuf::from("/tmp/bar"));
	/// assert_eq!(path.with_file_name("bar.txt"), PathBuf::from("/tmp/bar.txt"));
	///
	/// let path = Path::new("/tmp");
	/// assert_eq!(path.with_file_name("var"), PathBuf::from("/var"));
	/// ```
	#[must_use]
	pub fn with_file_name<S: AsRef<DaemonicOsStr>>(&self, file_name: S) -> DaemonicPathBuf
		where
			DaemonicOsStr: AsRef<DaemonicPath>,
	{
		self._with_file_name(file_name.as_ref())
	}
	
	fn _with_file_name(&self, file_name: &DaemonicOsStr) -> DaemonicPathBuf
		where
			DaemonicOsStr: AsRef<daemonic_path::DaemonicPath>,
	{
		let mut buf = self.to_path_buf();
		buf.set_file_name(file_name);
		buf
	}
	
	/// Creates an owned [`PathBuf`] like `self` but with the given extension.
	///
	/// See [`PathBuf::set_extension`] for more details.
	///
	/// # Examples
	///
	/// ```
	/// use std::path::{Path, PathBuf};
	///
	/// let path = Path::new("foo.rs");
	/// assert_eq!(path.with_extension("txt"), PathBuf::from("foo.txt"));
	///
	/// let path = Path::new("foo.tar.gz");
	/// assert_eq!(path.with_extension(""), PathBuf::from("foo.tar"));
	/// assert_eq!(path.with_extension("xz"), PathBuf::from("foo.tar.xz"));
	/// assert_eq!(path.with_extension("").with_extension("txt"), PathBuf::from("foo.txt"));
	/// ```
	pub fn with_extension<S: AsRef<DaemonicOsStr>>(&self, extension: S) -> DaemonicPathBuf {
		self._with_extension(extension.as_ref())
	}
	
	fn _with_extension(&self, extension: &DaemonicOsStr) -> DaemonicPathBuf {
		let self_len = self.as_os_str().len();
		let self_bytes = self.as_os_str().as_encoded_bytes();
		
		let (new_capacity, slice_to_copy) = match self.extension() {
			None => {
				// Enough capacity for the extension and the dot
				let capacity = self_len + extension.len() + 1;
				let whole_path = self_bytes;
				(capacity, whole_path)
			}
			Some(previous_extension) => {
				let capacity = self_len + extension.len() - previous_extension.len();
				let path_till_dot = &self_bytes[..self_len - previous_extension.len()];
				(capacity, path_till_dot)
			}
		};
		
		let mut new_path = DaemonicPathBuf::with_capacity(new_capacity);
		// SAFETY: The path is empty, so cannot have surrogate halves.
		unsafe { new_path.inner.extend_from_slice_unchecked(slice_to_copy) };
		new_path.set_extension(extension);
		new_path
	}
	
	/// Creates an owned [`PathBuf`] like `self` but with the extension added.
	///
	/// See [`PathBuf::add_extension`] for more details.
	///
	/// # Examples
	///
	/// ```
	/// #![feature(path_add_extension)]
	///
	/// use std::path::{Path, PathBuf};
	///
	/// let path = Path::new("foo.rs");
	/// assert_eq!(path.with_added_extension("txt"), PathBuf::from("foo.rs.txt"));
	///
	/// let path = Path::new("foo.tar.gz");
	/// assert_eq!(path.with_added_extension(""), PathBuf::from("foo.tar.gz"));
	/// assert_eq!(path.with_added_extension("xz"), PathBuf::from("foo.tar.gz.xz"));
	/// assert_eq!(path.with_added_extension("").with_added_extension("txt"), PathBuf::from("foo.tar.gz.txt"));
	/// ```
	pub fn with_added_extension<S: AsRef<DaemonicOsStr>>(&self, extension: S) -> DaemonicPathBuf {
		let mut new_path = self.to_path_buf();
		new_path.add_extension(extension);
		new_path
	}
	
	/// Produces an iterator over the [`Component`]s of the path.
	///
	/// When parsing the path, there is a small amount of normalization:
	///
	/// * Repeated separators are ignored, so `a/b` and `a//b` both have
	///   `a` and `b` as components.
	///
	/// * Occurrences of `.` are normalized away, except if they are at the
	///   beginning of the path. For example, `a/./b`, `a/b/`, `a/b/.` and
	///   `a/b` all have `a` and `b` as components, but `./a/b` starts with
	///   an additional [`CurDir`] component.
	///
	/// * A trailing slash is normalized away, `/a/b` and `/a/b/` are equivalent.
	///
	/// Note that no other normalization takes place; in particular, `a/c`
	/// and `a/b/../c` are distinct, to account for the possibility that `b`
	/// is a symbolic link (so its parent isn't `a`).
	///
	/// # Examples
	///
	/// ```
	/// use std::path::{Path, Component};
	/// use std::ffi::OsStr;
	///
	/// let mut components = Path::new("/tmp/foo.txt").components();
	///
	/// assert_eq!(components.next(), Some(Component::RootDir));
	/// assert_eq!(components.next(), Some(Component::Normal(OsStr::new("tmp"))));
	/// assert_eq!(components.next(), Some(Component::Normal(OsStr::new("foo.txt"))));
	/// assert_eq!(components.next(), None)
	/// ```
	///
	/// [`CurDir`]: Component::CurDir
	pub fn components(&self) -> Components<'_> {
		let prefix = parse_prefix(self.as_os_str());
		Components {
			path: self.as_u8_slice(),
			prefix,
			has_physical_root: has_physical_root(self.as_u8_slice(), prefix),
			front: State::Prefix,
			back: State::Body,
		}
	}
	
	/// Produces an iterator over the path's components viewed as [`OsStr`]
	/// slices.
	///
	/// For more information about the particulars of how the path is separated
	/// into components, see [`components`].
	///
	/// [`components`]: Path::components
	///
	/// # Examples
	///
	/// ```
	/// use std::path::{self, Path};
	/// use std::ffi::OsStr;
	///
	/// let mut it = Path::new("/tmp/foo.txt").iter();
	/// assert_eq!(it.next(), Some(OsStr::new(&path::MAIN_SEPARATOR.to_string())));
	/// assert_eq!(it.next(), Some(OsStr::new("tmp")));
	/// assert_eq!(it.next(), Some(OsStr::new("foo.txt")));
	/// assert_eq!(it.next(), None)
	/// ```
	#[inline]
	pub fn iter(&self) -> Iter<'_> {
		Iter { inner: self.components() }
	}
	
	// /// Returns an object that implements [`Display`] for safely printing paths
	// /// that may contain non-Unicode data. This may perform lossy conversion,
	// /// depending on the platform.  If you would like an implementation which
	// /// escapes the path please use [`Debug`] instead.
	// ///
	// /// [`Display`]: fmt::Display
	// /// [`Debug`]: fmt::Debug
	// ///
	// #[must_use = "this does not display the path, \
    //               it returns an object that can be displayed"]
	// #[inline]
	// pub fn display(&self) -> OsStrDisplay<'_> {
	// 	DaemonicOsStrDisplayOuter { inner: self.inner.display() }
	// }
	// todo: unfuck these later
	// /// Queries the file system to get information about a file, directory, etc.
	// ///
	// /// This function will traverse symbolic links to query information about the
	// /// destination file.
	// ///
	// /// This is an alias to [`fs::metadata`].
	// ///
	// /// # Examples
	// ///
	// /// ```no_run
	// /// use std::path::Path;
	// ///
	// /// let path = Path::new("/Minas/tirith");
	// /// let metadata = path.metadata().expect("metadata call failed");
	// /// println!("{:?}", metadata.file_type());
	// /// ```
	// /// This methods internals will change, metadata is a systemcall under the hood with a transparent libc wrapper im pretty sure.
	// /// This also pulls from std, no bueno.
	// #[inline]
	// pub fn metadata(&self) -> io::Result<fs::Metadata> {
	// 	fs::metadata(self)
	// }
	//
	// /// Queries the metadata about a file without following symlinks.
	// ///
	// /// This is an alias to [`fs::symlink_metadata`].
	// ///
	// /// # Examples
	// ///
	// /// ```no_run
	// /// use std::path::Path;
	// ///
	// /// let path = Path::new("/Minas/tirith");
	// /// let metadata = path.symlink_metadata().expect("symlink_metadata call failed");
	// /// println!("{:?}", metadata.file_type());
	// /// ```
	// #[inline]
	// pub fn symlink_metadata(&self) -> io::Result<fs::Metadata> {
	// 	fs::symlink_metadata(self)
	// }
	//
	// /// Returns the canonical, absolute form of the path with all intermediate
	// /// components normalized and symbolic links resolved.
	// ///
	// /// This is an alias to [`fs::canonicalize`].
	// ///
	// /// # Examples
	// ///
	// /// ```no_run
	// /// use std::path::{Path, PathBuf};
	// ///
	// /// let path = Path::new("/foo/test/../test/bar.rs");
	// /// assert_eq!(path.canonicalize().unwrap(), PathBuf::from("/foo/test/bar.rs"));
	// /// ```
	// #[inline]
	// pub fn canonicalize(&self) -> io::Result<DaemonicPathBuf> {
	// 	fs::canonicalize(self)
	// }
	//
	// /// Reads a symbolic link, returning the file that the link points to.
	// ///
	// /// This is an alias to [`fs::read_link`].
	// ///
	// /// # Examples
	// ///
	// /// ```no_run
	// /// use std::path::Path;
	// ///
	// /// let path = Path::new("/laputa/sky_castle.rs");
	// /// let path_link = path.read_link().expect("read_link call failed");
	// /// ```
	// #[inline]
	// pub fn read_link(&self) -> io::Result<DaemonicPathBuf> {
	// 	fs::read_link(self)
	// }
	//
	// /// Returns an iterator over the entries within a directory.
	// ///
	// /// The iterator will yield instances of <code>[io::Result]<[fs::DirEntry]></code>. New
	// /// errors may be encountered after an iterator is initially constructed.
	// ///
	// /// This is an alias to [`fs::read_dir`].
	// ///
	// /// # Examples
	// ///
	// /// ```no_run
	// /// use std::path::Path;
	// ///
	// /// let path = Path::new("/laputa");
	// /// for entry in path.read_dir().expect("read_dir call failed") {
	// ///     if let Ok(entry) = entry {
	// ///         println!("{:?}", entry.path());
	// ///     }
	// /// }
	// /// ```
	// #[inline]
	// pub fn read_dir(&self) -> io::Result<fs::ReadDir> {
	// 	fs::read_dir(self)
	// }
	//
	// /// Returns `true` if the path points at an existing entity.
	// ///
	// /// Warning: this method may be error-prone, consider using [`try_exists()`] instead!
	// /// It also has a risk of introducing time-of-check to time-of-use (TOCTOU) bugs.
	// ///
	// /// This function will traverse symbolic links to query information about the
	// /// destination file.
	// ///
	// /// If you cannot access the metadata of the file, e.g. because of a
	// /// permission error or broken symbolic links, this will return `false`.
	// ///
	// /// # Examples
	// ///
	// /// ```no_run
	// /// use std::path::Path;
	// /// assert!(!Path::new("does_not_exist.txt").exists());
	// /// ```
	// ///
	// /// # See Also
	// ///
	// /// This is a convenience function that coerces errors to false. If you want to
	// /// check errors, call [`Path::try_exists`].
	// ///
	// /// [`try_exists()`]: Self::try_exists
	// #[must_use]
	// #[inline]
	// pub fn exists(&self) -> bool {
	// 	fs::metadata(self).is_ok()
	// }
	//
	// /// Returns `Ok(true)` if the path points at an existing entity.
	// ///
	// /// This function will traverse symbolic links to query information about the
	// /// destination file. In case of broken symbolic links this will return `Ok(false)`.
	// ///
	// /// [`Path::exists()`] only checks whether or not a path was both found and readable. By
	// /// contrast, `try_exists` will return `Ok(true)` or `Ok(false)`, respectively, if the path
	// /// was _verified_ to exist or not exist. If its existence can neither be confirmed nor
	// /// denied, it will propagate an `Err(_)` instead. This can be the case if e.g. listing
	// /// permission is denied on one of the parent directories.
	// ///
	// /// Note that while this avoids some pitfalls of the `exists()` method, it still can not
	// /// prevent time-of-check to time-of-use (TOCTOU) bugs. You should only use it in scenarios
	// /// where those bugs are not an issue.
	// ///
	// /// This is an alias for [`std::fs::exists`](crate::fs::exists).
	// ///
	// /// # Examples
	// ///
	// /// ```no_run
	// /// use std::path::Path;
	// /// assert!(!Path::new("does_not_exist.txt").try_exists().expect("Can't check existence of file does_not_exist.txt"));
	// /// assert!(Path::new("/root/secret_file.txt").try_exists().is_err());
	// /// ```
	// ///
	// /// [`exists()`]: Self::exists
	// #[inline]
	// pub fn try_exists(&self) -> io::Result<bool> {
	// 	fs::exists(self)
	// }
	//
	// /// Returns `true` if the path exists on disk and is pointing at a regular file.
	// ///
	// /// This function will traverse symbolic links to query information about the
	// /// destination file.
	// ///
	// /// If you cannot access the metadata of the file, e.g. because of a
	// /// permission error or broken symbolic links, this will return `false`.
	// ///
	// /// # Examples
	// ///
	// /// ```no_run
	// /// use std::path::Path;
	// /// assert_eq!(Path::new("./is_a_directory/").is_file(), false);
	// /// assert_eq!(Path::new("a_file.txt").is_file(), true);
	// /// ```
	// ///
	// /// # See Also
	// ///
	// /// This is a convenience function that coerces errors to false. If you want to
	// /// check errors, call [`fs::metadata`] and handle its [`Result`]. Then call
	// /// [`fs::Metadata::is_file`] if it was [`Ok`].
	// ///
	// /// When the goal is simply to read from (or write to) the source, the most
	// /// reliable way to test the source can be read (or written to) is to open
	// /// it. Only using `is_file` can break workflows like `diff <( prog_a )` on
	// /// a Unix-like system for example. See [`fs::File::open`] or
	// /// [`fs::OpenOptions::open`] for more information.
	// #[must_use]
	// pub fn is_file(&self) -> bool {
	// 	fs::metadata(self).map(|m| m.is_file()).unwrap_or(false)
	// }
	//
	// /// Returns `true` if the path exists on disk and is pointing at a directory.
	// ///
	// /// This function will traverse symbolic links to query information about the
	// /// destination file.
	// ///
	// /// If you cannot access the metadata of the file, e.g. because of a
	// /// permission error or broken symbolic links, this will return `false`.
	// ///
	// /// # Examples
	// ///
	// /// ```no_run
	// /// use std::path::Path;
	// /// assert_eq!(Path::new("./is_a_directory/").is_dir(), true);
	// /// assert_eq!(Path::new("a_file.txt").is_dir(), false);
	// /// ```
	// ///
	// /// # See Also
	// ///
	// /// This is a convenience function that coerces errors to false. If you want to
	// /// check errors, call [`fs::metadata`] and handle its [`Result`]. Then call
	// /// [`fs::Metadata::is_dir`] if it was [`Ok`].
	// #[must_use]
	// pub fn is_dir(&self) -> bool {
	// 	fs::metadata(self).map(|m| m.is_dir()).unwrap_or(false)
	// }
	//
	// /// Returns `true` if the path exists on disk and is pointing at a symbolic link.
	// ///
	// /// This function will not traverse symbolic links.
	// /// In case of a broken symbolic link this will also return true.
	// ///
	// /// If you cannot access the directory containing the file, e.g., because of a
	// /// permission error, this will return false.
	// ///
	// /// # Examples
	// ///
	// #[cfg_attr(unix, doc = "```no_run")]
	// /// use std::path::Path;
	// /// use std::os::unix::fs::symlink;
	// ///
	// /// let link_path = Path::new("link");
	// /// symlink("/origin_does_not_exist/", link_path).unwrap();
	// /// assert_eq!(link_path.is_symlink(), true);
	// /// assert_eq!(link_path.exists(), false);
	// /// ```
	// ///
	// /// # See Also
	// ///
	// /// This is a convenience function that coerces errors to false. If you want to
	// /// check errors, call [`fs::symlink_metadata`] and handle its [`Result`]. Then call
	// /// [`fs::Metadata::is_symlink`] if it was [`Ok`].
	// #[must_use]
	// pub fn is_symlink(&self) -> bool {
	// 	fs::symlink_metadata(self).map(|m| m.is_symlink()).unwrap_or(false)
	// }
	
	/// Converts a [`Box<Path>`](Box) into a [`PathBuf`] without copying or
	/// allocating.
	#[must_use = "`self` will be dropped if the result is not used"]
	pub fn into_path_buf(self: Box<DaemonicPath>) -> DaemonicPathBuf {
		let rw = Box::into_raw(self) as *mut DaemonicOsStr;
		let inner = unsafe { Box::from_raw(rw) };
		DaemonicPathBuf { inner: DaemonicOsString::from(inner) }
	}
}

unsafe impl CloneToUninit for DaemonicPath {
	#[inline]
	#[cfg_attr(debug_assertions, track_caller)]
	unsafe fn clone_to_uninit(&self, dst: *mut u8) {
		// SAFETY: Path is just a transparent wrapper around OsStr
		unsafe { self.inner.clone_to_uninit(dst) }
	}
}

impl AsRef<DaemonicOsStr> for DaemonicPath {
	#[inline]
	fn as_ref(&self) -> &DaemonicOsStr {
		&self.inner
	}
}

impl fmt::Debug for DaemonicPath {
	fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
		fmt::Debug::fmt(&self.inner, formatter)
	}
}