Struct NodeIdRef 

pub struct NodeIdRef<T> {
    pub namespace: u16,
    pub identifier: T,
}

Cheap reference to a node ID of a specific type.

Fields

namespace: u16

Namespace index of the node ID.

identifier: T

Identifier of the node ID.

Trait Implementations

impl<T: Clone> Clone for NodeIdRef<T>

fn clone(&self) -> NodeIdRef<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for NodeIdRef<T>

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

Formats the value using the given formatter.

impl<T> Equivalent<NodeId> for NodeIdRef<T>

where NodeIdRef<T>: PartialEq<NodeId>,

fn equivalent(&self, key: &NodeId) -> bool

Compare self to key and return true if they are equal.

impl<'a> From<&'a NodeId> for NodeIdRef<&'a Identifier>

fn from(value: &'a NodeId) -> Self

Converts to this type from the input type.

impl<T> From<(u16, T)> for NodeIdRef<T>

where T: IdentifierRef,

fn from(value: (u16, T)) -> Self

Converts to this type from the input type.

impl<T> Hash for NodeIdRef<T>

where T: IdentifierRef,

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<'a, T> IntoNodeIdRef<'a> for NodeIdRef<T>

where T: IdentifierRef + Clone + Copy + 'a,

type TIdentifier = T

The inner identifier type.

fn into_node_id_ref(self) -> NodeIdRef<Self::TIdentifier>

Get a reference to this as a NodeIdRef.

impl<T> PartialEq<&NodeId> for NodeIdRef<T>

where T: PartialEq<Identifier>,

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<T> PartialEq<DataTypeId> for NodeIdRef<T>

where T: PartialEq<Identifier>,

fn eq(&self, other: &DataTypeId) -> 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<T> PartialEq<MethodId> for NodeIdRef<T>

where T: PartialEq<Identifier>,

fn eq(&self, other: &MethodId) -> 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<T> PartialEq<NodeId> for NodeIdRef<T>

where T: PartialEq<Identifier>,

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<T> PartialEq<NodeIdRef<T>> for &NodeId

where T: PartialEq<Identifier>,

fn eq(&self, other: &NodeIdRef<T>) -> 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<T> PartialEq<NodeIdRef<T>> for NodeId

where T: PartialEq<Identifier>,

fn eq(&self, other: &NodeIdRef<T>) -> 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<T> PartialEq<ObjectId> for NodeIdRef<T>

where T: PartialEq<Identifier>,

fn eq(&self, other: &ObjectId) -> 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<T> PartialEq<ObjectTypeId> for NodeIdRef<T>

where T: PartialEq<Identifier>,

fn eq(&self, other: &ObjectTypeId) -> 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<T> PartialEq<ReferenceTypeId> for NodeIdRef<T>

where T: PartialEq<Identifier>,

fn eq(&self, other: &ReferenceTypeId) -> 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<T> PartialEq<VariableId> for NodeIdRef<T>

where T: PartialEq<Identifier>,

fn eq(&self, other: &VariableId) -> 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<T> PartialEq<VariableTypeId> for NodeIdRef<T>

where T: PartialEq<Identifier>,

fn eq(&self, other: &VariableTypeId) -> 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<T: PartialEq> PartialEq for NodeIdRef<T>

fn eq(&self, other: &NodeIdRef<T>) -> 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<T: Copy> Copy for NodeIdRef<T>

impl<T: Eq> Eq for NodeIdRef<T>

impl<T> StructuralPartialEq for NodeIdRef<T>