56e9a3de88
# Objective I noticed while working on #5366 that the documentation for label types wasn't working correctly. Having experimented with this for a few weeks, I believe that generating docs in macros is more effort than it's worth. ## Solution Add more boilerplate, copy-paste and edit the docs across types. This also lets us add custom doctests for specific types. Also, we don't need `concat_idents` as a dependency anymore.
120 lines
2.8 KiB
Rust
120 lines
2.8 KiB
Rust
//! Traits used by label implementations
|
|
|
|
use std::{
|
|
any::Any,
|
|
hash::{Hash, Hasher},
|
|
};
|
|
|
|
pub trait DynEq: Any {
|
|
fn as_any(&self) -> &dyn Any;
|
|
|
|
fn dyn_eq(&self, other: &dyn DynEq) -> bool;
|
|
}
|
|
|
|
impl<T> DynEq for T
|
|
where
|
|
T: Any + Eq,
|
|
{
|
|
fn as_any(&self) -> &dyn Any {
|
|
self
|
|
}
|
|
|
|
fn dyn_eq(&self, other: &dyn DynEq) -> bool {
|
|
if let Some(other) = other.as_any().downcast_ref::<T>() {
|
|
return self == other;
|
|
}
|
|
false
|
|
}
|
|
}
|
|
|
|
pub trait DynHash: DynEq {
|
|
fn as_dyn_eq(&self) -> &dyn DynEq;
|
|
|
|
fn dyn_hash(&self, state: &mut dyn Hasher);
|
|
}
|
|
|
|
impl<T> DynHash for T
|
|
where
|
|
T: DynEq + Hash,
|
|
{
|
|
fn as_dyn_eq(&self) -> &dyn DynEq {
|
|
self
|
|
}
|
|
|
|
fn dyn_hash(&self, mut state: &mut dyn Hasher) {
|
|
T::hash(self, &mut state);
|
|
self.type_id().hash(&mut state);
|
|
}
|
|
}
|
|
|
|
/// Macro to define a new label trait
|
|
///
|
|
/// # Example
|
|
///
|
|
/// ```
|
|
/// # use bevy_utils::define_label;
|
|
/// define_label!(
|
|
/// /// A class of labels.
|
|
/// MyNewLabelTrait,
|
|
/// /// Identifies a value that implements `MyNewLabelTrait`.
|
|
/// MyNewLabelId,
|
|
/// );
|
|
/// ```
|
|
#[macro_export]
|
|
macro_rules! define_label {
|
|
(
|
|
$(#[$label_attr:meta])*
|
|
$label_name:ident,
|
|
|
|
$(#[$id_attr:meta])*
|
|
$id_name:ident $(,)?
|
|
) => {
|
|
$(#[$id_attr])*
|
|
#[derive(Clone, Copy, PartialEq, Eq, Hash)]
|
|
pub struct $id_name(::core::any::TypeId, &'static str);
|
|
|
|
impl ::core::fmt::Debug for $id_name {
|
|
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
|
|
write!(f, "{}", self.1)
|
|
}
|
|
}
|
|
|
|
$(#[$label_attr])*
|
|
pub trait $label_name: 'static {
|
|
/// Converts this type into an opaque, strongly-typed label.
|
|
fn as_label(&self) -> $id_name {
|
|
let id = self.type_id();
|
|
let label = self.as_str();
|
|
$id_name(id, label)
|
|
}
|
|
/// Returns the [`TypeId`] used to differentiate labels.
|
|
fn type_id(&self) -> ::core::any::TypeId {
|
|
::core::any::TypeId::of::<Self>()
|
|
}
|
|
/// Returns the representation of this label as a string literal.
|
|
///
|
|
/// In cases where you absolutely need a label to be determined at runtime,
|
|
/// you can use [`Box::leak`] to get a `'static` reference.
|
|
fn as_str(&self) -> &'static str;
|
|
}
|
|
|
|
impl $label_name for $id_name {
|
|
fn as_label(&self) -> Self {
|
|
*self
|
|
}
|
|
fn type_id(&self) -> ::core::any::TypeId {
|
|
self.0
|
|
}
|
|
fn as_str(&self) -> &'static str {
|
|
self.1
|
|
}
|
|
}
|
|
|
|
impl $label_name for &'static str {
|
|
fn as_str(&self) -> Self {
|
|
self
|
|
}
|
|
}
|
|
};
|
|
}
|