kutil 0.0.6

Kutil utilities collection
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

use super::{super::super::std::immutable::*, body::*};

use {
    http::response::*,
    std::{error::*, fmt},
};

//
// ResponsePieces
//

/// [Response] pieces.
///
/// Can be used to reconstruct a response, e.g. with
/// [BodyReader::new_with_first_bytes](super::super::body::BodyReader::new_with_first_bytes).
#[derive(Clone, Debug)]
pub struct ResponsePieces<ResponseBodyT> {
    /// Response.
    pub response: Response<ResponseBodyT>,

    /// First bytes.
    pub first_bytes: ImmutableBytes,
}

impl<ResponseBodyT> ResponsePieces<ResponseBodyT> {
    /// Constructor.
    pub fn new(parts: Parts, body: ResponseBodyT, first_bytes: ImmutableBytes) -> Self {
        Self { response: Response::from_parts(parts, body), first_bytes }
    }

    /// Constructor.
    pub fn new_from_body_pieces(parts: Parts, body_pieces: BodyPieces<ResponseBodyT>) -> Self {
        Self::new(parts, body_pieces.body, body_pieces.first_bytes)
    }
}

//
// ErrorWithResponsePieces
//

/// [Error] with optional [ResponsePieces].
pub struct ErrorWithResponsePieces<ErrorT, BodyT> {
    /// Error.
    pub error: ErrorT,

    /// Pieces.
    pub pieces: Option<ResponsePieces<BodyT>>,
}

impl<ErrorT, BodyT> ErrorWithResponsePieces<ErrorT, BodyT> {
    /// Constructor.
    pub fn new(error: ErrorT, pieces: Option<ResponsePieces<BodyT>>) -> Self {
        Self { error, pieces }
    }

    /// Constructor.
    pub fn new_from_body(error: ErrorWithBodyPieces<ErrorT, BodyT>, parts: Parts) -> Self {
        Self::new(error.error, error.pieces.map(|pieces| ResponsePieces::new_from_body_pieces(parts, pieces)))
    }
}

impl<ErrorT, BodyT> fmt::Debug for ErrorWithResponsePieces<ErrorT, BodyT>
where
    ErrorT: fmt::Debug,
{
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self.error, formatter)
    }
}

impl<ErrorT, BodyT> fmt::Display for ErrorWithResponsePieces<ErrorT, BodyT>
where
    ErrorT: fmt::Display,
{
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        fmt::Display::fmt(&self.error, formatter)
    }
}

impl<ErrorT, BodyT> Error for ErrorWithResponsePieces<ErrorT, BodyT>
where
    ErrorT: Error,
{
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        self.error.source()
    }
}

impl<ErrorT, BodyT> From<ErrorT> for ErrorWithResponsePieces<ErrorT, BodyT> {
    fn from(error: ErrorT) -> Self {
        Self::new(error, None)
    }
}