generalized_suffix_tree/
suffix_node.rs

1pub mod node;
2
3use crate::data::tree_item::Character;
4use crate::suffix_node::node::*;
5
6#[cfg(feature = "non_crypto_hash")]
7use fxhash::FxHashMap as HashMap;
8#[cfg(not(feature = "non_crypto_hash"))]
9use std::collections::HashMap;
10
11use std::marker::PhantomData;
12use std::fmt::{Display, Debug};
13use std::fmt;
14use std::hash::Hash;
15use std::option::Option;
16use serde::ser::{Serialize, Serializer, SerializeStruct};
17use serde::de::{self, Deserialize, Deserializer, Visitor, SeqAccess, MapAccess};
18
19
20#[derive(Debug)]
21pub struct Node<T>
22where
23    T: Display + Debug + Eq + PartialEq + Hash + Clone + PartialOrd,
24{
25    children: HashMap<Character<T>, usize>,
26    string_id: Option<usize>,
27    parent: Option<usize>,
28    edge_length: usize,
29    start: usize,
30}
31
32impl<T> Node<T>
33where
34    T: Display + Debug + Eq + PartialEq + Hash + Clone + PartialOrd,
35{
36    pub fn new(children: HashMap<Character<T>, usize>,
37                string_id: Option<usize>,
38                parent: Option<usize>,
39                edge_length: usize,
40                start: usize)->Self{
41                    Self {
42                        children,
43                        string_id,
44                        parent,
45                        edge_length,
46                        start,
47                    }
48                }
49}
50
51impl<T> SuffixNode<T> for Node<T>
52where
53    T: Display + Debug + Eq + PartialEq + Hash + Clone + PartialOrd,
54{
55
56    fn set_parent(&mut self, parent: usize){
57        self.parent = Some(parent);
58    }
59
60    fn get_parent(&self)->Option<&usize>{
61        self.parent.as_ref()
62    }
63
64
65    fn get_child(&self, child:&Character<T>)->Option<&usize>{
66        self.children.get(child)
67    }
68
69    fn get_child_mut(&mut self, child:&Character<T>)->Option<&mut usize>{
70        self.children.get_mut(child)
71    }
72    
73    fn set_child(&mut self, edge:Character<T>, child:usize){
74        self.children.insert(edge, child);
75    }
76
77    fn set_edge_length(&mut self, edge_length:usize){
78        self.edge_length = edge_length;
79    }
80
81    fn get_end(&self)->usize{
82        self.start + self.edge_length - 1        
83    }
84
85    fn get_edge_length(&self)-> usize{
86        self.edge_length
87    }
88
89    fn get_string_id(&self)->Option<&usize>{
90        self.string_id.as_ref()
91    }
92
93    fn get_start(&self)->&usize{
94        &self.start
95    }
96
97    fn set_string_id(&mut self, string_id:usize){
98        self.string_id = Some(string_id);
99    }
100
101    fn set_start(&mut self, new_start:usize){
102        self.edge_length -= new_start-self.start;
103        self.start = new_start;
104    }
105
106    fn has_children(&self)->bool{
107        !self.children.is_empty()
108    }
109
110    fn get_children(&self)->&HashMap<Character<T>, usize>{
111        &self.children
112    }
113
114    fn is_leaf(&self)->bool {
115        self.children.is_empty()
116    }
117
118}
119
120impl<T> Serialize for Node<T> 
121where
122    T: Display + Debug + Eq + PartialEq + Hash + Clone + Serialize + PartialOrd,
123{
124    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
125    where
126        S: Serializer,
127    {
128        let mut state = serializer.serialize_struct("Node", 5)?;
129        state.serialize_field("children", &self.children)?;
130        state.serialize_field("string_id", &self.string_id)?;
131        state.serialize_field("parent", &self.parent)?;
132        state.serialize_field("edge_length", &self.edge_length)?;
133        state.serialize_field("start", &self.start)?;
134        state.end()
135    }
136}
137
138impl<'de, T> Deserialize<'de> for Node<T>
139where
140    T: Display + Debug + Eq + PartialEq + PartialOrd + Hash + Clone + Serialize + Deserialize<'de>,
141{
142    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
143    where
144        D: Deserializer<'de>,
145    {
146        enum Field { Children, StringID, Parent, EdgeLength, Start }
147
148        impl<'de> Deserialize<'de> for Field {
149            fn deserialize<D>(deserializer: D) -> Result<Field, D::Error>
150            where
151                D: Deserializer<'de>,
152            {
153                struct FieldVisitor;
154
155                impl Visitor<'_> for FieldVisitor {
156                    type Value = Field;
157
158                    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
159                        formatter.write_str("`children` or `string_id` or `parent` or `edge_length` or `start`")
160                    }
161
162                    fn visit_str<E>(self, value: &str) -> Result<Field, E>
163                    where
164                        E: de::Error,
165                    {
166                        match value {
167                            "children" => Ok(Field::Children),
168                            "string_id" => Ok(Field::StringID),
169                            "parent" => Ok(Field::Parent),
170                            "edge_length" => Ok(Field::EdgeLength),
171                            "start" => Ok(Field::Start),
172                            _ => Err(de::Error::unknown_field(value, FIELDS)),
173                        }
174                    }
175                }
176
177                deserializer.deserialize_identifier(FieldVisitor)
178            }
179        }
180
181        struct DurationVisitor<K>(PhantomData<K>);
182
183        impl<'de, K> Visitor<'de> for DurationVisitor<K> 
184        where
185            K: Display + Debug + Eq + PartialEq + PartialOrd + Hash + Clone + Serialize + Deserialize<'de>
186        {
187            type Value = Node<K>;
188
189            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
190                formatter.write_str("struct Node")
191            }
192
193            fn visit_seq<V>(self, mut seq: V) -> Result<Node<K>, V::Error>
194            where
195                V: SeqAccess<'de>,
196            {
197                let children = seq.next_element()?
198                    .ok_or_else(|| de::Error::invalid_length(0, &self))?;
199                let string_id = seq.next_element()?
200                    .ok_or_else(|| de::Error::invalid_length(1, &self))?;
201                let parent = seq.next_element()?
202                    .ok_or_else(|| de::Error::invalid_length(0, &self))?;
203                let edge_length = seq.next_element()?
204                    .ok_or_else(|| de::Error::invalid_length(1, &self))?;
205                let start = seq.next_element()?
206                    .ok_or_else(|| de::Error::invalid_length(0, &self))?;                
207                Ok(Node::new(children, string_id, parent, edge_length, start))
208            }
209
210            fn visit_map<V>(self, mut map: V) -> Result<Node<K>, V::Error>
211            where
212                V: MapAccess<'de>,
213            {
214                let mut children = None;
215                let mut string_id = None;
216                let mut parent = None;
217                let mut edge_length = None;
218                let mut start = None;
219                while let Some(key) = map.next_key()? {
220                    match key {
221                        Field::Children => {
222                            if children.is_some() {
223                                return Err(de::Error::duplicate_field("children"));
224                            }
225                            children = Some(map.next_value()?);
226                        }
227                        Field::StringID => {
228                            if string_id.is_some() {
229                                return Err(de::Error::duplicate_field("string_id"));
230                            }
231                            string_id = Some(map.next_value()?);
232                        }
233                        Field::Parent => {
234                            if parent.is_some() {
235                                return Err(de::Error::duplicate_field("parent"));
236                            }
237                            parent = Some(map.next_value()?);
238                        }
239                        Field::EdgeLength => {
240                            if edge_length.is_some() {
241                                return Err(de::Error::duplicate_field("edge_length"));
242                            }
243                            edge_length = Some(map.next_value()?);
244                        }
245                        Field::Start => {
246                            if start.is_some() {
247                                return Err(de::Error::duplicate_field("start"));
248                            }
249                            start = Some(map.next_value()?);
250                        }
251                    }
252                }
253                let children = children.ok_or_else(|| de::Error::missing_field("children"))?;
254                let string_id = string_id.ok_or_else(|| de::Error::missing_field("string_id"))?;
255                let parent = parent.ok_or_else(|| de::Error::missing_field("parent"))?;
256                let edge_length = edge_length.ok_or_else(|| de::Error::missing_field("edge_length"))?;
257                let start = start.ok_or_else(|| de::Error::missing_field("start"))?;
258                Ok(Node::new(children, string_id, parent, edge_length, start))
259            }
260        }
261
262        const FIELDS: &[&str] = &["children", "string_id", "parent", "edge_length", "start"];
263        deserializer.deserialize_struct("Node", FIELDS, DurationVisitor::<T>(PhantomData::<T>))
264    }
265}
generalized_suffix_tree/suffix_node.rs

generalized_suffix_tree/
suffix_node.rs
