Struct NodeID 

pub struct NodeID(/* private fields */);

A unique identifier for a Node variant

The exact mapping of Nodes to NodeIDs is not stable; as such, the underlying representation is hidden.

let mut found_names = HashSet::new();
for node_id in NodeID::all() {
    let name: &'static str = node_id.into();
    assert!(found_names.insert(name));
}

Implementations

impl NodeID

pub fn all() -> impl Iterator<Item = NodeID>

An iterator across all possible NodeIDs

impl NodeID

pub const fn from_node(node: &Node<'_, '_>) -> NodeID

A const version of NodeID::from::<&Node<'_, '_>>

impl NodeID

pub const fn try_from_name(name: &str) -> Option<NodeID>

A const version of NodeID::try_from::<&str>

impl NodeID

pub const fn into_name(id: NodeID) -> &'static str

A const version of &'static str::from::<NodeID>

Trait Implementations

impl Clone for NodeID

fn clone(&self) -> NodeID

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for NodeID

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for NodeID

impl From<&Node<'_, '_>> for NodeID

fn from(value: &Node<'_, '_>) -> NodeID

Get the NodeID of a Node

let identifier_one = Identifier::SimpleIdentifier((
    "my_signal",
    Metadata::default()
));
let node_one: Node<'_, '_> = (&identifier_one).into();
let node_id_one: NodeID = (&node_one).into();
let identifier_two = Identifier::SimpleIdentifier((
    "my_other_signal",
    Metadata::default()
));
let node_two: Node<'_, '_> = (&identifier_two).into();
let node_id_two: NodeID = (&node_two).into();
assert_eq!(node_id_one, node_id_two);

impl From<NodeID> for &'static str

Get the name of a Node based on its NodeID

let identifier = Identifier::SimpleIdentifier((
    "my_signal",
    Metadata::default()
));
let node: Node<'_, '_> = (&identifier).into();
let node_id: NodeID = (&node).into();
let node_id_name: &'static str = node_id.into();
assert_eq!(node_id_name, "Identifier");

fn from(value: NodeID) -> Self

Converts to this type from the input type.

impl Hash for NodeID

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for NodeID

fn eq(&self, other: &NodeID) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for NodeID

impl TryFrom<&str> for NodeID

Lookup the NodeID of a Node based on its name

let identifier = Identifier::SimpleIdentifier((
    "my_signal",
    Metadata::default()
));
let node: Node<'_, '_> = (&identifier).into();
let node_id: NodeID = (&node).into();
let identifier_node_id: NodeID = "Identifier".try_into().unwrap();
assert_eq!(node_id, identifier_node_id);

type Error = ()

The type returned in the event of a conversion error.

fn try_from(value: &str) -> Result<Self, Self::Error>

Performs the conversion.