predawn-core 0.9.0

Core types and traits for predawn
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

use std::{
    collections::{BTreeMap, BTreeSet},
    error::Error,
    fmt,
};

use http::StatusCode;

use crate::{
    error::BoxError,
    error_ext::{ErrorExt, NextError},
    location::Location,
    openapi::{self, merge_responses, Schema},
    response::Response,
    response_error::ResponseError,
};

#[derive(Debug)]
pub enum Either<L, R> {
    Left(L),
    Right(R),
}

impl<L, R> fmt::Display for Either<L, R>
where
    L: fmt::Display,
    R: fmt::Display,
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Either::Left(l) => fmt::Display::fmt(l, f),
            Either::Right(r) => fmt::Display::fmt(r, f),
        }
    }
}

impl<L, R> Error for Either<L, R>
where
    L: Error,
    R: Error,
{
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        match self {
            Either::Left(l) => l.source(),
            Either::Right(r) => r.source(),
        }
    }
}

impl<L, R> ErrorExt for Either<L, R>
where
    L: ErrorExt,
    R: ErrorExt,
{
    fn entry(&self) -> (Location, NextError<'_>) {
        match self {
            Either::Left(l) => l.entry(),
            Either::Right(r) => r.entry(),
        }
    }
}

impl<L, R> ResponseError for Either<L, R>
where
    L: ResponseError,
    R: ResponseError,
{
    fn as_status(&self) -> StatusCode {
        match self {
            Either::Left(l) => l.as_status(),
            Either::Right(r) => r.as_status(),
        }
    }

    fn status_codes(codes: &mut BTreeSet<StatusCode>) {
        L::status_codes(codes);
        R::status_codes(codes);
    }

    fn as_response(&self) -> Response {
        match self {
            Either::Left(l) => l.as_response(),
            Either::Right(r) => r.as_response(),
        }
    }

    fn responses(
        schemas: &mut BTreeMap<String, Schema>,
        schemas_in_progress: &mut Vec<String>,
    ) -> BTreeMap<StatusCode, openapi::Response> {
        let mut responses = L::responses(schemas, schemas_in_progress);
        merge_responses(&mut responses, R::responses(schemas, schemas_in_progress));
        responses
    }

    #[doc(hidden)]
    fn inner(self) -> BoxError {
        match self {
            Either::Left(l) => l.inner(),
            Either::Right(r) => r.inner(),
        }
    }
}