Trait fbp::fbp_node_trait::FBPNodeTrait [−][src]
pub trait FBPNodeTrait: Sync + Send + 'static {
fn node_data_clone(&self) -> FBPNodeContext;
fn node_data(&self) -> &FBPNodeContext;
fn node_data_mut(&mut self) -> &mut FBPNodeContext;
fn process_message(
&mut self,
msg: IIDMessage
) -> Result<IIDMessage, NodeError>;
fn node_is_configured(&self) -> bool { ... }
fn wait_for_node_to_be_configured<'life0, 'async_trait>(
&'life0 self
) -> Pin<Box<dyn Future<Output = ()> + 'async_trait>>
where
'life0: 'async_trait,
Self: 'async_trait,
{ ... }
fn do_process_message(
&mut self,
msg_to_process: IIDMessage
) -> Result<(), NodeError> { ... }
fn process_config(
&mut self,
msg: IIDMessage
) -> Result<IIDMessage, NodeError> { ... }
fn process_process_message(
&mut self,
msg: IIDMessage
) -> Result<IIDMessage, NodeError> { ... }
fn start(self)
where
Self: Sized + Send + Sync + Clone + 'static,
{ ... }
fn stop(&mut self) { ... }
}
Required methods
fn node_data_clone(&self) -> FBPNodeContext
fn node_data_clone(&self) -> FBPNodeContext
Return a reference to the FBPNodeContext
This must be implemented by the struct adhering to the FBPNode trait
Example
use serde::{Deserialize, Serialize};
use async_trait::async_trait;
use std::any::Any;
use std::ops::Deref;
use fbp::fbp_node_trait::*;
use fbp::fbp_node_context::*;
use fbp::fbp_iidmessage::*;
use fbp::fbp_node_error::*;
use fbp::fbp_threadsafe_wrapper::ThreadSafeType;
#[derive(Clone, Serialize, Deserialize)]
pub struct ExampleFBPNode {
data: Box<FBPNodeContext>,
}
impl ExampleFBPNode {
pub fn new() -> Self {
ExampleFBPNode {
data: Box::new(FBPNodeContext::new("ExampleFBPNode")),
}
}
}
#[async_trait]
impl FBPNodeTrait for ExampleFBPNode {
fn node_data(&self) -> &FBPNodeContext { &self.data }
fn node_data_mut(&mut self) -> &mut FBPNodeContext { &mut self.data }
fn node_data_clone(&self) -> FBPNodeContext {
self.data.deref().clone()
}
// This is where an FBP node processes IIDMessages. In this example
// No processing is done and the original message is sent along to all of
// the FBP nodes that have registered to receive the output of this node.
fn process_message(&mut self,
msg: IIDMessage) -> std::result::Result<IIDMessage, NodeError> {
Ok(msg.clone())
}
}
fn node_data(&self) -> &FBPNodeContext
fn node_data_mut(&mut self) -> &mut FBPNodeContext
fn node_data_mut(&mut self) -> &mut FBPNodeContext
Return a mutable reference to an FBPNodeContext
This must be implemented by the struct adhering to the FBPNode trait Please see the example for the node_data method for details
fn process_message(&mut self, msg: IIDMessage) -> Result<IIDMessage, NodeError>
fn process_message(&mut self, msg: IIDMessage) -> Result<IIDMessage, NodeError>
Provide the processing for this node.
This is where a specific node does its specific work. In this example, all that is done to to forward the incoming IIDMessage onto any nodes that have registered to receive the output of this node. Please see the example for the node_data method for details
Provided methods
fn node_is_configured(&self) -> bool
fn node_is_configured(&self) -> bool
Return is an FBP node is fully configured and can process IIDMessages
This must be implemented by the struct adhering to the FBPNode trait Please see the example for the node_data method for details
Block waiting on node to be configured
This method will block the caller until the node is fully configured
Example
use serde::{Deserialize, Serialize};
use async_trait::async_trait;
use std::any::Any;
use std::ops::{Deref, DerefMut};
use fbp::fbp_node_trait::*;
use fbp::fbp_node_context::*;
use fbp::fbp_iidmessage::*;
use fbp::fbp_node_error::*;
use fbp::fbp_threadsafe_wrapper::ThreadSafeType;
#[derive(Clone, Serialize, Deserialize)]
pub struct ExampleFBPNode {
data: Box<FBPNodeContext>,
}
impl ExampleFBPNode {
pub fn new() -> Self {
ExampleFBPNode {
data: Box::new(FBPNodeContext::new("ExampleFBPNode")),
}
}
}
#[async_trait]
impl FBPNodeTrait for ExampleFBPNode {
fn node_data(&self) -> &FBPNodeContext { &self.data }
fn node_data_mut(&mut self) -> &mut FBPNodeContext { &mut self.data }
fn node_data_clone(&self) -> FBPNodeContext {
self.data.deref().clone()
}
// This is where an FBP node processes IIDMessages. In this example
// No processing is done and the original message is sent along to all of
// the FBP nodes that have registered to receive the output of this node.
fn process_message(&mut self,
msg: IIDMessage) -> std::result::Result<IIDMessage, NodeError> {
Ok(msg.clone())
}
}
let example_node = ExampleFBPNode::new();
async fn do_wait(node: &ExampleFBPNode) {
node.wait_for_node_to_be_configured().await;
}
do_wait(&example_node);
fn do_process_message(
&mut self,
msg_to_process: IIDMessage
) -> Result<(), NodeError>
fn do_process_message(
&mut self,
msg_to_process: IIDMessage
) -> Result<(), NodeError>
Process an incoming IIDMessage
When a IIDMessage is sent to an FBP node, it is enqueue onto the input queue of the node. The node runs a thread with a loop. At the top of the loop, the queue is checked and if there are no items in the queue, then the node thread blocks waiting for an IIDMessage to be posted to the input queue. If there is at least one message in the input queue, then it will be dequeued and will be processed by this method. If the message is a Data message, then the process_message method will be called. If the message is a Process message then the process_process_message method will be called. If the message is a Config message, then the process_config method will be called. If any errors occur in the processing of the IIDMessage, then a NodeError will be returned.
fn process_config(&mut self, msg: IIDMessage) -> Result<IIDMessage, NodeError>
fn process_config(&mut self, msg: IIDMessage) -> Result<IIDMessage, NodeError>
Process an IIDMessage that is an Config message
This method is called from the do_process_message method to handled incoming config message. If an FBP node needs to receive an Config message to setup its fields so that it has all of the information needed to process messages, then the node will need to implement this method.
fn process_process_message(
&mut self,
msg: IIDMessage
) -> Result<IIDMessage, NodeError>
fn process_process_message(
&mut self,
msg: IIDMessage
) -> Result<IIDMessage, NodeError>
Process an IIDMessage that is a Process message
This method is called from the do_process_message method to handled incoming process message. It is async as it will call the stop method which is async.
Run the message loop for an FBP node.
The start method runs a thread that will block waiting on IIDMessages to be enqueued on to the input of the FBP node. Once enqueued the loop will dequeue a IIDMessage and then call do_process_message to determine what the correct processing is needed for the IIDMessage