serde_prometheus 0.2.9

serde-based serializer for prometheus' text-based exposition format
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
116
117

use std::fmt::Write;
use std::{
    fmt::{Display, Formatter},
    rc::Rc,
};

/// A slight optimisation to `Cow`, which stores the "owned" version of a string as an
/// `Arc<str>` so cloning is less expensive.
#[derive(Debug, Clone, Eq)]
pub enum CowArcStr<'a> {
    Borrowed(&'a str),
    Owned(Rc<str>),
    SignedNumber(i64),
    UnsignedNumber(u64),
    Char(char),
}

impl Default for CowArcStr<'_> {
    fn default() -> Self {
        Self::Borrowed("")
    }
}

impl PartialEq for CowArcStr<'_> {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        match (self, other) {
            (CowArcStr::Borrowed(v), _) => <Self as PartialEq<&str>>::eq(other, v),
            (CowArcStr::Owned(v), _) => <Self as PartialEq<&str>>::eq(other, &v.as_ref()),
            (CowArcStr::SignedNumber(v), CowArcStr::SignedNumber(o)) => v == o,
            (CowArcStr::UnsignedNumber(v), CowArcStr::UnsignedNumber(o)) => v == o,
            (CowArcStr::SignedNumber(v), _) => {
                let mut buf = itoa::Buffer::new();
                <Self as PartialEq<&str>>::eq(other, &buf.format(*v))
            }
            (CowArcStr::UnsignedNumber(v), _) => {
                let mut buf = itoa::Buffer::new();
                <Self as PartialEq<&str>>::eq(other, &buf.format(*v))
            }
            (CowArcStr::Char(c), CowArcStr::Char(o)) => c == o,
            (CowArcStr::Char(c), _) => {
                let mut buf = [0_u8; 4];
                <Self as PartialEq<&str>>::eq(other, &&*c.encode_utf8(&mut buf))
            }
        }
    }
}

impl PartialEq<&str> for CowArcStr<'_> {
    #[inline]
    fn eq(&self, other: &&str) -> bool {
        match self {
            CowArcStr::Borrowed(v) => *v == *other,
            CowArcStr::Owned(v) => &**v == *other,
            CowArcStr::SignedNumber(v) => {
                let mut buf = itoa::Buffer::new();
                buf.format(*v) == *other
            }
            CowArcStr::UnsignedNumber(v) => {
                let mut buf = itoa::Buffer::new();
                buf.format(*v) == *other
            }
            CowArcStr::Char(c) => {
                let mut buf = [0_u8; 4];
                c.encode_utf8(&mut buf) == *other
            }
        }
    }
}

impl Display for CowArcStr<'_> {
    #[inline]
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
            CowArcStr::Borrowed(inner) => f.write_str(inner),
            CowArcStr::Owned(inner) => f.write_str(inner),
            CowArcStr::SignedNumber(inner) => inner.fmt(f),
            CowArcStr::UnsignedNumber(inner) => inner.fmt(f),
            CowArcStr::Char(inner) => f.write_char(*inner),
        }
    }
}

impl<'a> From<&'a str> for CowArcStr<'a> {
    #[inline]
    fn from(value: &'a str) -> Self {
        Self::Borrowed(value)
    }
}

impl From<String> for CowArcStr<'_> {
    #[inline]
    fn from(value: String) -> Self {
        Self::Owned(Rc::from(value))
    }
}

impl From<u64> for CowArcStr<'_> {
    #[inline]
    fn from(value: u64) -> Self {
        Self::UnsignedNumber(value)
    }
}

impl From<i64> for CowArcStr<'_> {
    #[inline]
    fn from(value: i64) -> Self {
        Self::SignedNumber(value)
    }
}

impl From<char> for CowArcStr<'_> {
    #[inline]
    fn from(value: char) -> Self {
        Self::Char(value)
    }
}