behavior-tree-lite 0.3.2

A minimal behavior tree implementation
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

use crate::{
    parser::{BlackboardValue, PortMap, PortMapOwned},
    Symbol,
};

#[derive(Debug, PartialEq, Eq, Clone, Copy)]
pub enum PortType {
    Input,
    Output,
    InOut,
}

#[derive(Debug, PartialEq, Eq, Clone, Copy)]
pub struct PortSpec {
    pub ty: PortType,
    pub key: Symbol,
}

impl PortSpec {
    pub fn new_in(key: impl Into<Symbol>) -> Self {
        Self {
            ty: PortType::Input,
            key: key.into(),
        }
    }

    pub fn new_out(key: impl Into<Symbol>) -> Self {
        Self {
            ty: PortType::Output,
            key: key.into(),
        }
    }

    pub fn new_inout(key: impl Into<Symbol>) -> Self {
        Self {
            ty: PortType::InOut,
            key: key.into(),
        }
    }
}

#[derive(Debug, PartialEq, Eq, Clone)]
pub enum BlackboardValueOwned {
    /// Literal value could have been decoded, so it is an owned string.
    Literal(String),
    Ref(String),
}

impl crate::BlackboardValue {
    pub fn to_owned2(&self) -> BlackboardValueOwned {
        match self {
            Self::Literal(s) => BlackboardValueOwned::Literal(s.clone()),
            Self::Ref(s, _) => BlackboardValueOwned::Ref(s.to_string()),
        }
    }
}

pub trait AbstractPortMap<'src> {
    fn get_type(&self) -> PortType;
    fn node_port(&self) -> &str;
    fn blackboard_value(&self) -> BlackboardValueOwned;
}

impl<'src> AbstractPortMap<'src> for PortMap<'src> {
    fn get_type(&self) -> PortType {
        self.ty
    }

    fn node_port(&self) -> &'src str {
        self.node_port
    }

    fn blackboard_value(&self) -> BlackboardValueOwned {
        match &self.blackboard_value {
            BlackboardValue::Literal(s) => BlackboardValueOwned::Literal(s.clone()),
            BlackboardValue::Ref(s) => BlackboardValueOwned::Ref(s.to_string()),
        }
    }
}

impl<'src> AbstractPortMap<'src> for PortMapOwned {
    fn get_type(&self) -> PortType {
        self.ty
    }

    fn node_port(&self) -> &str {
        &self.node_port
    }

    fn blackboard_value(&self) -> BlackboardValueOwned {
        self.blackboard_value.clone()
    }
}