pub trait TypePath: 'static {
// Required methods
fn type_path() -> &'static str;
fn short_type_path() -> &'static str;
// Provided methods
fn type_ident() -> Option<&'static str> { ... }
fn crate_name() -> Option<&'static str> { ... }
fn module_path() -> Option<&'static str> { ... }
}
Expand description
A static accessor to type paths and names.
The engine uses this trait over std::any::type_name
for stability and flexibility.
This trait is automatically implemented by the #[derive(Reflect)]
macro
and allows type path information to be processed without an instance of that type.
Implementors may have difficulty in generating references with static lifetimes. Luckily, this crate comes with some utility structs, to make generating these statics much simpler.
§Stability
Certain parts of the engine, e.g. (de)serialization, rely on type paths as identifiers for matching dynamic values to concrete types.
Using std::any::type_name
, a scene containing my_crate::foo::MyComponent
would break,
failing to deserialize if the component was moved from the foo
module to the bar
module,
becoming my_crate::bar::MyComponent
.
This trait, through attributes when deriving itself or Reflect
, can ensure breaking changes are avoidable.
The only external factor we rely on for stability when deriving is the module_path!
macro,
only if the derive does not provide a #[type_path = "..."]
attribute.
§Anonymity
Some methods on this trait return Option<&'static str>
over &'static str
because not all types define all parts of a type path, for example the array type [T; N]
.
Such types are ‘anonymous’ in that they have only a defined type_path
and short_type_path
and the methods crate_name
, module_path
and type_ident
all return None
.
Primitives are treated like anonymous types, except they also have a defined type_ident
.
§Example
use bevy_reflect::TypePath;
// This type path will not change with compiler versions or recompiles,
// although it will not be the same if the definition is moved.
#[derive(TypePath)]
struct NonStableTypePath;
// This type path will never change, even if the definition is moved.
#[derive(TypePath)]
#[type_path = "my_crate::foo"]
struct StableTypePath;
// Type paths can have any number of path segments.
#[derive(TypePath)]
#[type_path = "my_crate::foo::bar::baz"]
struct DeeplyNestedStableTypePath;
// Including just a crate name!
#[derive(TypePath)]
#[type_path = "my_crate"]
struct ShallowStableTypePath;
// We can also rename the identifier/name of types.
#[derive(TypePath)]
#[type_path = "my_crate::foo"]
#[type_name = "RenamedStableTypePath"]
struct NamedStableTypePath;
// Generics are also supported.
#[derive(TypePath)]
#[type_path = "my_crate::foo"]
struct StableGenericTypePath<T, const N: usize>([T; N]);
Required Methods§
Sourcefn type_path() -> &'static str
fn type_path() -> &'static str
Returns the fully qualified path of the underlying type.
Generic parameter types are also fully expanded.
For Option<Vec<usize>>
, this is "std::option::Option<std::vec::Vec<usize>>"
.
Sourcefn short_type_path() -> &'static str
fn short_type_path() -> &'static str
Returns a short, pretty-print enabled path to the type.
Generic parameter types are also shortened.
For Option<Vec<usize>>
, this is "Option<Vec<usize>>"
.
Provided Methods§
Sourcefn type_ident() -> Option<&'static str>
fn type_ident() -> Option<&'static str>
Sourcefn crate_name() -> Option<&'static str>
fn crate_name() -> Option<&'static str>
Dyn Compatibility§
This trait is not dyn compatible.
In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.
Implementations on Foreign Types§
Source§impl TypePath for FixedState
impl TypePath for FixedState
Source§impl TypePath for AtomicBool
impl TypePath for AtomicBool
Source§impl TypePath for AtomicIsize
impl TypePath for AtomicIsize
Source§impl TypePath for AtomicUsize
impl TypePath for AtomicUsize
Source§impl TypePath for RandomState
impl TypePath for RandomState
Source§impl TypePath for DefaultHashBuilder
impl TypePath for DefaultHashBuilder
Source§impl TypePath for NonZeroI16
impl TypePath for NonZeroI16
Source§impl TypePath for NonZeroI32
impl TypePath for NonZeroI32
Source§impl TypePath for NonZeroI64
impl TypePath for NonZeroI64
Source§impl TypePath for NonZeroI128
impl TypePath for NonZeroI128
Source§impl TypePath for NonZeroIsize
impl TypePath for NonZeroIsize
Source§impl TypePath for NonZeroU16
impl TypePath for NonZeroU16
Source§impl TypePath for NonZeroU32
impl TypePath for NonZeroU32
Source§impl TypePath for NonZeroU64
impl TypePath for NonZeroU64
Source§impl TypePath for NonZeroU128
impl TypePath for NonZeroU128
Source§impl TypePath for NonZeroUsize
impl TypePath for NonZeroUsize
Source§impl<P: TypePath> TypePath for (P₁, P₂, …, Pₙ)
impl<P: TypePath> TypePath for (P₁, P₂, …, Pₙ)
This trait is implemented for tuples up to 13 items long.