querystrong 0.4.0

query-params
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

use std::{
    borrow::Cow,
    fmt::{Display, Formatter, Result},
};

/// A single segment of an [`IndexPath`](crate::IndexPath).
///
/// The lifetime `'a` reflects zero-copy borrowing: string keys that need no
/// percent-decoding are stored as `Cow::Borrowed` slices of the original input.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Indexer<'a> {
    /// A numeric index (`[42]`), used for both dense [`List`](crate::Value::List)
    /// and sparse [`SparseList`](crate::Value::SparseList) access.
    Number(usize),
    /// A string key (`[name]` or a bare first segment like `user`).
    ///
    /// Percent-encoding and `+`-as-space substitution are applied during
    /// construction; if no decoding was necessary the original borrow is preserved.
    String(Cow<'a, str>),
    /// An empty bracket (`[]`), signalling "append to the end of the list".
    Empty,
}

impl<'a> Indexer<'a> {
    pub fn into_owned(self) -> Indexer<'static> {
        match self {
            Indexer::Number(n) => Indexer::Number(n),
            Indexer::String(cow) => Indexer::String(Cow::Owned(cow.into_owned())),
            Indexer::Empty => Indexer::Empty,
        }
    }
}

impl From<usize> for Indexer<'_> {
    fn from(f: usize) -> Self {
        Self::Number(f)
    }
}

impl From<String> for Indexer<'static> {
    fn from(f: String) -> Self {
        Self::String(crate::decode(f))
    }
}

impl<'a> From<&'a String> for Indexer<'a> {
    fn from(f: &'a String) -> Self {
        Self::String(crate::decode(f))
    }
}

impl<'a> From<Cow<'a, str>> for Indexer<'a> {
    fn from(value: Cow<'a, str>) -> Self {
        Self::String(crate::decode(value))
    }
}

impl<'a> From<&'a str> for Indexer<'a> {
    fn from(f: &'a str) -> Self {
        Self::String(crate::decode(f))
    }
}

impl From<()> for Indexer<'_> {
    fn from(_: ()) -> Self {
        Self::Empty
    }
}

impl Display for Indexer<'_> {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
        match self {
            Indexer::Number(n) => f.write_str(&n.to_string()),
            Indexer::String(s) => f.write_str(&crate::encode(s)),
            Indexer::Empty => Ok(()),
        }
    }
}