Trait InMemoryNodeManagerImpl 

pub trait InMemoryNodeManagerImpl:
    Send
    + Sync
    + 'static {
    // Required methods
    fn init<'life0, 'life1, 'async_trait>(
        &'life0 self,
        address_space: &'life1 mut AddressSpace,
        context: ServerContext,
    ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: 'async_trait;
    fn name(&self) -> &str;
    fn namespaces(&self) -> Vec<NamespaceMetadata>;

    // Provided methods
    fn owns_server_events(&self) -> bool { ... }
    fn handle_new_node(&self, parent_id: &ExpandedNodeId) -> bool { ... }
    fn register_nodes<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>(
        &'life0 self,
        context: &'life1 RequestContext,
        address_space: &'life2 RwLock<RawRwLock, AddressSpace>,
        nodes: &'life3 mut [&'life4 mut RegisterNodeItem],
    ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait,
             'life4: 'async_trait,
             Self: 'async_trait { ... }
    fn read_values<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>(
        &'life0 self,
        context: &'life1 RequestContext,
        address_space: &'life2 RwLock<RawRwLock, AddressSpace>,
        nodes: &'life3 [&'life4 ParsedReadValueId],
        max_age: f64,
        timestamps_to_return: TimestampsToReturn,
    ) -> Pin<Box<dyn Future<Output = Vec<DataValue>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait,
             'life4: 'async_trait,
             Self: 'async_trait { ... }
    fn create_value_monitored_items<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'async_trait>(
        &'life0 self,
        context: &'life1 RequestContext,
        address_space: &'life2 RwLock<RawRwLock, AddressSpace>,
        items: &'life3 mut [&'life4 mut &'life5 mut CreateMonitoredItem],
    ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait,
             'life4: 'async_trait,
             'life5: 'async_trait,
             Self: 'async_trait { ... }
    fn create_event_monitored_items<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'async_trait>(
        &'life0 self,
        context: &'life1 RequestContext,
        address_space: &'life2 RwLock<RawRwLock, AddressSpace>,
        items: &'life3 mut [&'life4 mut &'life5 mut CreateMonitoredItem],
    ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait,
             'life4: 'async_trait,
             'life5: 'async_trait,
             Self: 'async_trait { ... }
    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 'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait,
             Self: 'async_trait { ... }
    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 'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait,
             Self: 'async_trait { ... }
    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 'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait,
             Self: 'async_trait { ... }
    fn unregister_nodes<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>(
        &'life0 self,
        context: &'life1 RequestContext,
        address_space: &'life2 RwLock<RawRwLock, AddressSpace>,
        nodes: &'life3 [&'life4 NodeId],
    ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait,
             'life4: 'async_trait,
             Self: 'async_trait { ... }
    fn history_read_raw_modified<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'async_trait>(
        &'life0 self,
        context: &'life1 RequestContext,
        details: &'life2 ReadRawModifiedDetails,
        nodes: &'life3 mut [&'life4 mut &'life5 mut HistoryNode],
        timestamps_to_return: TimestampsToReturn,
    ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait,
             'life4: 'async_trait,
             'life5: 'async_trait,
             Self: 'async_trait { ... }
    fn history_read_processed<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'async_trait>(
        &'life0 self,
        context: &'life1 RequestContext,
        details: &'life2 ReadProcessedDetails,
        nodes: &'life3 mut [&'life4 mut &'life5 mut HistoryNode],
        timestamps_to_return: TimestampsToReturn,
    ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait,
             'life4: 'async_trait,
             'life5: 'async_trait,
             Self: 'async_trait { ... }
    fn history_read_at_time<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'async_trait>(
        &'life0 self,
        context: &'life1 RequestContext,
        details: &'life2 ReadAtTimeDetails,
        nodes: &'life3 mut [&'life4 mut &'life5 mut HistoryNode],
        timestamps_to_return: TimestampsToReturn,
    ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait,
             'life4: 'async_trait,
             'life5: 'async_trait,
             Self: 'async_trait { ... }
    fn history_read_events<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'async_trait>(
        &'life0 self,
        context: &'life1 RequestContext,
        details: &'life2 ReadEventDetails,
        nodes: &'life3 mut [&'life4 mut &'life5 mut HistoryNode],
        timestamps_to_return: TimestampsToReturn,
    ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait,
             'life4: 'async_trait,
             'life5: 'async_trait,
             Self: 'async_trait { ... }
    fn history_read_annotations<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'async_trait>(
        &'life0 self,
        context: &'life1 RequestContext,
        details: &'life2 ReadAnnotationDataDetails,
        nodes: &'life3 mut [&'life4 mut &'life5 mut HistoryNode],
        timestamps_to_return: TimestampsToReturn,
    ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait,
             'life4: 'async_trait,
             'life5: 'async_trait,
             Self: 'async_trait { ... }
    fn history_update<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>(
        &'life0 self,
        context: &'life1 RequestContext,
        nodes: &'life2 mut [&'life3 mut &'life4 mut HistoryUpdateNode],
    ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait,
             'life4: 'async_trait,
             Self: 'async_trait { ... }
    fn write<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>(
        &'life0 self,
        context: &'life1 RequestContext,
        address_space: &'life2 RwLock<RawRwLock, AddressSpace>,
        nodes_to_write: &'life3 mut [&'life4 mut WriteNode],
    ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait,
             'life4: 'async_trait,
             Self: 'async_trait { ... }
    fn call<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'async_trait>(
        &'life0 self,
        context: &'life1 RequestContext,
        address_space: &'life2 RwLock<RawRwLock, AddressSpace>,
        methods_to_call: &'life3 mut [&'life4 mut &'life5 mut MethodCall],
    ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait,
             'life4: 'async_trait,
             'life5: 'async_trait,
             Self: 'async_trait { ... }
    fn add_nodes<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>(
        &'life0 self,
        context: &'life1 RequestContext,
        address_space: &'life2 RwLock<RawRwLock, AddressSpace>,
        nodes_to_add: &'life3 mut [&'life4 mut AddNodeItem],
    ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait,
             'life4: 'async_trait,
             Self: 'async_trait { ... }
    fn add_references<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>(
        &'life0 self,
        context: &'life1 RequestContext,
        address_space: &'life2 RwLock<RawRwLock, AddressSpace>,
        references_to_add: &'life3 mut [&'life4 mut AddReferenceItem],
    ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait,
             'life4: 'async_trait,
             Self: 'async_trait { ... }
    fn delete_nodes<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>(
        &'life0 self,
        context: &'life1 RequestContext,
        address_space: &'life2 RwLock<RawRwLock, AddressSpace>,
        nodes_to_delete: &'life3 mut [&'life4 mut DeleteNodeItem],
    ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait,
             'life4: 'async_trait,
             Self: 'async_trait { ... }
    fn delete_node_references<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>(
        &'life0 self,
        context: &'life1 RequestContext,
        address_space: &'life2 RwLock<RawRwLock, AddressSpace>,
        to_delete: &'life3 [&'life4 DeleteNodeItem],
    ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait,
             'life4: 'async_trait,
             Self: 'async_trait { ... }
    fn delete_references<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>(
        &'life0 self,
        context: &'life1 RequestContext,
        address_space: &'life2 RwLock<RawRwLock, AddressSpace>,
        references_to_delete: &'life3 mut [&'life4 mut DeleteReferenceItem],
    ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait,
             'life4: 'async_trait,
             Self: 'async_trait { ... }
}

Trait for user-provided implementation of the InMemoryNodeManager

Required Methods

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

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

Populate the address space.

fn name(&self) -> &str

Name of this node manager, for debug purposes.

fn namespaces(&self) -> Vec<NamespaceMetadata>

Return the static list of namespaces this node manager uses.

Provided Methods

fn owns_server_events(&self) -> 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 handle_new_node(&self, parent_id: &ExpandedNodeId) -> bool

Return true if a node with no requested node ID and parent parent_id should be created using this node manager.

This does not commit to actually allowing the node to be created, it just means that no other node managers will be called to create the node.

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

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

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

fn read_values<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, context: &'life1 RequestContext, address_space: &'life2 RwLock<RawRwLock, AddressSpace>, nodes: &'life3 [&'life4 ParsedReadValueId], max_age: f64, timestamps_to_return: TimestampsToReturn, ) -> Pin<Box<dyn Future<Output = Vec<DataValue>> + Send + 'async_trait>>

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

Read for variable values. Other attributes are handled by the parent node ID. This should return a list of data values with the same length and order as nodes.

fn create_value_monitored_items<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'async_trait>( &'life0 self, context: &'life1 RequestContext, address_space: &'life2 RwLock<RawRwLock, AddressSpace>, items: &'life3 mut [&'life4 mut &'life5 mut CreateMonitoredItem], ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

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

Create monitored items for the Value attribute, as needed. This should, at the very least, read the current value of the nodes, and set appropriate status on the monitored item request, see default implementation.

It may also begin sampling as given by the monitored item request.

fn create_event_monitored_items<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'async_trait>( &'life0 self, context: &'life1 RequestContext, address_space: &'life2 RwLock<RawRwLock, AddressSpace>, items: &'life3 mut [&'life4 mut &'life5 mut CreateMonitoredItem], ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

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

Create monitored items for events.

This does not need to do anything.

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 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, Self: 'async_trait,

Handle the SetMonitoringMode request, to pause or resume sampling.

This will only get monitored items for events or value.

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 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, Self: 'async_trait,

Handle modification of monitored items, this may adjust sampling intervals or filters, and require action to update background processes.

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 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, Self: 'async_trait,

Handle deletion of monitored items.

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

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

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

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

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

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

Nodes are verified to be readable before this is called.

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

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

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

Nodes are verified to be readable before this is called.

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

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

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

Nodes are verified to be readable before this is called.

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

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

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

Nodes are verified to be readable before this is called.

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

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

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

Nodes are verified to be readable before this is called.

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

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

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

Nodes are verified to be writable before this is called.

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

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

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

Writing is left almost entirely up to the node manager impl. If you do write values you should call context.subscriptions.notify_data_change to trigger any monitored items subscribed to the updated values.

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

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

Call a list of methods.

The methods have already had their arguments verified to have valid length and the method is verified to exist on the given object. This should try to execute the methods, and set the result.

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

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, Self: '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 add_references<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, context: &'life1 RequestContext, address_space: &'life2 RwLock<RawRwLock, AddressSpace>, references_to_add: &'life3 mut [&'life4 mut AddReferenceItem], ) -> Pin<Box<dyn Future<Output = Result<(), StatusCode>> + Send + 'async_trait>>

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

Add a list of references.

This will be given all references where the source or target belongs to this node manager. A reference is considered successfully added if either source_status or target_status are Good.

If you want to explicitly set the reference to failed, set both source and target status. Note that it may already have been added in a different node manager, you are responsible for any cleanup if you do this.

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

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

Delete a list of nodes.

This will be given all nodes that belong to this node manager.

Typically, you also want to implement delete_node_references if there are other node managers that support deletes.

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

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

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

This is not allowed to fail, you should make it impossible to delete nodes with immutable references.

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

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

Delete a list of references.

This will be given all references where the source or target belongs to this node manager. A reference is considered successfully added if either source_status or target_status are Good.

If you want to explicitly set the reference to failed, set both source and target status. Note that it may already have been deleted in a different node manager, you are responsible for any cleanup if you do this.

Implementors

impl InMemoryNodeManagerImpl for CoreNodeManagerImpl

impl InMemoryNodeManagerImpl for SimpleNodeManagerImpl