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

pub mod compose;
pub mod del;
pub mod empty;
pub mod evt;
pub mod full;
pub mod integer;
pub mod item;
pub mod list;
pub mod next;
pub mod push;
pub mod read;
pub mod request;
pub mod u;
pub mod write;

use crate::evt::Event;
use crate::request::Request;

use crate::item::{Item, Name};

/// An interface for creating request handler.
pub trait RingBuffer {
    fn handle(&mut self, req: Request) -> Event;
}

/// Creates new request handler.
pub fn ring_buffer_new<R>(mut r: R) -> impl FnMut(Request) -> Event
where
    R: RingBuffer,
{
    move |req: Request| r.handle(req)
}

/// Helper struct for creating request handler.
pub struct FsRingBuffer<G, D, P, L> {
    pub get: G,
    pub del: D,
    pub push: P,
    pub list: L,
}

impl<G, D, P, L> FsRingBuffer<G, D, P, L>
where
    G: Fn(Name) -> Event,
    D: Fn(Name) -> Event,
    P: FnMut(Item) -> Event,
    L: Fn() -> Event,
{
    fn handle_get(&mut self, name: Name) -> Event {
        (self.get)(name)
    }

    fn handle_del(&mut self, name: Name) -> Event {
        (self.del)(name)
    }

    fn handle_push(&mut self, item: Item) -> Event {
        (self.push)(item)
    }

    fn handle_list(&mut self) -> Event {
        (self.list)()
    }
}

impl<G, D, P, L> RingBuffer for FsRingBuffer<G, D, P, L>
where
    G: Fn(Name) -> Event,
    D: Fn(Name) -> Event,
    P: FnMut(Item) -> Event,
    L: Fn() -> Event,
{
    fn handle(&mut self, req: Request) -> Event {
        match req {
            Request::Get(name) => self.handle_get(name),
            Request::Del(name) => self.handle_del(name),
            Request::Push(item) => self.handle_push(item),
            Request::List => self.handle_list(),
        }
    }
}