Struct fbp::fbp_node_context::FBPNodeContext

pub struct FBPNodeContext {
    pub output_vec: ThreadSafeType<HashMap<String, Vec<Box<FBPNodeContext>>>>,
    pub is_configured: AsyncState,
    pub is_running: AsyncState,
    pub node_completion: AsyncState,
    // some fields omitted
}

FBP Node Context

The fields in this struct are all of the required data for a Flow Based Programming node.

Fields

output_vec: ThreadSafeType<HashMap<String, Vec<Box<FBPNodeContext>>>>

is_configured: AsyncState

is_running: AsyncState

node_completion: AsyncState

Implementations

impl FBPNodeContext

pub fn new(name: &str) -> Self

Create a new FBPNodeContext

pub fn name(&self) -> String

Return the name of this FBPNodeContext

pub fn uuid(&self) -> Uuid

Return the UUID associated with the FBPNodeContext

All FBPNodeContexts and by extension all FBP Nodes have a unique identifier. This is used to add and remove specific instances of an FBP node from various groups.

pub fn rx(&self) -> Box<FBPNodeReceiver>

Return the Receiver for this FBPNodeContext

This is the input queue for an FBP Node

pub fn tx(&self) -> Box<FBPNodeSender>

Return the Sender for this FBPNodeContext

This is the output sender for an FBP Node

pub fn node_is_running(&self) -> bool

Returns true if the node’s thread is running and processing messages

Basic usage:

use fbp::fbp_node_context::*;

// NOTE:  An FBPNodeContext is usally NOT created as a standalone struct.  It is used as
// part of an FBP node as is outlined in the example in the NodeNetworkItem documentation.  
// The following example is just to show how the FBPNodeContext struct works.

let my_node_context = FBPNodeContext::new("ExampleContext");
if my_node_context.node_is_running() {
    println!("The node is running");
} else {
    println!("The node is NOT running");
}

pub fn set_node_is_running(&self, flag: bool)

Set if an NodeContext is running or not

This method should only be called by the FBP system and not called directly

pub async fn wait_for_node_to_be_running(&self)

Wait for a node to be running

This will block the caller until the node is running

Basic usage:

use fbp::fbp_node_context::*;

let my_node_context = FBPNodeContext::new("ExampleContext");

async fn test_wait(a_context: &FBPNodeContext) {
    a_context.wait_for_node_to_be_running().await;
}

pub fn node_has_completed(&self) -> bool

Check to see if a node has stopped processing

This will return true if the node has stopped processing

Basic usage:

use fbp::fbp_node_context::*;

let my_node_context = FBPNodeContext::new("ExampleContext");
if my_node_context.node_has_completed() {
    println!("The node has stopped running");
} else {
    println!("The node is still running");
}

pub fn set_node_has_completed(&self, flag: bool)

Set if the FBPNodeContext has stopped running its thread.

This method should not be called outside of the FBP control software

pub async fn wait_for_node_to_complete(&self)

Wait for a node to stop running

This will block the caller until the node has stopped running

Basic usage:

use fbp::fbp_node_context::*;

let my_node_context = FBPNodeContext::new("ExampleContext");

async fn test_wait(a_context: &FBPNodeContext) {
    a_context.wait_for_node_to_complete().await;
}

pub fn node_is_configured(&self) -> bool

Returns if a node is fully configured

This will return true if the node is fully configured

Basic usage:

use fbp::fbp_node_context::*;

let my_node_context = FBPNodeContext::new("ExampleContext");
if my_node_context.node_is_configured() {
    println!("The node is fully configured");
} else {
    println!("The node needs to be configured");
}

pub fn set_node_is_configured(&self, flag: bool)

Set if a node has all of its configuration data in place.

This should be implemented by an FBP node when it requires configuration. The easiest way to do this is to add an accessor for the required field and when it is set, call this method to signal that the node has all of its configurations in place and can start running

pub async fn wait_for_node_to_be_configured(&self)

Wait for a node to be configured

This will block the caller until the node is fully configured

Basic usage:

use fbp::fbp_node_context::*;

let my_node_context = FBPNodeContext::new("ExampleContext");

async fn test_wait(a_context: &FBPNodeContext) {
    a_context.wait_for_node_to_be_configured().await;
}

pub fn node_is_suspended(&self) -> bool

Returns if the node has suspended processing

This will return true if the node has been suspended

Basic usage:

use fbp::fbp_node_context::*;

let my_node_context = FBPNodeContext::new("ExampleContext");
if my_node_context.node_is_suspended() {
    println!("The node has been suspended");
} else {
    println!("The node is NOT suspended");
}

pub fn set_is_suspended(&self, flag: bool)

Set if this FBPCondeContext is suspended

This method should only be called by the FBP system and not called directly

pub fn add_receiver(
    &mut self,
    receiver: &mut FBPNodeContext,
    key: Option<String>
)

Add an FBPContext to receive the output of this node

This will create a Receiver Context and then add that context to the nodes output_vec field

Basic usage:

use fbp::fbp_node_context::*;

let mut my_node_context = FBPNodeContext::new("ExampleContext");
let mut my_downstream_context = FBPNodeContext::new("DownStreamContext");

// The Key parameter allows for grouping receiving nodes into groups.  This could be used
// to send only certain types of output to certain groups.  Typically None is passed which
// specifies that the node should receive ALL output from a node.
my_node_context.add_receiver(&mut my_downstream_context, None);

pub fn remove_receiver(
    &mut self,
    receiver: &mut FBPNodeContext,
    key: Option<String>
)

Remove an FBPContext from the list of nodes to receive the output from

This will find the receiver FBPNodeContext in the output_vec field of the node and will remove it from receiving the output of this node.

Basic usage:

use fbp::fbp_node_context::*;

let mut my_node_context = FBPNodeContext::new("ExampleContext");
let mut my_downstream_context = FBPNodeContext::new("DownStreamContext");
// The Key parameter allows for removing a receiving context from the output_vec that was
// previously placed into an output group.  Typically this is set to None which just removes
// the context entirely
 my_node_context.remove_receiver(&mut my_downstream_context, None);

pub fn get_num_items_for_receiver_vec(&self, key: Option<String>) -> usize

Returns the number of nodes that have registered to receive the output of this node.

This will return the number of nodes that have asked to receive the output from this context. If the key option is set, then it will only count those contexts that have registered with the group. If the key option is set to None, then all receivers will be counted

Basic usage:

use fbp::fbp_node_context::*;

let my_node_context = FBPNodeContext::new("ExampleContext");
let num_receivers = my_node_context.get_num_items_for_receiver_vec(None);

pub fn post_msg(&self, msg: IIDMessage)

Post an IIDMessage to the input queue of a context.

This will post a message to the input queue of this context. Messages posted to the input queue are dealt with in a First In, First Out (FIFO) manner

Basic usage:

use fbp::fbp_node_context::*;
use fbp::fbp_iidmessage::*;

let a_msg = IIDMessage::new(MessageType::Data, Some("This is a payload".to_string()));
let my_node_context = FBPNodeContext::new("ExampleContext");
my_node_context.post_msg(a_msg);

pub fn post_msg_to_group(&self, msg: IIDMessage, key: Option<String>)

Post an IIDMessage to a specific set of receiver nodes

This will post a message to the group of receivers that were added with a specific key when calling add_receiver. The message will only be sent to those receivers that were added with the key

/// Basic usage:

use fbp::fbp_node_context::*;
use fbp::fbp_iidmessage::*;

let mut my_node_context = FBPNodeContext::new("ExampleContext");
let mut group_a =  FBPNodeContext::new("GroupA");
let mut group_b =  FBPNodeContext::new("GroupB");
my_node_context.add_receiver(&mut group_a, Some("GroupA".to_string()));
my_node_context.add_receiver(&mut group_b, Some("GroupB".to_string()));

let group_a_msg = IIDMessage::new(MessageType::Data, Some("A GroupA msg".to_string()));
let group_b_msg = IIDMessage::new(MessageType::Data, Some("A GroupB msg".to_string()));

// This code would most likely be in the trait implementation  of
// process_message(self: &mut Self, msg: IIDMessage) -> std::result::Result<IIDMessage, NodeError>;
// method.  This assumes that a node will create two different types of IIDMessages.  One
// for GroupA and one for GroupB.

my_node_context.post_msg_to_group(group_a_msg, Some("GroupA".to_string()));
my_node_context.post_msg_to_group(group_b_msg, Some("GroupB".to_string()));

Trait Implementations

impl Clone for FBPNodeContext

fn clone(&self) -> FBPNodeContext

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'de> Deserialize<'de> for FBPNodeContext

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl PartialEq<FBPNodeContext> for FBPNodeContext

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl Serialize for FBPNodeContext

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.