Struct RuntimeTree

pub struct RuntimeTree {
    pub root: RNodeId,
    pub nodes: HashMap<RNodeId, RNode>,
}

The runtime tree is a representation of the compilation tree supplemented with some runtime information.

Fields

root: RNodeId

nodes: HashMap<RNodeId, RNode>

Implementations

impl RuntimeTree

pub fn iter(&self) -> RtTreeBfsIter<'_>

Returns bfs iterator over the runtime tree

pub fn analyze(&self) -> RtTreeAnalyzer<'_>

Returns the analyzer for the runtime tree which provides methods to analyze the tree and find nodes by some criteria

Example

    use forester_rs::runtime::args::RtArgs;
    use forester_rs::runtime::rtree::builder::RtNodeBuilder;
    use forester_rs::runtime::rtree::builder::RtTreeBuilder;
    use forester_rs::runtime::rtree::rnode::FlowType;
    use forester_rs::runtime::rtree::rnode::RNodeName;
    use forester_rs::*;

    #[test]
    fn analyzer() {
        let mut rtb = RtTreeBuilder::new();

        let flow = flow!(fallback node_name!("root"), args!();
            flow!(sequence node_name!("seq"), args!();
                 action!(node_name!("action1"))
            ),
           action!(node_name!("action2"))
        );

        rtb.add_as_root(flow);
        let tree = rtb.build().unwrap().0;

        let analyzer = tree.analyze();

        let a1 = analyzer.find_id_by(|n| n.is_name("action1")).unwrap();
        let a2 = analyzer.find_id_by(|n| n.is_name("action2")).unwrap();
        let root = analyzer.find_id_by(|n| n.is_name("root")).unwrap();
        let seq = analyzer.find_id_by(|n| n.is_name("seq")).unwrap();

        assert_eq!(analyzer.parent(&a1), Some(&seq));
        assert_eq!(analyzer.parent(&a2), Some(&root));
        assert_eq!(analyzer.parent(&root), None);
    }

pub fn build(project: Project) -> Result<RuntimeTreeStarter, TreeError>

Builds the runtime tree from the project

pub fn node(&self, id: &RNodeId) -> RtResult<&RNode>

Returns the node by id

pub fn max_id(&self) -> RNodeId

find the max given id in the tree

pub fn to_ros_nav(&self, xml: PathBuf) -> RtOk

Converts the runtime tree into the ROS navigation xml file

Trait Implementations

impl Debug for RuntimeTree

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for RuntimeTree

fn default() -> RuntimeTree

Returns the “default value” for a type.

impl PartialEq for RuntimeTree

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for RuntimeTree