fr-trie 0.0.4

Fuzzy Radix Trie
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

//! The Trie trait(s)
use std::fmt::Debug;
use std::marker::PhantomData;
use std::slice::Iter;
use serde::{Serialize, Deserialize};
use crate::node::RFRNode;
use crate::key::{TrieKey, KeyPrefix, ValueMerge};
use crate::matcher::PushdownStateMachine;


#[derive(Clone, Serialize, Deserialize)]
pub struct Trie<K, V> where
    K: KeyPrefix + Clone, V: Clone
{
    size: usize,
    node: RFRNode<K, V>,
    _phantom_k: PhantomData<K>,
    _phantom_v: PhantomData<V>,
}

impl<K: KeyPrefix + Clone, V: Clone> Trie<K, V>
{
    /// Creates new trie
    pub fn new()  -> Self {
        Self {
            size: 0,
            node: RFRNode::new(),
            _phantom_k: Default::default(),
            _phantom_v: Default::default()
        }
    }

    #[inline]
    pub fn insert(&mut self, key: K, value: V) -> Option<V>  {
        let result = self.node.insert(TrieKey::new(key), Some(value));
        if result.is_none() {
            self.size += 1;
        }
        result
    }

    #[inline]
    pub fn get<M: PushdownStateMachine + Clone>(&self, key: &K) -> Option<V>  {
        self.node.get::<M>(key)
    }

    #[inline]
    pub fn get_merge<M: PushdownStateMachine + Clone>(&self, key: &K) -> Option<V>
    where V: ValueMerge + Debug
    {
        self.node.get_merge::<M>(key)
    }

    #[inline]
    /// Inmutable slice iterator
    pub fn iter(&self) -> Iter<'_, Box<RFRNode<K, V>>> {
        self.node.children.iter()
    }

    #[inline]
    pub fn foreach<F>(&self, f: F) -> ()
        where F: Fn((usize, &K, &Option<V>))
    {
        for item in self.iter() {
            f( (1 as usize, &item.node_key.key, &item.value) );
            item.foreach(2, &f);
        }
    }
}