vertree 0.2.2

A persistent trie where each node is typed and versioned
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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

use std::sync::Arc;
use containers::{Container, Queue, Set};
use serde::{Serialize, Serializer, Deserialize, Deserializer};

#[derive(Copy, Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
pub enum NodeType {
    Directory,
    Blob,
    Queue,
    Set
}

/// A node in a hierarchical version tree
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
pub struct Node {
    pub path: String,
    pub version: u64,
    pub content: Content
}

impl Node {
    pub fn new<S>(path: S, content: Content) -> Node
        where S: Into<String>
    {
        Node {
            path: path.into(),
            version: 0,
            content: content
        }
    }

    pub fn get_type(&self) -> NodeType {
        match self.content {
            Content::Directory(_) => NodeType::Directory,
            Content::Container(Container::Blob(_)) => NodeType::Blob,
            Content::Container(Container::Queue(_)) => NodeType::Queue,
            Content::Container(Container::Set(_)) => NodeType::Set,
        }
    }
}

/// The contents of a Node
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
pub enum Content {
    Directory(Vec<Edge>),
    Container(Container)
}

impl Content {
    pub fn new(ty: NodeType) -> Content {
        match ty {
            NodeType::Directory => Content::Directory(vec![]),
            NodeType::Blob => Content::Container(Container::Blob(Vec::new())),
            NodeType::Queue => Content::Container(Container::Queue(Queue::new())),
            NodeType::Set => Content::Container(Container::Set(Set::new())),
        }
    }

    pub fn is_dir(&self) -> bool {
        if let Content::Directory(_) = *self {
            return true;
        }
        false
    }

    /// Return a reference to the blob if the content contains a blob, None otherwise
    pub fn get_blob(&self) -> Option<&[u8]> {
        if let Content::Container(Container::Blob(ref blob)) = *self {
            return Some(blob);
        }
        None
    }

    /// Return a reference to the queue if the content contains a queue, None otherwise
    pub fn get_queue(&self) -> Option<&Queue> {
        if let Content::Container(Container::Queue(ref queue)) = *self {
            return Some(queue);
        }
        None
    }

    /// Return a reference to the set if the content contains a set, None otherwise
    pub fn get_set(&self) -> Option<&Set> {
        if let Content::Container(Container::Set(ref set)) = *self {
            return Some(set);
        }
        None
    }

    pub fn get_dir_edges_mut(&mut self) -> Option<&mut Vec<Edge>> {
        if let Content::Directory(ref mut edges) = *self {
            return Some(edges);
        }
        None
    }

    /// Return a mutable reference to the queue if the content contains a queue, None otherwise
    pub fn get_queue_mut(&mut self) -> Option<&mut Queue> {
        if let Content::Container(Container::Queue(ref mut queue)) = *self {
            return Some(queue);
        }
        None
    }

    /// Return a mutable reference to the set if the content contains a set, None otherwise
    pub fn get_set_mut(&mut self) -> Option<&mut Set> {
        if let Content::Container(Container::Set(ref mut set)) = *self {
            return Some(set);
        }
        None
    }
}

/// A single entry in the contents of an interior node
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct Edge {
    pub label: String,
    pub node: Arc<Node>
}

impl Edge {
    pub fn new(label: &str, node: Node) -> Edge {
        Edge {
            label: label.to_string(),
            node: Arc::new(node)
        }
    }
}

impl Serialize for Edge {
    #[inline]
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        self.node.serialize(serializer)
    }
}

impl<'de> Deserialize<'de> for Edge {
    #[inline]
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let node = Node::deserialize(deserializer)?;
        // Parse out the label from the node path.
        let label = if let Some(pos) = node.path.rfind('/') {
            // Don't include the '/' in the label.
            node.path[pos + 1..].to_string()
        } else {
            node.path.clone()
        };

        Ok(Edge {
            label: label,
            node: Arc::new(node),
        })
    }
}