btree_slab/generic/node/
item.rs

1use super::Keyed;
2use std::{cmp::Ordering, mem::MaybeUninit};
3
4pub struct Item<K, V> {
5	/// # Safety
6	///
7	/// This field must always be initialized when the item is accessed and/or dropped.
8	key: MaybeUninit<K>,
9
10	/// # Safety
11	///
12	/// This field must always be initialized when the item is accessed and/or dropped.
13	value: MaybeUninit<V>,
14}
15
16impl<K: Clone, V: Clone> Clone for Item<K, V> {
17	fn clone(&self) -> Self {
18		unsafe {
19			Self::new(
20				self.key.assume_init_ref().clone(),
21				self.value.assume_init_ref().clone(),
22			)
23		}
24	}
25}
26
27impl<K, V> AsRef<Item<K, V>> for Item<K, V> {
28	fn as_ref(&self) -> &Self {
29		self
30	}
31}
32
33impl<K, V> Item<K, V> {
34	pub fn new(key: K, value: V) -> Item<K, V> {
35		Item {
36			key: MaybeUninit::new(key),
37			value: MaybeUninit::new(value),
38		}
39	}
40
41	#[inline]
42	pub fn key(&self) -> &K {
43		unsafe { self.key.assume_init_ref() }
44	}
45
46	/// Modifying a key in such a way that its order with regard to other keys changes is a logical error.
47	#[inline]
48	pub fn key_mut(&mut self) -> &mut K {
49		unsafe { self.key.assume_init_mut() }
50	}
51
52	#[inline]
53	pub fn value(&self) -> &V {
54		unsafe { self.value.assume_init_ref() }
55	}
56
57	#[inline]
58	pub fn value_mut(&mut self) -> &mut V {
59		unsafe { self.value.assume_init_mut() }
60	}
61
62	/// Modifying a key in such a way that its order with regard to other keys changes is a logical error.
63	#[inline]
64	pub fn set(&mut self, key: K, value: V) -> (K, V) {
65		let mut old_key = MaybeUninit::new(key);
66		let mut old_value = MaybeUninit::new(value);
67		std::mem::swap(&mut old_key, &mut self.key);
68		std::mem::swap(&mut old_value, &mut self.value);
69		unsafe { (old_key.assume_init(), old_value.assume_init()) }
70	}
71
72	/// Modifying a key in such a way that its order with regard to other keys changes is a logical error.
73	#[inline]
74	pub fn set_key(&mut self, key: K) -> K {
75		let mut old_key = MaybeUninit::new(key);
76		std::mem::swap(&mut old_key, &mut self.key);
77		unsafe { old_key.assume_init() }
78	}
79
80	#[inline]
81	pub fn set_value(&mut self, value: V) -> V {
82		let mut old_value = MaybeUninit::new(value);
83		std::mem::swap(&mut old_value, &mut self.value);
84		unsafe { old_value.assume_init() }
85	}
86
87	#[inline]
88	pub fn maybe_uninit_value_mut(&mut self) -> &mut MaybeUninit<V> {
89		&mut self.value
90	}
91
92	#[inline]
93	pub fn into_key(self) -> K {
94		let (key, value) = self.into_inner();
95		unsafe {
96			std::mem::drop(value.assume_init());
97			key.assume_init()
98		}
99	}
100
101	#[inline]
102	pub fn into_value(self) -> V {
103		let (key, value) = self.into_inner();
104		unsafe {
105			std::mem::drop(key.assume_init());
106			value.assume_init()
107		}
108	}
109
110	#[inline]
111	pub fn as_pair(&self) -> (&K, &V) {
112		unsafe { (self.key.assume_init_ref(), self.value.assume_init_ref()) }
113	}
114
115	#[inline]
116	pub fn as_pair_mut(&mut self) -> (&mut K, &mut V) {
117		unsafe { (self.key.assume_init_mut(), self.value.assume_init_mut()) }
118	}
119
120	#[inline]
121	pub fn into_pair(self) -> (K, V) {
122		let (key, value) = self.into_inner();
123		unsafe { (key.assume_init(), value.assume_init()) }
124	}
125
126	/// Drop the key but not the value which is assumed uninitialized.
127	///
128	/// # Safety
129	///
130	/// The value must be uninitialized.
131	#[inline]
132	pub unsafe fn forget_value(self) {
133		let (key, _) = self.into_inner();
134		std::mem::drop(key.assume_init())
135	}
136
137	#[inline]
138	pub fn into_inner(mut self) -> (MaybeUninit<K>, MaybeUninit<V>) {
139		let mut key = MaybeUninit::uninit();
140		let mut value = MaybeUninit::uninit();
141		std::mem::swap(&mut key, &mut self.key);
142		std::mem::swap(&mut value, &mut self.value);
143		std::mem::forget(self);
144		(key, value)
145	}
146}
147
148impl<K, V> Drop for Item<K, V> {
149	fn drop(&mut self) {
150		unsafe {
151			std::ptr::drop_in_place(self.key.assume_init_mut());
152			std::ptr::drop_in_place(self.value.assume_init_mut());
153		}
154	}
155}
156
157impl<K, V> Keyed for Item<K, V> {
158	type Key = K;
159
160	#[inline]
161	fn key(&self) -> &K {
162		self.key()
163	}
164}
165
166// impl<K, V, T: PartialEq<K>> PartialEq<T> for Item<K, V> {
167// 	fn eq(&self, other: &T) -> bool {
168// 		other.eq(self.key())
169// 	}
170// }
171
172// impl<K, V, T: PartialOrd<K>> PartialOrd<T> for Item<K, V> {
173// 	fn partial_cmp(&self, other: &T) -> Option<Ordering> {
174// 		match other.partial_cmp(self.key()) {
175// 			Some(Ordering::Greater) => Some(Ordering::Less),
176// 			Some(Ordering::Less) => Some(Ordering::Greater),
177// 			Some(Ordering::Equal) => Some(Ordering::Equal),
178// 			None => None
179// 		}
180// 	}
181// }
182
183impl<K: PartialEq, V> PartialEq for Item<K, V> {
184	fn eq(&self, other: &Item<K, V>) -> bool {
185		self.key().eq(other.key())
186	}
187}
188
189impl<K: Ord + PartialEq, V> PartialOrd for Item<K, V> {
190	fn partial_cmp(&self, other: &Item<K, V>) -> Option<Ordering> {
191		Some(self.key().cmp(other.key()))
192	}
193}
btree_slab/generic/node/item.rs

btree_slab/generic/node/
item.rs
