Crate bevy_utils

General utilities for first-party Bevy engine crates.

Re-exports

• pub use hashbrown;
• pub use tracing;

Modules

• futures
  Utilities for working with Futures.
• prelude
  The utilities prelude.
• synccell
  A reimplementation of the currently unstable std::sync::Exclusive
• syncunsafecell
  A reimplementation of the currently unstable std::cell::SyncUnsafeCell

Macros

• all_tuples
  Helper macro to generate tuple pyramids. Useful to generate scaffolding to work around Rust lacking variadics. Invoking all_tuples!(impl_foo, start, end, P, Q, ..) invokes impl_foo providing ident tuples through arity start..=end. If you require the length of the tuple, see all_tuples_with_size!.
• all_tuples_with_size
  Helper macro to generate tuple pyramids with their length. Useful to generate scaffolding to work around Rust lacking variadics. Invoking all_tuples_with_size!(impl_foo, start, end, P, Q, ..) invokes impl_foo providing ident tuples through arity start..=end preceded by their length. If you don’t require the length of the tuple, see all_tuples!.
• debug_once
  Call debug! once per call site.
• detailed_trace
  Like tracing::trace, but conditional on cargo feature detailed_trace.
• error_once
  Call error! once per call site.
• info_once
  Call info! once per call site.
• once
  Call some expression only once per call site.
• trace_once
  Call trace! once per call site.
• warn_once
  Call warn! once per call site.

Structs

• AHasher
  A Hasher for hashing an arbitrary stream of bytes.
• DurationNon-WebAssembly and std
  A Duration type to represent a span of time, typically used for system timeouts.
• FixedState
  A hasher builder that will create a fixed hasher.
• Hashed
  A pre-hashed value of a specific type. Pre-hashing enables memoization of hashes that are expensive to compute.
• InstantNon-WebAssembly and std
  A measurement of a monotonically nondecreasing clock. Opaque and useful only with Duration.
• NoOpHash
  BuildHasher for types that already contain a high-quality hash.
• OnDrop
  A type which calls a function when dropped. This can be used to ensure that cleanup code is run even in case of a panic.
• Parallelstd
  A cohesive set of thread-local values of a given type.
• PassHash
  A BuildHasher that results in a PassHasher.
• PassHasher
  A no-op hash that only works on u64s. Will panic if attempting to hash a type containing non-u64 fields.
• RandomState
  Provides a Hasher factory. This is typically used (e.g. by HashMap) to create AHashers in order to hash the keys of the map. See build_hasher below.
• SystemTimeNon-WebAssembly and std
  A measurement of the system clock, useful for talking to external entities like the file system or other processes.
• SystemTimeErrorNon-WebAssembly and std
  An error returned from the duration_since and elapsed methods on SystemTime, used to learn how far in the opposite direction a system time lies.
• TryFromFloatSecsErrorNon-WebAssembly and std
  An error which can be returned when converting a floating-point value of seconds into a Duration.

Traits

• ConditionalSendNon-WebAssembly
  Use ConditionalSend to mark an optional Send trait bound. Useful as on certain platforms (eg. Wasm), futures aren’t Send.
• ConditionalSendFuture
  Use ConditionalSendFuture for a future with an optional Send trait bound, as on certain platforms (eg. Wasm), futures aren’t Send.
• PreHashMapExt
  Extension methods intended to add functionality to PreHashMap.

Functions

• assert_object_safe
  Assert that a given T is object safe. Will fail to compile if that is not the case.
• dbg
  Calls the tracing::debug! macro on a value.
• default
  An ergonomic abbreviation for Default::default() to make initializing structs easier.
• error
  Processes a Result by calling the tracing::error! macro in case of an Err value.
• info
  Calls the tracing::info! macro on a value.
• warn
  Processes a Result by calling the tracing::warn! macro in case of an Err value.

Type Aliases

• BoxedFuturealloc
  An owned and dynamically typed Future used when you can’t statically type your result or need to add some indirection.
• Entry
  A shortcut alias for hashbrown::hash_map::Entry.
• HashMap
  A HashMap implementing aHash, a high speed keyed hashing algorithm intended for use in in-memory hashmaps.
• HashSet
  A HashSet implementing aHash, a high speed keyed hashing algorithm intended for use in in-memory hashmaps.
• PreHashMap
  A HashMap pre-configured to use Hashed keys and PassHash passthrough hashing. Iteration order only depends on the order of insertions and deletions.
• StableHashMapDeprecated
  A stable hash map implementing aHash, a high speed keyed hashing algorithm intended for use in in-memory hashmaps.
• StableHashSetDeprecated
  A stable hash set implementing aHash, a high speed keyed hashing algorithm intended for use in in-memory hashmaps.
• TypeIdMap
  A specialized hashmap type with Key of TypeId Iteration order only depends on the order of insertions and deletions.