typex 0.1.1

Runtime reflection: inspection, traversal, equality and mutation
Documentation 
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

use core::any::TypeId;
use core::fmt::Debug;
use core::hash::Hash;

/// Shallow metadata about a type, containing its qualified Rust name and type
/// ID. Equality and hashing are based only on the type ID.
///
/// # Example
/// ```
/// # use std::collections::HashSet;
/// # use typex::TypeInfo;
///
/// struct UserId(u64);
///
/// let info = TypeInfo::of::<UserId>();
///
/// assert_eq!(info.name(), core::any::type_name::<UserId>());
/// assert_eq!(info.id(), TypeInfo::of::<UserId>().id());
/// assert_eq!(info, TypeInfo::of::<UserId>());
/// assert!(HashSet::from([info]).contains(&TypeInfo::of::<UserId>()));
/// ```
#[derive(Copy, Clone)]
pub struct TypeInfo {
  name: &'static str,
  id: TypeId,
}

impl TypeInfo {
  /// Returns shallow type metadata for `T`.
  pub fn of<T: ?Sized + 'static>() -> Self {
    TypeInfo {
      name: core::any::type_name::<T>(),
      id: TypeId::of::<T>(),
    }
  }

  /// Returns the qualified Rust name from [`core::any::type_name`].
  #[inline]
  pub fn name(&self) -> &'static str {
    self.name
  }

  /// Returns the type's [`TypeId`].
  #[inline]
  pub fn id(&self) -> TypeId {
    self.id
  }
}

/// Hashes the type ID of a [`TypeInfo`] value.
///
/// [`TypeInfo`] values can only be created through [`TypeInfo::of`], so hashing
/// the type ID is sufficient.
impl Hash for TypeInfo {
  fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
    self.id.hash(state);
  }
}

/// Compares the type IDs of [`TypeInfo`] values.
///
/// [`TypeInfo`] values can only be created through [`TypeInfo::of`], so matching
/// type IDs is sufficient.
impl PartialEq for TypeInfo {
  fn eq(&self, other: &Self) -> bool {
    self.id == other.id
  }
}

impl Eq for TypeInfo {}

/// Formats [`TypeInfo`] values as their qualified Rust type names.
impl Debug for TypeInfo {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    f.write_str(self.name)
  }
}