yazi-shared 26.5.6

Yazi shared library
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

use std::ops::Deref;

use crate::pool::{Pool, Symbol};

pub enum SymbolCow<'a, T: ?Sized> {
	Borrowed(&'a T),
	Owned(Symbol<T>),
}

impl<T: ?Sized> Clone for SymbolCow<'_, T> {
	fn clone(&self) -> Self {
		match self {
			Self::Borrowed(t) => Self::Borrowed(t),
			Self::Owned(t) => Self::Owned(t.clone()),
		}
	}
}

impl AsRef<[u8]> for SymbolCow<'_, [u8]> {
	fn as_ref(&self) -> &[u8] {
		match self {
			Self::Borrowed(b) => b,
			Self::Owned(b) => b.as_ref(),
		}
	}
}

impl AsRef<str> for SymbolCow<'_, str> {
	fn as_ref(&self) -> &str {
		match self {
			Self::Borrowed(s) => s,
			Self::Owned(s) => s.as_ref(),
		}
	}
}

// --- Deref
impl Deref for SymbolCow<'_, [u8]> {
	type Target = [u8];

	fn deref(&self) -> &Self::Target { self.as_ref() }
}

impl Deref for SymbolCow<'_, str> {
	type Target = str;

	fn deref(&self) -> &Self::Target { self.as_ref() }
}

// --- From
impl<'a, T: ?Sized> From<&'a T> for SymbolCow<'a, T> {
	fn from(value: &'a T) -> Self { Self::Borrowed(value) }
}

impl<T: ?Sized> From<Symbol<T>> for SymbolCow<'_, T> {
	fn from(value: Symbol<T>) -> Self { Self::Owned(value) }
}

impl From<SymbolCow<'_, [u8]>> for Symbol<[u8]> {
	fn from(value: SymbolCow<'_, [u8]>) -> Self { value.into_owned() }
}

impl From<SymbolCow<'_, str>> for Symbol<str> {
	fn from(value: SymbolCow<'_, str>) -> Self { value.into_owned() }
}

// --- Debug
impl std::fmt::Debug for SymbolCow<'_, [u8]> {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		write!(f, "SymbolCow<[u8]>({:?})", self.as_ref())
	}
}

impl std::fmt::Debug for SymbolCow<'_, str> {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		write!(f, "SymbolCow<str>({:?})", self.as_ref())
	}
}

impl SymbolCow<'_, [u8]> {
	pub fn into_owned(self) -> Symbol<[u8]> {
		match self {
			Self::Borrowed(t) => Pool::<[u8]>::intern(t),
			Self::Owned(t) => t,
		}
	}
}

impl SymbolCow<'_, str> {
	pub fn into_owned(self) -> Symbol<str> {
		match self {
			Self::Borrowed(t) => Pool::<str>::intern(t),
			Self::Owned(t) => t,
		}
	}
}