Enum AnyId 

#[non_exhaustive]
pub enum AnyId {
    Module(Id<ModuleNode>, NodeId),
    Type(Id<TypeNode>, NodeId),
    Member(Id<MemberNode>, NodeId),
    Case(Id<CaseNode>, NodeId),
    Enumerator(Id<EnumeratorNode>, NodeId),
    BitValue(Id<BitValueNode>, NodeId),
    Bitfield(Id<BitfieldNode>, NodeId),
    Const(Id<ConstNode>, NodeId),
    ConstExpr(Id<ConstExprNode>, NodeId),
    Interface(Id<InterfaceNode>, NodeId),
    Operation(Id<OperationNode>, NodeId),
    Param(Id<ParamNode>, NodeId),
    Attribute(Id<AttributeNode>, NodeId),
    Exception(Id<ExceptionNode>, NodeId),
    AnnotationDef(Id<AnnotationDefNode>, NodeId),
    AnnotationMember(Id<AnnotationMemberNode>, NodeId),
    Domain(Id<DomainNode>, NodeId),
    Topic(Id<TopicNode>, NodeId),
    QosProfile(Id<QosProfileNode>, NodeId),
    Participant(Id<ParticipantNode>, NodeId),
    Endpoint(Id<EndpointNode>, NodeId),
    Library(Id<LibraryNode>, NodeId),
}

A handle to any node, carrying its kind and its stable identity.

Used where a container holds mixed kinds — a module’s children, a member’s parent — without erasing which kind each entry is.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Module(Id<ModuleNode>, NodeId)

A module.

Type(Id<TypeNode>, NodeId)

A type.

Member(Id<MemberNode>, NodeId)

An aggregate member.

Case(Id<CaseNode>, NodeId)

A union case.

Enumerator(Id<EnumeratorNode>, NodeId)

An enumerator.

BitValue(Id<BitValueNode>, NodeId)

A bitmask bit.

Bitfield(Id<BitfieldNode>, NodeId)

A bitset field.

Const(Id<ConstNode>, NodeId)

A constant.

ConstExpr(Id<ConstExprNode>, NodeId)

An expression node.

Interface(Id<InterfaceNode>, NodeId)

An interface.

Operation(Id<OperationNode>, NodeId)

An operation.

Param(Id<ParamNode>, NodeId)

An operation parameter.

Attribute(Id<AttributeNode>, NodeId)

An interface attribute.

Exception(Id<ExceptionNode>, NodeId)

An exception.

AnnotationDef(Id<AnnotationDefNode>, NodeId)

An annotation declaration.

AnnotationMember(Id<AnnotationMemberNode>, NodeId)

An annotation member.

Domain(Id<DomainNode>, NodeId)

A domain.

Topic(Id<TopicNode>, NodeId)

A topic.

QosProfile(Id<QosProfileNode>, NodeId)

A QoS profile.

Participant(Id<ParticipantNode>, NodeId)

A participant.

Endpoint(Id<EndpointNode>, NodeId)

An endpoint.

Library(Id<LibraryNode>, NodeId)

A deployment library.

Implementations

impl AnyId

pub const fn node_id(self) -> NodeId

The node’s stable identity.

pub const fn kind(self) -> NodeKind

The node’s kind.

pub const fn as_type(self) -> Option<Id<TypeNode>>

The type handle, if this names a type.

pub const fn as_interface(self) -> Option<Id<InterfaceNode>>

The interface handle, if this names an interface.

pub const fn as_module(self) -> Option<Id<ModuleNode>>

The module handle, if this names a module.

pub const fn as_member(self) -> Option<Id<MemberNode>>

The member handle, if this names a member.

Trait Implementations

impl Clone for AnyId

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for AnyId

impl Debug for AnyId

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

Formats the value using the given formatter.

impl Eq for AnyId

impl Hash for AnyId

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 AnyId

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for AnyId