diff options
Diffstat (limited to 'vendor/sharded-slab/src/clear.rs')
-rw-r--r-- | vendor/sharded-slab/src/clear.rs | 100 |
1 files changed, 100 insertions, 0 deletions
diff --git a/vendor/sharded-slab/src/clear.rs b/vendor/sharded-slab/src/clear.rs new file mode 100644 index 000000000..1eb88b460 --- /dev/null +++ b/vendor/sharded-slab/src/clear.rs @@ -0,0 +1,100 @@ +use std::{collections, hash, ops::DerefMut, sync}; + +/// Trait implemented by types which can be cleared in place, retaining any +/// allocated memory. +/// +/// This is essentially a generalization of methods on standard library +/// collection types, including as [`Vec::clear`], [`String::clear`], and +/// [`HashMap::clear`]. These methods drop all data stored in the collection, +/// but retain the collection's heap allocation for future use. Types such as +/// `BTreeMap`, whose `clear` methods drops allocations, should not +/// implement this trait. +/// +/// When implemented for types which do not own a heap allocation, `Clear` +/// should reset the type in place if possible. If the type has an empty state +/// or stores `Option`s, those values should be reset to the empty state. For +/// "plain old data" types, which hold no pointers to other data and do not have +/// an empty or initial state, it's okay for a `Clear` implementation to be a +/// no-op. In that case, it essentially serves as a marker indicating that the +/// type may be reused to store new data. +/// +/// [`Vec::clear`]: https://doc.rust-lang.org/stable/std/vec/struct.Vec.html#method.clear +/// [`String::clear`]: https://doc.rust-lang.org/stable/std/string/struct.String.html#method.clear +/// [`HashMap::clear`]: https://doc.rust-lang.org/stable/std/collections/struct.HashMap.html#method.clear +pub trait Clear { + /// Clear all data in `self`, retaining the allocated capacithy. + fn clear(&mut self); +} + +impl<T> Clear for Option<T> { + fn clear(&mut self) { + let _ = self.take(); + } +} + +impl<T> Clear for Box<T> +where + T: Clear, +{ + #[inline] + fn clear(&mut self) { + self.deref_mut().clear() + } +} + +impl<T> Clear for Vec<T> { + #[inline] + fn clear(&mut self) { + Vec::clear(self) + } +} + +impl<K, V, S> Clear for collections::HashMap<K, V, S> +where + K: hash::Hash + Eq, + S: hash::BuildHasher, +{ + #[inline] + fn clear(&mut self) { + collections::HashMap::clear(self) + } +} + +impl<T, S> Clear for collections::HashSet<T, S> +where + T: hash::Hash + Eq, + S: hash::BuildHasher, +{ + #[inline] + fn clear(&mut self) { + collections::HashSet::clear(self) + } +} + +impl Clear for String { + #[inline] + fn clear(&mut self) { + String::clear(self) + } +} + +impl<T: Clear> Clear for sync::Mutex<T> { + #[inline] + fn clear(&mut self) { + self.get_mut().unwrap().clear(); + } +} + +impl<T: Clear> Clear for sync::RwLock<T> { + #[inline] + fn clear(&mut self) { + self.write().unwrap().clear(); + } +} + +#[cfg(all(loom, test))] +impl<T: Clear> Clear for crate::sync::alloc::Track<T> { + fn clear(&mut self) { + self.get_mut().clear() + } +} |