csf 0.1.14

The library of compressed static functions (maps) that use perfect hashing and value compression.
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

use crate::fp::OptimalLevelSize;
use ph::BuildDefaultSeededHasher;
use ph::fmph::{GOConf, GroupSize, SeedSize, TwoToPowerBitsStatic};
use crate::coding::BuildMinimumRedundancy;

/// Configuration accepted by [`fp::GOCMap`](crate::fp::GOCMap) constructors.
#[derive(Clone)]
pub struct GOCMapConf<
    BC = BuildMinimumRedundancy,
    LSC = OptimalLevelSize,
    GS: GroupSize = TwoToPowerBitsStatic::<4>, SS: SeedSize = TwoToPowerBitsStatic<2>, S = BuildDefaultSeededHasher
> {
    pub coding: BC,
    /// Configuration of family of (group-optimized) hash functions (default: [`GOConf::default`]).
    pub goconf: GOConf<GS, SS, S>,
    /// Chooses the size of level for the given level input.
    pub level_size_chooser: LSC,
}

impl Default for GOCMapConf {
    fn default() -> Self { Self {
        coding: Default::default(),
        goconf: Default::default(),
        level_size_chooser: Default::default(),
    } }
}

impl GOCMapConf {
    pub fn bpf(bits_per_fragment: u8) -> Self {
        Self::coding(BuildMinimumRedundancy { bits_per_fragment })
    }
}

impl<BC> GOCMapConf<BC, OptimalLevelSize, TwoToPowerBitsStatic::<4>, TwoToPowerBitsStatic<2>, BuildDefaultSeededHasher> {
    pub fn coding(coding: BC) -> Self {
        Self {
            coding,
            goconf: Default::default(),
            level_size_chooser: Default::default(),
        }
    }
}

impl<GS: GroupSize, SS: SeedSize, S> GOCMapConf<BuildMinimumRedundancy, OptimalLevelSize, GS, SS, S> {
    pub fn groups(goconf: GOConf<GS, SS, S>) -> Self {
        Self {
            coding: Default::default(),
            goconf,
            level_size_chooser: Default::default(),
        }
    }
}

impl<GS: GroupSize, SS: SeedSize, S> From<GOConf<GS, SS, S>> for GOCMapConf<BuildMinimumRedundancy, OptimalLevelSize, GS, SS, S> {
    #[inline] fn from(value: GOConf<GS, SS, S>) -> Self {
        Self::groups(value)
    }
}

impl<BC, GS: GroupSize, SS: SeedSize, S> GOCMapConf<BC, OptimalLevelSize, GS, SS, S> {
    pub fn groups_coding(goconf: GOConf<GS, SS, S>, coding: BC) -> Self {
        Self {
            coding,
            goconf,
            level_size_chooser: Default::default(),
        }
    }
}

impl<BC, LSC> GOCMapConf<BC, LSC, TwoToPowerBitsStatic::<4>, TwoToPowerBitsStatic<2>, BuildDefaultSeededHasher> {
    pub fn lsize_coding(level_size_chooser: LSC, coding: BC) -> Self {
        Self {
            coding,
            goconf: Default::default(),
            level_size_chooser,
        }
    }
}

impl<LSC> GOCMapConf<BuildMinimumRedundancy, LSC, TwoToPowerBitsStatic::<4>, TwoToPowerBitsStatic<2>, BuildDefaultSeededHasher> {
    pub fn lsize(level_size_chooser: LSC) -> Self {
        Self::lsize_coding(level_size_chooser, BuildMinimumRedundancy::default())
    }
}

impl<BC, LSC, GS: GroupSize, SS: SeedSize, S> GOCMapConf<BC, LSC, GS, SS, S> {
    pub fn groups_lsize_coding(goconf: GOConf<GS, SS, S>, level_size_chooser: LSC, coding: BC) -> Self {
        Self { coding, goconf, level_size_chooser }
    }
}