ohkami_lib 0.24.9

internal library for Ohkami - A performant, declarative, and runtime-flexible web framework for Rust
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

mod de;
mod ser;

#[cfg(test)]
mod _test;

#[inline]
pub fn to_string(value: &impl serde::Serialize) -> Result<String, Error> {
    let mut s = ser::URLEncodedSerializer::new();
    value.serialize(&mut s)?;
    Ok(s.output())
}

#[inline(always)]
pub fn from_bytes<'de, D: serde::Deserialize<'de>>(input: &'de [u8]) -> Result<D, Error> {
    let mut d = de::URLEncodedDeserializer::new(input);
    let t = D::deserialize(&mut d)?;
    d.remaining().is_empty().then_some(t).ok_or_else(|| {
        serde::de::Error::custom(format!(
            "Unexpected trailing charactors: `{}`",
            d.remaining().escape_ascii()
        ))
    })
}

#[derive(Debug)]
pub struct Error(String);
const _: () = {
    impl std::fmt::Display for Error {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            f.write_str(&self.0)
        }
    }
    impl std::error::Error for Error {}

    impl serde::ser::Error for Error {
        fn custom<T>(msg: T) -> Self
        where
            T: std::fmt::Display,
        {
            Self(msg.to_string())
        }
    }
    impl serde::de::Error for Error {
        fn custom<T>(msg: T) -> Self
        where
            T: std::fmt::Display,
        {
            Self(msg.to_string())
        }
    }
};

pub(crate) enum Infallible {}
const _: () = {
    impl serde::ser::SerializeStructVariant for Infallible {
        type Ok = ();
        type Error = Error;

        fn serialize_field<T>(&mut self, _key: &'static str, _value: &T) -> Result<(), Self::Error>
        where
            T: ?Sized + serde::Serialize,
        {
            match *self {}
        }

        fn end(self) -> Result<Self::Ok, Self::Error> {
            match self {}
        }
    }

    impl serde::ser::SerializeTupleVariant for Infallible {
        type Ok = ();
        type Error = Error;

        fn serialize_field<T>(&mut self, _: &T) -> Result<(), Self::Error>
        where
            T: ?Sized + serde::Serialize,
        {
            match *self {}
        }

        fn end(self) -> Result<Self::Ok, Self::Error> {
            match self {}
        }
    }
};