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 97 98 99
pub use ahash::AHasher; use ahash::RandomState; pub use instant::{Duration, Instant}; use std::{future::Future, pin::Pin}; pub use tracing; pub use uuid::Uuid; #[cfg(not(target_arch = "wasm32"))] pub type BoxedFuture<'a, T> = Pin<Box<dyn Future<Output = T> + Send + 'a>>; #[cfg(target_arch = "wasm32")] pub type BoxedFuture<'a, T> = Pin<Box<dyn Future<Output = T> + 'a>>; /// A std hash map implementing AHash, a high speed keyed hashing algorithm /// intended for use in in-memory hashmaps. /// /// AHash is designed for performance and is NOT cryptographically secure. pub type HashMap<K, V> = std::collections::HashMap<K, V, RandomState>; pub trait AHashExt { fn new() -> Self; fn with_capacity(capacity: usize) -> Self; } impl<K, V> AHashExt for HashMap<K, V> { /// Creates an empty `HashMap` with AHash. /// /// The hash map is initially created with a capacity of 0, so it will not /// allocate until it is first inserted into. /// /// # Examples /// /// ``` /// use bevy_utils::{HashMap, AHashExt}; /// let mut map: HashMap<&str, i32> = HashMap::new(); /// ``` #[inline] fn new() -> Self { Default::default() } /// Creates an empty `HashMap` with the specified capacity with AHash. /// /// The hash map will be able to hold at least `capacity` elements without /// reallocating. If `capacity` is 0, the hash map will not allocate. /// /// # Examples /// /// ``` /// use bevy_utils::{HashMap, AHashExt}; /// let mut map: HashMap<&str, i32> = HashMap::with_capacity(10); /// ``` #[inline] fn with_capacity(capacity: usize) -> Self { HashMap::with_capacity_and_hasher(capacity, RandomState::default()) } } /// A std hash set implementing AHash, a high speed keyed hashing algorithm /// intended for use in in-memory hashmaps. /// /// AHash is designed for performance and is NOT cryptographically secure. pub type HashSet<K> = std::collections::HashSet<K, RandomState>; impl<K> AHashExt for HashSet<K> { /// Creates an empty `HashSet` with AHash. /// /// The hash set is initially created with a capacity of 0, so it will not /// allocate until it is first inserted into. /// /// # Examples /// /// ``` /// use bevy_utils::{HashSet, AHashExt}; /// let set: HashSet<i32> = HashSet::new(); /// ``` #[inline] fn new() -> Self { Default::default() } /// Creates an empty `HashSet` with the specified capacity with AHash. /// /// The hash set will be able to hold at least `capacity` elements without /// reallocating. If `capacity` is 0, the hash set will not allocate. /// /// # Examples /// /// ``` /// use bevy_utils::{HashSet, AHashExt}; /// let set: HashSet<i32> = HashSet::with_capacity(10); /// assert!(set.capacity() >= 10); /// ``` #[inline] fn with_capacity(capacity: usize) -> Self { HashSet::with_capacity_and_hasher(capacity, RandomState::default()) } }