prefix-trie 0.10.1

Prefix trie (tree) datastructure (both a set and a map) that provides exact and longest-prefix matches.
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

//! Deserialization logic for rkyv

use crate::{
    joint::{JointPrefix, JointPrefixMap, JointPrefixSet},
    rkyv::{ArchivedJointPrefixMap, ArchivedJointPrefixSet, ArchivedPrefixMap, ArchivedPrefixSet},
    table::Table,
    Prefix, PrefixMap, PrefixSet,
};
use rkyv::{
    rancor::{Fallible, Source},
    Archive, Deserialize,
};

impl<P, T, D> Deserialize<PrefixMap<P, T>, D> for ArchivedPrefixMap<P, T>
where
    P: Prefix,
    T: Archive,
    T::Archived: Deserialize<T, D>,
    D: Fallible + ?Sized,
    D::Error: Source,
{
    fn deserialize(&self, d: &mut D) -> Result<PrefixMap<P, T>, D::Error> {
        let count = self.data.as_slice().len();
        let nodes = self
            .nodes
            .as_slice()
            .iter()
            .map(|n| (n.data_bitmap.to_native(), n.child_bitmap.to_native()));
        let data = self.data.as_slice().iter().map(|c| c.deserialize(d));

        let table = Table::from_bfs(nodes, data)?;
        Ok(PrefixMap::from_table_count(table, count))
    }
}

impl<P, D> Deserialize<PrefixSet<P>, D> for ArchivedPrefixSet<P>
where
    P: Prefix,
    D: Fallible + ?Sized,
    D::Error: Source,
{
    fn deserialize(&self, d: &mut D) -> Result<PrefixSet<P>, D::Error> {
        self.0.deserialize(d).map(PrefixSet)
    }
}

impl<P, T, D> Deserialize<JointPrefixMap<P, T>, D> for ArchivedJointPrefixMap<P, T>
where
    P: JointPrefix,
    T: Archive,
    T::Archived: Deserialize<T, D>,
    D: Fallible + ?Sized,
    D::Error: Source,
{
    fn deserialize(&self, d: &mut D) -> Result<JointPrefixMap<P, T>, D::Error> {
        let t1 = self.t1.deserialize(d)?;
        let t2 = self.t2.deserialize(d)?;
        Ok(JointPrefixMap { t1, t2 })
    }
}

impl<P, D> Deserialize<JointPrefixSet<P>, D> for ArchivedJointPrefixSet<P>
where
    P: JointPrefix,
    D: Fallible + ?Sized,
    D::Error: Source,
{
    fn deserialize(&self, d: &mut D) -> Result<JointPrefixSet<P>, D::Error> {
        let t1 = self.t1.deserialize(d)?;
        let t2 = self.t2.deserialize(d)?;
        Ok(JointPrefixSet { t1, t2 })
    }
}