mach-core 0.1.1

Mach Data Framework Core.
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
94
95
96
97
98
99
100
101
102
103
104

use serde::{Deserialize, Serialize};
use crate::dag::Visitor;


///
/// MachNode.
/// This is where data is referenced/owned as relational to other data.
/// Nodes are meant to be as small as possible. They are used for relationships, not actual data.
///
#[derive(Debug, Serialize, Deserialize)]
pub struct MachNode {
    /// Name of this node - does not have to be unique to the graph.
    pub name: String,

    /// Parent index within graph. Same as 'index' means no parent.
    pub parent: u32,

    /// Index of this node within graph.
    pub index: u32,

    /// Children of this node.
    pub children: Vec<u32>,

    /// Index of components in data store (not owned by graph).
    pub components: Vec<u32>,
}


///
/// Default implementation.
/// 
impl Default for MachNode {
    fn default() -> Self {
        Self {
            name: String::from("root"),
            parent: 0,
            index: 0,
            children: Vec::new(),
            components: Vec::new()
        }
    }
}


///
/// Implementation for MachNode.
/// 
impl MachNode {
    /// New mach node with name.
    pub fn new(name: String) -> Self {
        Self {
            name: name,
            ..Default::default()
        }
    }


    /// Has parent?
    pub fn has_parent(&self) -> bool {
        self.index != self.parent
    }


    /// Has children?
    pub fn has_children(&self) -> bool {
        self.children.len() > 0
    }


    /// Has components?
    pub fn has_components(&self) -> bool {
        self.components.len() > 0
    }


    /**********************************************************
     * Visitors
     **********************************************************/

    /// Accept a visitor.
    pub fn accept(&self, visitor: &impl Visitor) {
        visitor.visit(self);
    }


    /// Accept a visitor mutable.
    pub fn accept_mut(&mut self, visitor: &mut impl Visitor) {
        visitor.visit_mut(self);
    }
}


///
/// From a parent.
/// 
impl From<(String, u32)> for MachNode {
    fn from((name, parent): (String, u32)) -> Self {
        Self {
            name: name,
            parent: parent,
            ..Default::default()
        }
    }
}