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
118
use std::collections::hash_map::{self, Entry, HashMap};
use std::ops::Index;
#[doc(inline)]
pub use crate::query_params::values::Values;
pub mod values;
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct QueryParams(HashMap<String, Values>);
impl QueryParams {
#[inline]
pub fn new() -> QueryParams {
QueryParams::default()
}
pub fn insert<T, U>(&mut self, key: T, value: U)
where
T: Into<String>,
U: Into<String>,
{
self.0
.entry(key.into())
.or_insert_with(Values::new)
.push(value)
}
pub fn insert_all<T, U, I>(&mut self, key: T, values: I)
where
T: Into<String>,
U: Into<String>,
I: IntoIterator<Item = U>,
{
match self.0.entry(key.into()) {
Entry::Occupied(mut e) => e.get_mut().extend(values),
Entry::Vacant(e) => {
let mut new = Values::new();
new.extend(values);
if !new.is_empty() {
e.insert(new);
}
}
}
}
#[inline]
pub fn iter(&self) -> Iter<'_> {
Iter(self.0.iter())
}
}
impl<'a> IntoIterator for &'a QueryParams {
type IntoIter = Iter<'a>;
type Item = (&'a str, &'a Values);
#[inline]
fn into_iter(self) -> Iter<'a> {
self.iter()
}
}
impl<'a> Index<&'a str> for QueryParams {
type Output = Values;
#[inline]
fn index(&self, key: &'a str) -> &Values {
self.0.get(key).unwrap_or_else(|| &*values::EMPTY)
}
}
pub struct Iter<'a>(hash_map::Iter<'a, String, Values>);
impl<'a> Iterator for Iter<'a> {
type Item = (&'a str, &'a Values);
#[inline]
fn next(&mut self) -> Option<(&'a str, &'a Values)> {
self.0.next().map(|v| (&**v.0, v.1))
}
#[inline]
fn size_hint(&self) -> (usize, Option<usize>) {
self.0.size_hint()
}
}
impl<'a> ExactSizeIterator for Iter<'a> {
#[inline]
fn len(&self) -> usize {
self.0.len()
}
}