Struct InMemoryNodeManager 

pub struct InMemoryNodeManager<TImpl> { /* private fields */ }

A node manager that stores its nodes in an in-memory AddressSpace. This only supports a static list of namespaces, and a attributes stored in memory.

Implementations of custom behavior are provided with a type implementing InMemoryNodeManagerImpl.

Implementations

impl<TImpl: InMemoryNodeManagerImpl> InMemoryNodeManager<TImpl>

pub fn inner(&self) -> &TImpl

Return the inner InMemoryNodeManagerImpl.

pub fn address_space(&self) -> &Arc<RwLock<AddressSpace>>

Get the address space.

pub fn namespaces(&self) -> &HashMap<u16, String>

Get a reference to the namespaces managed by this node manager, by namespace index.

pub fn set_attributes<'a>( &self, subscriptions: &SubscriptionCache, values: impl Iterator<Item = (&'a NodeId, AttributeId, Variant)>, ) -> Result<(), StatusCode>

Set the attributes given in values and notify any subscriptions about the changes.

To set values, use InMemoryNodeManager::set_values.

pub fn set_attribute( &self, subscriptions: &SubscriptionCache, id: &NodeId, attribute_id: AttributeId, value: Variant, ) -> Result<(), StatusCode>

Set the attribute given by attribute_id on the node with ID id to value.

pub fn set_values<'a>( &self, subscriptions: &SubscriptionCache, values: impl Iterator<Item = (&'a NodeId, Option<&'a NumericRange>, DataValue)>, ) -> Result<(), StatusCode>

Set variable values with updates given by values, notifying any subscriptions of the changes.

pub fn set_value( &self, subscriptions: &SubscriptionCache, id: &NodeId, index_range: Option<&NumericRange>, value: DataValue, ) -> Result<(), StatusCode>

Set the variable value to value, using index_range, on the node with ID id.

Trait Implementations

impl<TImpl: InMemoryNodeManagerImpl> NodeManager for InMemoryNodeManager<TImpl>

fn add_nodes<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, context: &'life1 RequestContext, nodes_to_add: &'life2 mut [&'life3 mut AddNodeItem], ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Add a list of nodes.

This should create the nodes, or set a failed status as appropriate. If a node was created, the status should be set to Good.

fn owns_node(&self, id: &NodeId) -> bool

Return whether this node manager owns the given node, this is used for propagating service-level errors.

fn name(&self) -> &str

Name of this node manager, for debug purposes.

fn init<'life0, 'life1, 'async_trait>( &'life0 self, type_tree: &'life1 mut DefaultTypeTree, context: ServerContext, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Perform any necessary loading of nodes, should populate the type tree if needed.

fn namespaces_for_user( &self, _context: &RequestContext, ) -> Vec<NamespaceMetadata>

Namespaces for a given user, used to populate the namespace array. This being a method allows different users to see different namespaces.

fn handle_new_node(&self, parent_id: &ExpandedNodeId) -> bool

Return whether this node should handle requests to create a node for the given parent ID. This is only called if no new node ID is requested, otherwise owns_node is called on the requested node ID.

fn resolve_external_references<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, context: &'life1 RequestContext, items: &'life2 mut [&'life3 mut ExternalReferenceRequest], ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Resolve a list of references given by a different node manager.

fn browse<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, context: &'life1 RequestContext, nodes_to_browse: &'life2 mut [BrowseNode], ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Perform the Browse or BrowseNext service.

fn read<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, context: &'life1 RequestContext, max_age: f64, timestamps_to_return: TimestampsToReturn, nodes_to_read: &'life2 mut [&'life3 mut ReadNode], ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Execute the Read service. This should set results on the given nodes_to_read as needed.

fn translate_browse_paths_to_node_ids<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, context: &'life1 RequestContext, nodes: &'life2 mut [&'life3 mut BrowsePathItem<'_>], ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Perform the translate browse paths to node IDs service.

fn register_nodes<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, context: &'life1 RequestContext, nodes: &'life2 mut [&'life3 mut RegisterNodeItem], ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Perform the register nodes service. The default behavior for this service is to do nothing and pretend the nodes were registered.

fn unregister_nodes<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, context: &'life1 RequestContext, nodes: &'life2 [&'life3 NodeId], ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Perform the unregister nodes service. The default behavior for this service is to do nothing.

fn create_monitored_items<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, context: &'life1 RequestContext, items: &'life2 mut [&'life3 mut CreateMonitoredItem], ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Prepare for monitored item creation, the node manager must take action to sample data for each produced monitored item, according to the parameters. Monitored item parameters have already been revised according to server limits, but the node manager is allowed to further revise sampling interval.

fn modify_monitored_items<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, context: &'life1 RequestContext, items: &'life2 [&'life3 MonitoredItemUpdateRef], ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Modify monitored items. This method is purely informative for the node manager, to let it modify sampling intervals, apply a new filter, or similar.

fn set_monitoring_mode<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, context: &'life1 RequestContext, mode: MonitoringMode, items: &'life2 [&'life3 MonitoredItemRef], ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Modify monitored items. This method is purely informative for the node manager, to let it pause or resume sampling. Note that this should not delete context stored from create_monitored_items, since it may be called again to resume sampling.

fn delete_monitored_items<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, context: &'life1 RequestContext, items: &'life2 [&'life3 MonitoredItemRef], ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Delete monitored items. This method is purely informative for the node manager, to let it stop sampling, or similar.

fn history_read_raw_modified<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, context: &'life1 RequestContext, details: &'life2 ReadRawModifiedDetails, nodes: &'life3 mut [&'life4 mut HistoryNode], timestamps_to_return: TimestampsToReturn, ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Perform the history read raw modified service. This should write results to the nodes list of type either HistoryData or HistoryModifiedData

fn history_read_processed<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, context: &'life1 RequestContext, details: &'life2 ReadProcessedDetails, nodes: &'life3 mut [&'life4 mut HistoryNode], timestamps_to_return: TimestampsToReturn, ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Perform the history read processed service. This should write results to the nodes list of type HistoryData.

fn history_read_at_time<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, context: &'life1 RequestContext, details: &'life2 ReadAtTimeDetails, nodes: &'life3 mut [&'life4 mut HistoryNode], timestamps_to_return: TimestampsToReturn, ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Perform the history read processed service. This should write results to the nodes list of type HistoryData.

fn history_read_events<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, context: &'life1 RequestContext, details: &'life2 ReadEventDetails, nodes: &'life3 mut [&'life4 mut HistoryNode], timestamps_to_return: TimestampsToReturn, ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Perform the history read events service. This should write results to the nodes list of type HistoryEvent.

fn history_read_annotations<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, context: &'life1 RequestContext, details: &'life2 ReadAnnotationDataDetails, nodes: &'life3 mut [&'life4 mut HistoryNode], timestamps_to_return: TimestampsToReturn, ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Perform the history read annotations data service. This should write results to the nodes list of type Annotation.

fn write<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, context: &'life1 RequestContext, nodes_to_write: &'life2 mut [&'life3 mut WriteNode], ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Perform the write service. This should write results to the nodes_to_write list. The default result is BadNodeIdUnknown

fn history_update<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, context: &'life1 RequestContext, nodes: &'life2 mut [&'life3 mut HistoryUpdateNode], ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Perform the HistoryUpdate service. This should write result status codes to the nodes list as appropriate.

fn call<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, context: &'life1 RequestContext, methods_to_call: &'life2 mut [&'life3 mut MethodCall], ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Call a list of methods.

fn add_references<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, context: &'life1 RequestContext, references_to_add: &'life2 mut [&'life3 mut AddReferenceItem], ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Add a list of references.

fn delete_nodes<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, context: &'life1 RequestContext, nodes_to_delete: &'life2 mut [&'life3 mut DeleteNodeItem], ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Delete a list of nodes.

fn delete_node_references<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, context: &'life1 RequestContext, to_delete: &'life2 [&'life3 DeleteNodeItem], ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Delete references for the given list of nodes. The node manager should respect delete_target_references.

fn delete_references<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, context: &'life1 RequestContext, references_to_delete: &'life2 mut [&'life3 mut DeleteReferenceItem], ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Delete a list of references.

fn owns_server_events(&self) -> bool

Return whether this node manager owns events on the server. The first node manager that returns true here will be called when reading or updating historical server events.

fn query<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, context: &'life1 RequestContext, request: &'life2 mut QueryRequest, ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Perform a query on the address space.