1248a639ee
There are cases where we want an enum variant name. Right now the only way to do that with rust's std is to derive Debug, but this will also print out the variant's fields. This creates the unfortunate situation where we need to manually write out each variant's string name (ex: in #1963), which is both boilerplate-ey and error-prone. Crates such as `strum` exist for this reason, but it includes a lot of code and complexity that we don't need. This adds a dead-simple `EnumVariantMeta` derive that exposes `enum_variant_index` and `enum_variant_name` functions. This allows us to make cases like #1963 much cleaner (see the second commit). We might also be able to reuse this logic for `bevy_reflect` enum derives.
63 lines
2.2 KiB
Rust
63 lines
2.2 KiB
Rust
mod enum_variant_meta;
|
|
pub use enum_variant_meta::*;
|
|
|
|
pub use ahash::AHasher;
|
|
pub use instant::{Duration, Instant};
|
|
pub use tracing;
|
|
pub use uuid::Uuid;
|
|
|
|
use ahash::RandomState;
|
|
use std::{future::Future, pin::Pin};
|
|
|
|
#[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 hasher builder that will create a fixed hasher.
|
|
#[derive(Default)]
|
|
pub struct FixedState;
|
|
|
|
impl std::hash::BuildHasher for FixedState {
|
|
type Hasher = AHasher;
|
|
|
|
#[inline]
|
|
fn build_hasher(&self) -> AHasher {
|
|
AHasher::new_with_keys(
|
|
0b1001010111101110000001001100010000000011001001101011001001111000,
|
|
0b1100111101101011011110001011010100000100001111100011010011010101,
|
|
)
|
|
}
|
|
}
|
|
|
|
/// 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>;
|
|
|
|
/// A stable std hash map implementing AHash, a high speed keyed hashing algorithm
|
|
/// intended for use in in-memory hashmaps.
|
|
///
|
|
/// Unlike [`HashMap`] this has an iteration order that only depends on the order
|
|
/// of insertions and deletions and not a random source.
|
|
///
|
|
/// AHash is designed for performance and is NOT cryptographically secure.
|
|
pub type StableHashMap<K, V> = std::collections::HashMap<K, V, FixedState>;
|
|
|
|
/// 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>;
|
|
|
|
/// A stable std hash set implementing AHash, a high speed keyed hashing algorithm
|
|
/// intended for use in in-memory hashmaps.
|
|
///
|
|
/// Unlike [`HashSet`] this has an iteration order that only depends on the order
|
|
/// of insertions and deletions and not a random source.
|
|
///
|
|
/// AHash is designed for performance and is NOT cryptographically secure.
|
|
pub type StableHashSet<K> = std::collections::HashSet<K, FixedState>;
|