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 std::{fmt, iter};

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

use crate::{header_value, BorrowedNameWrapper, Either};

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

#[derive(Serialize)]
struct BorrowedValueWrapper<'a>(#[serde(with = "crate::header_value")] &'a HeaderValue);

struct GetAllWrapper<'a>(GetAll<'a, HeaderValue>);

impl<'a> Serialize for GetAllWrapper<'a> {
    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 header_value::serialize(first, ser);
                } else {
                    return ser.collect_seq(iter::once(BorrowedValueWrapper(first)));
                }
            };

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

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

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

#[derive(Deserialize)]
struct ValueWrapper(#[serde(with = "crate::header_value")] HeaderValue);

struct Visitor {
    is_human_readable: bool,
}

impl<'de> de::Visitor<'de> for Visitor {
    type Value = Type;

    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::with_capacity(access.size_hint().unwrap_or(0));

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

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

derive_extension_types!(super::Type);