urcu2 0.1.3

Safe API to liburcu
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

use std::marker::PhantomData;

pub struct RcuContextBuilder<F, const READ: bool = false, const DEFER: bool = false>(
    PhantomData<F>,
);

impl<F, const READ: bool, const DEFER: bool> RcuContextBuilder<F, READ, DEFER> {
    pub fn new() -> RcuContextBuilder<F> {
        RcuContextBuilder::<F, false, false>(PhantomData)
    }
}

impl<F, const DEFER: bool> RcuContextBuilder<F, false, DEFER> {
    pub fn with_read_context(self) -> RcuContextBuilder<F, true, DEFER> {
        RcuContextBuilder::<F, true, DEFER>(PhantomData)
    }
}

impl<F, const READ: bool> RcuContextBuilder<F, READ, false> {
    pub fn with_defer_context(self) -> RcuContextBuilder<F, READ, true> {
        RcuContextBuilder::<F, READ, true>(PhantomData)
    }
}

#[cfg(feature = "flavor-bp")]
mod bp {
    use super::*;

    use crate::rcu::context::RcuContextBp;
    use crate::rcu::flavor::RcuFlavorBp;

    impl<const READ: bool, const DEFER: bool> RcuContextBuilder<RcuFlavorBp, READ, DEFER> {
        pub fn register_thread(self) -> Option<RcuContextBp<READ, DEFER>> {
            RcuContextBp::<READ, DEFER>::new()
        }
    }
}

#[cfg(feature = "flavor-mb")]
mod mb {
    use super::*;

    use crate::rcu::context::RcuContextMb;
    use crate::rcu::flavor::RcuFlavorMb;

    impl<const READ: bool, const DEFER: bool> RcuContextBuilder<RcuFlavorMb, READ, DEFER> {
        pub fn register_thread(self) -> Option<RcuContextMb<READ, DEFER>> {
            RcuContextMb::<READ, DEFER>::new()
        }
    }
}

#[cfg(feature = "flavor-memb")]
mod memb {
    use super::*;

    use crate::rcu::context::RcuContextMemb;
    use crate::rcu::flavor::RcuFlavorMemb;

    impl<const READ: bool, const DEFER: bool> RcuContextBuilder<RcuFlavorMemb, READ, DEFER> {
        pub fn register_thread(self) -> Option<RcuContextMemb<READ, DEFER>> {
            RcuContextMemb::<READ, DEFER>::new()
        }
    }
}

#[cfg(feature = "flavor-qsbr")]
mod qsbr {
    use super::*;

    use crate::rcu::context::RcuContextQsbr;
    use crate::rcu::flavor::RcuFlavorQsbr;

    impl<const READ: bool, const DEFER: bool> RcuContextBuilder<RcuFlavorQsbr, READ, DEFER> {
        pub fn register_thread(self) -> Option<RcuContextQsbr<READ, DEFER>> {
            RcuContextQsbr::<READ, DEFER>::new()
        }
    }
}