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, iter, marker::PhantomData};

use http::{header::GetAll, HeaderName};
use serde::{
    de,
    ser::{self, SerializeSeq},
    Deserialize, Deserializer, Serialize, Serializer,
};

use super::{BorrowedNameWrapper, Either};

type Type<T> = http::HeaderMap<T>;
const EXPECT_MESSAGE: &str = "a header map";

struct GetAllWrapper<'a, T: Serialize>(GetAll<'a, T>);

impl<'a, T: Serialize> Serialize for GetAllWrapper<'a, T> {
    fn serialize<S: Serializer>(&self, ser: S) -> Result<S::Ok, S::Error> {
        let mut iter = self.0.iter();
        if let Some(first) = iter.next() {
            if iter.next().is_none() {
                if ser.is_human_readable() {
                    return first.serialize(ser);
                } else {
                    return ser.collect_seq(iter::once(first));
                }
            };

            let count = iter.count() + 2;
            let mut seq = ser.serialize_seq(Some(count))?;
            for v in self.0.iter() {
                seq.serialize_element(v)?;
            }
            seq.end()
        } else {
            Err(ser::Error::custom("header has no values"))
        }
    }
}

pub fn serialize<S, T>(headers: &Type<T>, ser: S) -> Result<S::Ok, S::Error>
where
    S: Serializer,
    T: Serialize,
{
    ser.collect_map(
        headers
            .keys()
            .map(|k| (BorrowedNameWrapper(k), GetAllWrapper(headers.get_all(k)))),
    )
}

#[derive(Deserialize)]
struct NameWrapper(#[serde(with = "crate::header_name")] HeaderName);

struct Visitor<T>
where
    T: for<'a> Deserialize<'a>,
{
    is_human_readable: bool,
    _ph: PhantomData<T>,
}

impl<'de, T> de::Visitor<'de> for Visitor<T>
where
    T: for<'a> Deserialize<'a>,
{
    type Value = Type<T>;

    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str(EXPECT_MESSAGE)
    }

    fn visit_map<M>(self, mut access: M) -> Result<Self::Value, M::Error>
    where
        M: de::MapAccess<'de>,
    {
        let mut map = Type::<T>::with_capacity(access.size_hint().unwrap_or_default());

        if self.is_human_readable {
            while let Some((key, val)) = access.next_entry::<NameWrapper, Either<T>>()? {
                match val {
                    Either::One(val) => {
                        map.insert(key.0, val);
                    }
                    Either::Many(arr) => {
                        for val in arr {
                            map.append(&key.0, val);
                        }
                    }
                };
            }
        } else {
            while let Some((key, arr)) = access.next_entry::<NameWrapper, Vec<T>>()? {
                for val in arr {
                    map.append(&key.0, val);
                }
            }
        }

        Ok(map)
    }
}

pub fn deserialize<'de, D, T>(de: D) -> Result<Type<T>, D::Error>
where
    D: Deserializer<'de>,
    T: for<'a> Deserialize<'a>,
{
    let is_human_readable = de.is_human_readable();
    de.deserialize_map(Visitor::<T> {
        is_human_readable,
        _ph: PhantomData,
    })
}

derive_extension_types!(super::Type<T>, T);