s2n-quic-core 0.81.0

Internal crate used by s2n-quic
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
111
112
113
114
115

// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0

use super::{
    info::{self, Info},
    Metric,
};

pub trait Recorder: 'static + Send + Sync {
    fn record<T: Metric>(&self, info: &'static Info, value: T);
}

pub trait BoolRecorder: 'static + Send + Sync {
    fn record(&self, info: &'static Info, value: bool);
}

pub trait NominalRecorder: 'static + Send + Sync {
    fn record<T: Metric>(&self, info: &'static Info, variant: &'static info::Variant, value: T);
}

macro_rules! impl_recorder {
    ($trait:ident $(, $extra_param:ident: $extra_type:ty)?) => {
        impl<A, B> $trait for (A, B)
        where
            A: $trait,
            B: $trait,
        {
            #[inline]
            fn record<T: Metric>(&self, info: &'static Info, $($extra_param: $extra_type,)? value: T) {
                self.0.record(info, $($extra_param,)? value);
                self.1.record(info, $($extra_param,)? value);
            }
        }

        impl<R> $trait for Option<R>
        where
            R: $trait,
        {
            #[inline]
            fn record<T: Metric>(&self, info: &'static Info, $($extra_param: $extra_type,)? value: T) {
                if let Some(recorder) = self {
                    recorder.record(info, $($extra_param,)? value);
                }
            }
        }

        #[cfg(target_has_atomic = "64")]
        impl $trait for core::sync::atomic::AtomicU64 {
            #[inline]
            fn record<T: Metric>(&self, _info: &'static Info, $($extra_param: $extra_type,)? value: T) {
                self.fetch_add(value.as_u64(), core::sync::atomic::Ordering::Relaxed);
                $(let _ = $extra_param;)?
            }
        }

        #[cfg(feature = "alloc")]
        impl<R> $trait for alloc::sync::Arc<R>
        where
            R: $trait,
        {
            #[inline]
            fn record<T: Metric>(&self, info: &'static Info, $($extra_param: $extra_type,)? value: T) {
                self.as_ref().record(info, $($extra_param,)? value );
            }
        }
    };
}

impl_recorder!(Recorder);
impl_recorder!(NominalRecorder, variant: &'static info::Variant);

impl<A, B> BoolRecorder for (A, B)
where
    A: BoolRecorder,
    B: BoolRecorder,
{
    #[inline]
    fn record(&self, info: &'static Info, value: bool) {
        self.0.record(info, value);
        self.1.record(info, value);
    }
}

impl<A> BoolRecorder for Option<A>
where
    A: BoolRecorder,
{
    #[inline]
    fn record(&self, info: &'static Info, value: bool) {
        if let Some(recorder) = self {
            recorder.record(info, value);
        }
    }
}

#[cfg(target_has_atomic = "64")]
impl BoolRecorder for core::sync::atomic::AtomicU64 {
    #[inline]
    fn record(&self, _info: &'static Info, value: bool) {
        if value {
            self.fetch_add(1, core::sync::atomic::Ordering::Relaxed);
        }
    }
}

#[cfg(feature = "alloc")]
impl<R> BoolRecorder for alloc::sync::Arc<R>
where
    R: BoolRecorder,
{
    #[inline]
    fn record(&self, info: &'static Info, value: bool) {
        self.as_ref().record(info, value);
    }
}