adblock 0.12.2

Native Rust module for Adblock Plus syntax (e.g. EasyList, EasyPrivacy) filter parsing and matching.
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

/// A HashMap implementation backed by a HashIndex.
/// Uses more memory than FlatMap, but gives faster lookup.
use crate::flatbuffers::containers::{
    fb_index::FbIndex,
    flat_serialize::{FlatBuilder, FlatMapBuilderOutput, FlatSerialize},
    hash_index::{FbHashKey, HashIndexBuilder, HashIndexView, HashKey},
};

/// A builder for a HashMap that can be serialized into a flatbuffer.
/// A default key is used to mark empty slots, so (default_key, _) pair
/// can't be added.
#[derive(Default)]
pub(crate) struct HashMapBuilder<I: HashKey, V: Default + Clone> {
    builder: HashIndexBuilder<I, V>,
}

impl<I: HashKey, V: Default + Clone> HashMapBuilder<I, V> {
    #[allow(unused)]
    pub fn insert(&mut self, key: I, value: V) {
        self.builder.insert(key, value, false /* allow_duplicate */);
    }

    pub fn get_or_insert(&mut self, key: I, value: V) -> &mut V {
        self.builder.get_or_insert(key, value)
    }

    pub fn finish<'b, B: FlatBuilder<'b>>(
        value: Self,
        builder: &mut B,
    ) -> FlatMapBuilderOutput<'b, I, V, B>
    where
        I: FlatSerialize<'b, B>,
        V: FlatSerialize<'b, B>,
    {
        let (indexes, values) = HashIndexBuilder::consume(value.builder);

        let keys = indexes
            .into_iter()
            .map(|i| FlatSerialize::serialize(i, builder))
            .collect::<Vec<_>>();
        let values = values
            .into_iter()
            .map(|v| FlatSerialize::serialize(v, builder))
            .collect::<Vec<_>>();

        let keys = builder.raw_builder().create_vector(&keys);
        let values = builder.raw_builder().create_vector(&values);

        FlatMapBuilderOutput { keys, values }
    }
}

/// A view of a HashMap stored in a flatbuffer.
/// The default key is considered as an empty slot, `get(default_key)` always
/// returns None.
pub(crate) struct HashMapView<I, V, Keys, Values>
where
    I: FbHashKey,
    Keys: FbIndex<I>,
    Values: FbIndex<V>,
{
    view: HashIndexView<I, V, Keys, Values>,
}

impl<I, V, Keys, Values> HashMapView<I, V, Keys, Values>
where
    I: FbHashKey,
    Keys: FbIndex<I>,
    Values: FbIndex<V>,
{
    pub fn new(keys: Keys, values: Values) -> Self {
        assert_eq!(keys.len(), values.len());
        Self {
            view: HashIndexView::new(keys, values),
        }
    }

    pub fn get(&self, key: I) -> Option<V> {
        self.view.get_single(key)
    }

    #[cfg(test)]
    pub fn capacity(&self) -> usize {
        self.view.capacity()
    }

    #[cfg(test)]
    pub fn len(&self) -> usize {
        self.view.len()
    }
}

pub type HashMapStringView<'a, V> = HashMapView<
    &'a str,
    V,
    flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>,
    flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<<V as flatbuffers::Follow<'a>>::Inner>>,
>;

#[cfg(test)]
#[path = "../../../tests/unit/flatbuffers/containers/hash_map.rs"]
mod unit_tests;