floria 0.0.5

Floria data system for cloud orchestration
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

use super::{
    super::{data::*, entities::*},
    errors::*,
};

//
// Store
//

/// Thread-safe access to a Floria store.
///
/// Implementations should ensure that cloning is cheap and clones always refer to the same shared
/// state.
pub trait Store {
    /// Create ID.
    fn create_id(&self, id: &mut ID) -> Result<(), StoreError>;

    /// Get class.
    fn get_class(&self, id: &ID) -> Result<Option<Class>, StoreError>;

    /// Add class.
    fn add_class(&self, class: Class) -> Result<(), StoreError>;

    /// Get vertex template.
    fn get_vertex_template(&self, id: &ID) -> Result<Option<VertexTemplate>, StoreError>;

    /// Add vertex template.
    ///
    /// Checks to make sure we aren't creating infinite nesting.
    fn add_vertex_template(&self, vertex_template: VertexTemplate) -> Result<(), StoreError>;

    /// Get edge template.
    fn get_edge_template(&self, id: &ID) -> Result<Option<EdgeTemplate>, StoreError>;

    /// Add edge template.
    fn add_edge_template(&self, edge_template: EdgeTemplate) -> Result<(), StoreError>;

    /// Get vertex.
    fn get_vertex(&self, id: &ID) -> Result<Option<Vertex>, StoreError>;

    /// Get vertexes.
    fn get_vertexes(&self, directories: Option<Vec<Directory>>) -> Result<Vec<Vertex>, StoreError>;

    /// Add vertex.
    fn add_vertex(&self, vertex: Vertex) -> Result<(), StoreError>;

    /// Get edge.
    fn get_edge(&self, id: &ID) -> Result<Option<Edge>, StoreError>;

    /// Add edge.
    fn add_edge(&self, edge: Edge) -> Result<(), StoreError>;
}

//
// StoreUtilities
//

/// Utilities for [Store].
pub trait StoreUtilities {
    /// Get entity as expression.
    fn get_entity_as_expression(&self, id: &ID) -> Result<Option<Expression>, StoreError>;
}

impl<StoreT> StoreUtilities for StoreT
where
    StoreT: Store,
{
    fn get_entity_as_expression(&self, id: &ID) -> Result<Option<Expression>, StoreError> {
        let variant = match id.kind {
            EntityKind::Class => self.get_class(&id)?.map(|class| Ok(class.into())),
            EntityKind::VertexTemplate => {
                self.get_vertex_template(&id)?.map(|vertex_template| vertex_template.into_expression(false, self))
            }
            EntityKind::EdgeTemplate => {
                self.get_edge_template(&id)?.map(|edge_template| edge_template.into_expression(false, self))
            }
            EntityKind::Vertex => self.get_vertex(&id)?.map(|vertex| vertex.into_expression(false, self)),
            EntityKind::Edge => self.get_edge(&id)?.map(|edge| edge.into_expression(false, self)),
        };

        Ok(match variant {
            Some(variant) => Some(variant?),
            None => None,
        })
    }
}