rs-fsring 3.1.0

A ring(like) buffer using filesystem
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
103
104
105
106
107
108
109
110

use std::path::Path;

use crate::evt::Event;
use crate::item::{Item, Name, NamedItem};
use crate::write;

/// Creates new pusher which uses closures to get/set name and write `NamedItem`.
pub fn push_new<G, S, W>(
    mut get_name: G,
    mut set_next: S,
    wtr: W,
) -> impl FnMut(Item) -> Result<(), Event>
where
    G: FnMut() -> Result<Name, Event>,
    S: FnMut(Name) -> Result<(), Event>,
    W: Fn(NamedItem) -> Result<Name, Event>,
{
    move |item: Item| {
        let name: Name = get_name()?;
        let named: NamedItem = NamedItem::new(item, name);
        match wtr(named) {
            Ok(prev) => {
                set_next(prev)?;
                Ok(())
            }
            Err(evt) => Err(evt),
        }
    }
}

fn push_new_unmanaged<G, W>(mut get_name: G, wtr: W) -> impl FnMut(Item) -> Result<(), Event>
where
    G: FnMut() -> Result<Name, Event>,
    W: Fn(NamedItem) -> Result<Name, Event>,
{
    move |item: Item| {
        let name: Name = get_name()?;
        let named: NamedItem = NamedItem::new(item, name);
        wtr(named)?;
        Ok(())
    }
}

/// Creates new unmanaged push handler which uses closures to get `Name` and write `NamedItem`.
pub fn push_handler_new_unmanaged<G, W>(get_name: G, wtr: W) -> impl FnMut(Item) -> Event
where
    G: FnMut() -> Result<Name, Event>,
    W: Fn(NamedItem) -> Result<Name, Event>,
{
    let mut f = push_new_unmanaged(get_name, wtr);
    move |i: Item| f(i).map(|_| Event::Success).unwrap_or_else(|e| e)
}

/// Creates new checked unmanaged push handler which uses default writer to write `NamedItem`.
///
/// # Arguments
/// - get_name: Gets next name.
/// - dirname:  Path to store buffer files.
/// - checksum:     Computes checksum.
pub fn push_handler_new_unmanaged_default_with_checksum<G, P, C>(
    get_name: G,
    dirname: P,
    checksum: C,
) -> impl FnMut(Item) -> Event
where
    G: FnMut() -> Result<Name, Event>,
    P: AsRef<Path>,
    C: Fn(&[u8]) -> Vec<u8>,
{
    let wtr = write::writer_checked_new_default_with_checksum(dirname, checksum);
    push_handler_new_unmanaged(get_name, wtr)
}

fn checksum_nop(_: &[u8]) -> Vec<u8> {
    vec![]
}

/// Creates new unmanaged push handler which uses default writer to write `NamedItem`.
pub fn push_handler_new_unmanaged_default<G, P>(
    get_name: G,
    dirname: P,
) -> impl FnMut(Item) -> Event
where
    G: FnMut() -> Result<Name, Event>,
    P: AsRef<Path>,
{
    push_handler_new_unmanaged_default_with_checksum(get_name, dirname, checksum_nop)
}

#[cfg(test)]
mod test_push {

    mod push_new {

        use crate::evt::Event;
        use crate::item::{Item, Name, NamedItem};

        use crate::push;

        #[test]
        fn test_no_next() {
            let get_name = || Err(Event::TooManyItemsAlready);
            let set_next = |_: Name| Ok(());
            let wtr = |i: NamedItem| Ok(i.into());
            let mut p = push::push_new(get_name, set_next, wtr);
            let r = p(Item::from(vec![]));
            assert_eq!(r, Err(Event::TooManyItemsAlready));
        }
    }
}