serde_qs 1.1.1

Querystrings for Serde
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

use serde::de;

use std::fmt::{self, Display};
use std::io;
use std::num;
use std::str;
use std::string;

/// Error type for `serde_qs`.
#[derive(Debug)]
pub enum Error {
    /// Custom string-based error
    Custom(String),

    /// Maximum serialization depth exceeded
    MaxSerializationDepthExceeded(usize),

    /// Parse error at a specified position in the query string
    Parse(String, usize),

    /// Unsupported type that `serde_qs` can't serialize into a query string
    Unsupported,

    /// Error processing UTF-8 for a `String`
    FromUtf8(string::FromUtf8Error),

    /// I/O error
    Io(io::Error),

    /// Error parsing a number
    ParseInt(num::ParseIntError),

    /// Error processing UTF-8 for a `str`
    Utf8(str::Utf8Error),
}

impl Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Error::Custom(msg) => write!(f, "{}", msg),
            Error::MaxSerializationDepthExceeded(depth) => {
                write!(f, "Maximum serialization depth `{depth}` exceeded")
            }
            Error::Parse(msg, pos) => {
                write!(f, "parsing failed with error: '{msg}' at position: {pos}")
            }
            Error::Unsupported => write!(f, "unsupported type for serialization"),
            Error::FromUtf8(e) => write!(f, "{e}"),
            Error::Io(e) => write!(f, "{e}"),
            Error::ParseInt(e) => write!(f, "{e}"),
            Error::Utf8(e) => write!(f, "{e}"),
        }
    }
}

impl std::error::Error for Error {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match self {
            Error::FromUtf8(e) => Some(e),
            Error::Io(e) => Some(e),
            Error::ParseInt(e) => Some(e),
            Error::Utf8(e) => Some(e),
            _ => None,
        }
    }
}

impl From<string::FromUtf8Error> for Error {
    fn from(e: string::FromUtf8Error) -> Self {
        Error::FromUtf8(e)
    }
}

impl From<io::Error> for Error {
    fn from(e: io::Error) -> Self {
        Error::Io(e)
    }
}

impl From<num::ParseIntError> for Error {
    fn from(e: num::ParseIntError) -> Self {
        Error::ParseInt(e)
    }
}

impl From<str::Utf8Error> for Error {
    fn from(e: str::Utf8Error) -> Self {
        Error::Utf8(e)
    }
}

impl Error {
    /// Generate error to show top-level type cannot be deserialized.
    pub fn top_level(object: &'static str) -> Self {
        Error::Custom(format!(
            "cannot deserialize {object} at the top level.\
             Try deserializing into a struct.",
        ))
    }

    /// Generate a parsing error message with position.
    pub fn parse_err<T>(msg: T, position: usize) -> Self
    where
        T: Display,
    {
        Error::Parse(msg.to_string(), position)
    }

    #[cfg(feature = "debug_parsed")]
    pub fn custom<T, D: std::fmt::Debug>(msg: T, parsed: &D) -> Self
    where
        T: Display,
    {
        Error::Custom(format!("{msg}\nParsed:\n{parsed:#?}"))
    }

    #[cfg(not(feature = "debug_parsed"))]
    pub fn custom<T, D: std::fmt::Debug>(msg: T, _parsed: &D) -> Self
    where
        T: Display,
    {
        Error::Custom(msg.to_string())
    }
}

impl de::Error for Error {
    fn custom<T>(msg: T) -> Self
    where
        T: Display,
    {
        Error::Custom(msg.to_string())
    }
}

pub type Result<T, E = Error> = core::result::Result<T, E>;