Struct opcua_server::address_space::references::References

pub struct References { /* private fields */ }

Implementations

impl References

pub fn insert<T>(
    &mut self,
    source_node: &NodeId,
    references: &[(&NodeId, &T, ReferenceDirection)]
) where
    T: Into<NodeId> + Clone, 

Inserts a single reference into the map.

pub fn insert_reference<T>(
    &mut self,
    source_node: &NodeId,
    target_node: &NodeId,
    reference_type: &T
) where
    T: Into<NodeId> + Clone, 

pub fn insert_references<T>(&mut self, references: &[(&NodeId, &NodeId, &T)]) where
    T: Into<NodeId> + Clone, 

Inserts references into the map.

pub fn delete_reference<T>(
    &mut self,
    source_node: &NodeId,
    target_node: &NodeId,
    reference_type: T
) -> bool where
    T: Into<NodeId>, 

Deletes a matching references between one node and the target node of the specified reference type. The function returns true if the reference was found and deleted.

pub fn delete_node_references(&mut self, source_node: &NodeId) -> bool

Deletes all references to the node.

pub fn has_reference<T>(
    &self,
    source_node: &NodeId,
    target_node: &NodeId,
    reference_type: T
) -> bool where
    T: Into<NodeId>, 

Test if a reference relationship exists between one node and another node

pub fn find_references<T>(
    &self,
    source_node: &NodeId,
    reference_filter: Option<(T, bool)>
) -> Option<Vec<Reference>> where
    T: Into<NodeId> + Clone, 

Finds forward references from the node

pub fn find_inverse_references<T>(
    &self,
    target_node: &NodeId,
    reference_filter: Option<(T, bool)>
) -> Option<Vec<Reference>> where
    T: Into<NodeId> + Clone, 

Returns inverse references for the target node, i.e if there are references where Reference.target_node matches the supplied target node then return references where Reference.target_node is the source node.

pub fn find_references_by_direction<T>(
    &self,
    node: &NodeId,
    browse_direction: BrowseDirection,
    reference_filter: Option<(T, bool)>
) -> (Vec<Reference>, usize) where
    T: Into<NodeId> + Clone, 

Find references optionally to and/or from the specified node id. The browse direction indicates the desired direction, or both. The reference filter indicates if only references of a certain type (including sub types) should be fetched.

pub fn reference_type_matches(
    &self,
    ref_type: &NodeId,
    ref_subtype: &NodeId,
    include_subtypes: bool
) -> bool

Test if a reference type matches another reference type which is potentially a subtype. If include_subtypes is set to true, the function will test if the subttype for a match.

pub fn get_type_id(&self, node: &NodeId) -> Option<NodeId>

Trait Implementations

impl Default for References

fn default() -> Self

Returns the “default value” for a type.