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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

use serde::de::IntoDeserializer;

use super::Error;
use super::parse::{Multipart, Next, Part};

pub(crate) struct MultipartDesrializer<'de> {
    parsed: Multipart<'de>,
}

impl<'de> MultipartDesrializer<'de> {
    pub(crate) fn new(input: &'de [u8]) -> Result<Self, Error> {
        Ok(Self {
            parsed: Multipart::parse(input)?,
        })
    }
}

impl<'de> serde::de::Deserializer<'de> for &mut MultipartDesrializer<'de> {
    type Error = Error;

    fn deserialize_struct<V>(
        self,
        _name: &'static str,
        _fields: &'static [&'static str],
        visitor: V,
    ) -> Result<V::Value, Self::Error>
    where
        V: serde::de::Visitor<'de>,
    {
        self.deserialize_map(visitor)
    }
    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: serde::de::Visitor<'de>,
    {
        visitor.visit_map(self)
    }

    fn deserialize_newtype_struct<V>(
        self,
        _name: &'static str,
        visitor: V,
    ) -> Result<V::Value, Self::Error>
    where
        V: serde::de::Visitor<'de>,
    {
        visitor.visit_newtype_struct(self)
    }

    serde::forward_to_deserialize_any! {
        bool str string char
        unit unit_struct
        tuple tuple_struct
        bytes byte_buf
        option enum seq identifier
        ignored_any
        i8 i16 i32 i64
        u8 u16 u32 u64
        f32 f64
    }
    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: serde::de::Visitor<'de>,
    {
        self.deserialize_map(visitor)
    }
}

impl<'de> serde::de::MapAccess<'de> for &mut MultipartDesrializer<'de> {
    type Error = Error;

    fn next_entry_seed<K, V>(
        &mut self,
        kseed: K,
        vseed: V,
    ) -> Result<Option<(K::Value, V::Value)>, Self::Error>
    where
        K: serde::de::DeserializeSeed<'de>,
        V: serde::de::DeserializeSeed<'de>,
    {
        match self.parsed.next() {
            Some(Next { name, item }) => Ok(Some((
                kseed.deserialize(name.into_deserializer())?,
                vseed.deserialize(item.into_deserializer())?,
            ))),
            None => Ok(None),
        }
    }

    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
    where
        K: serde::de::DeserializeSeed<'de>,
    {
        let Some(part) = self.parsed.peek() else {
            return Ok(None);
        };
        let name = match part {
            Part::File { name, .. } => name,
            Part::Text { name, .. } => name,
        };
        seed.deserialize(name.into_deserializer()).map(Some)
    }
    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
    where
        V: serde::de::DeserializeSeed<'de>,
    {
        let Next { item, .. } = self.parsed.next().unwrap();
        seed.deserialize(item.into_deserializer())
    }
}