bach 0.1.2

Discrete-event simulation environment for async workflows
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

use super::{CloseError, PopError, PushError, Pushable};
use crate::tracing::{info_span, Span};
use alloc::borrow::Cow;
use core::{fmt, ops};
use std::task::Context;

pub struct Queue<Q> {
    #[cfg_attr(not(feature = "tracing"), allow(dead_code))]
    name: Cow<'static, str>,
    inner: Q,
}

impl<Q: Default> Default for Queue<Q> {
    fn default() -> Self {
        let name = "";
        let inner = Q::default();
        Self {
            name: Cow::Borrowed(name),
            inner,
        }
    }
}

impl<Q: fmt::Debug> fmt::Debug for Queue<Q> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.inner.fmt(f)
    }
}

impl<Q> ops::Deref for Queue<Q> {
    type Target = Q;

    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}

impl<Q> ops::DerefMut for Queue<Q> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}

impl<Q> Queue<Q> {
    pub fn new<N: Into<Cow<'static, str>>>(inner: Q, name: N) -> Self {
        Self {
            name: name.into(),
            inner,
        }
    }

    fn span(&self) -> Span {
        info_span!("queue", queue = %self.name)
    }
}

impl<T, Q> super::Queue<T> for Queue<Q>
where
    Q: super::Queue<T>,
{
    fn push_lazy(&mut self, value: &mut dyn Pushable<T>) -> Result<Option<T>, PushError> {
        self.span().in_scope(|| self.inner.push_lazy(value))
    }

    fn push_with_notify(
        &mut self,
        value: &mut dyn Pushable<T>,
        cx: &mut Context,
    ) -> Result<Option<T>, PushError> {
        self.span()
            .in_scope(|| self.inner.push_with_notify(value, cx))
    }

    fn pop(&mut self) -> Result<T, PopError> {
        self.span().in_scope(|| self.inner.pop())
    }

    fn pop_with_notify(&mut self, cx: &mut Context) -> Result<T, PopError> {
        self.span().in_scope(|| self.inner.pop_with_notify(cx))
    }

    fn close(&mut self) -> Result<(), CloseError> {
        self.span().in_scope(|| self.inner.close())
    }

    fn is_closed(&self) -> bool {
        self.span().in_scope(|| self.inner.is_closed())
    }

    fn is_empty(&self) -> bool {
        self.span().in_scope(|| self.inner.is_empty())
    }

    fn is_full(&self) -> bool {
        self.span().in_scope(|| self.inner.is_full())
    }

    fn len(&self) -> usize {
        self.span().in_scope(|| self.inner.len())
    }

    fn capacity(&self) -> Option<usize> {
        self.span().in_scope(|| self.inner.capacity())
    }
}