nyquest-interface 0.4.0

Interface definitions for Nyquest backends
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

//! Type-erased blocking client interface traits.
//!
//! This module provides trait definitions for type-erased blocking HTTP client
//! implementations, allowing different backend implementations to be used interchangeably.
//!
//! The traits in this module are automatically implemented for types that implement the
//! corresponding traits from the `blocking::backend` module, so backend developers don't need
//! to implement them directly.

use std::any::Any;
use std::fmt;
use std::sync::Arc;

use super::backend::BlockingResponse;
use super::Request;
use crate::client::ClientOptions;
use crate::Result;

/// Trait for type-erased blocking backend implementations.
///
/// Automatically implemented for types implementing `BlockingBackend`.
pub trait AnyBlockingBackend: Send + Sync + 'static {
    /// Creates a new blocking client with the given options.
    fn create_blocking_client(&self, options: ClientOptions) -> Result<Arc<dyn AnyBlockingClient>>;
}

/// Trait for type-erased blocking HTTP clients.
///
/// Automatically implemented for types implementing `BlockingClient`.
pub trait AnyBlockingClient: Any + Send + Sync + 'static {
    /// Provides a textual description of this client.
    fn describe(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result;
    /// Sends an HTTP request and returns the response.
    fn request(&self, req: Request) -> crate::Result<Box<dyn AnyBlockingResponse>>;
}

/// Trait for type-erased blocking HTTP responses.
///
/// Automatically implemented for types implementing `BlockingResponse`.
/// It extends io::Read to allow streaming the response body.
pub trait AnyBlockingResponse: super::MaybeRead + Any + Send + Sync + 'static {
    /// Provides a textual description of this response.
    fn describe(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result;
    /// Returns the HTTP status code of this response.
    fn status(&self) -> u16;
    /// Returns the content-length of the response body, if known.
    fn content_length(&self) -> Option<u64>;
    /// Gets all values for the specified header.
    fn get_header(&self, header: &str) -> crate::Result<Vec<String>>;
    /// Reads the response body as text.
    fn text(&mut self) -> crate::Result<String>;
    /// Reads the response body as bytes.
    fn bytes(&mut self) -> crate::Result<Vec<u8>>;
}

// These implementations allow backend types implementing the base traits
// to be used with the type-erased trait system automatically.

impl<B> AnyBlockingBackend for B
where
    B: super::backend::BlockingBackend,
{
    fn create_blocking_client(&self, options: ClientOptions) -> Result<Arc<dyn AnyBlockingClient>> {
        Ok(Arc::new(self.create_blocking_client(options)?))
    }
}

impl<R> AnyBlockingResponse for R
where
    R: BlockingResponse,
{
    fn describe(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        BlockingResponse::describe(self, f)
    }

    fn status(&self) -> u16 {
        BlockingResponse::status(self)
    }

    fn content_length(&self) -> Option<u64> {
        BlockingResponse::content_length(self)
    }

    fn get_header(&self, header: &str) -> crate::Result<Vec<String>> {
        BlockingResponse::get_header(self, header)
    }

    fn text(&mut self) -> crate::Result<String> {
        BlockingResponse::text(self)
    }

    fn bytes(&mut self) -> crate::Result<Vec<u8>> {
        BlockingResponse::bytes(self)
    }
}

impl<B> AnyBlockingClient for B
where
    B: super::backend::BlockingClient,
{
    fn describe(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        super::backend::BlockingClient::describe(self, f)
    }
    fn request(&self, req: Request) -> crate::Result<Box<dyn AnyBlockingResponse>> {
        Ok(Box::new(self.request(req)?))
    }
}