clientix-core 0.2.0

Library for building HTTP clients and requests declaratively with procedural macros - no need to write complex imperative or functional logic.
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

use bytes::Bytes;
use reqwest::blocking::Response;
use serde::de::DeserializeOwned;
use crate::client::response::{ClientixResponse, ClientixResult};

pub struct BlockingResponseHandler {
    result: ClientixResult<Response>
}

impl BlockingResponseHandler {

    pub fn new(result: ClientixResult<Response>) -> BlockingResponseHandler {
        BlockingResponseHandler { result }
    }

    pub fn text(self) -> ClientixResult<ClientixResponse<String>> {
        match self.result {
            Ok(response) => {
                Ok(ClientixResponse::new(
                    response.version(),
                    response.content_length(),
                    response.status(),
                    response.url().clone(),
                    response.remote_addr(),
                    response.headers().clone(),
                    response.text()?
                ))
            },
            Err(error) => Err(error),
        }
    }

    pub fn text_with_encoding(self, encoding: &str) -> ClientixResult<ClientixResponse<String>> {
        match self.result {
            Ok(response) => {
                Ok(ClientixResponse::new(
                    response.version(),
                    response.content_length(),
                    response.status(),
                    response.url().clone(),
                    response.remote_addr(),
                    response.headers().clone(),
                    response.text_with_charset(encoding)?
                ))
            },
            Err(error) => Err(error),
        }
    }

    pub fn bytes(self) -> ClientixResult<ClientixResponse<Bytes>> {
        match self.result {
            Ok(response) => {
                Ok(ClientixResponse::new(
                    response.version(),
                    response.content_length(),
                    response.status(),
                    response.url().clone(),
                    response.remote_addr(),
                    response.headers().clone(),
                    response.bytes()?
                ))
            },
            Err(error) => Err(error),
        }
    }

    pub fn json<T>(self) -> ClientixResult<ClientixResponse<T>> where T: DeserializeOwned + Clone {
        match self.result {
            Ok(response) => {
                Ok(ClientixResponse::new(
                    response.version(),
                    response.content_length(),
                    response.status(),
                    response.url().clone(),
                    response.remote_addr(),
                    response.headers().clone(),
                    serde_json::from_str::<T>(response.text()?.as_str())?
                ))
            },
            Err(error) => Err(error),
        }
    }

    pub fn xml<T>(self) -> ClientixResult<ClientixResponse<T>> where T: DeserializeOwned + Clone {
        match self.result {
            Ok(response) => {
                Ok(ClientixResponse::new(
                    response.version(),
                    response.content_length(),
                    response.status(),
                    response.url().clone(),
                    response.remote_addr(),
                    response.headers().clone(),
                    serde_xml_rs::from_str::<T>(response.text()?.as_str())?
                ))
            },
            Err(error) => Err(error),
        }
    }

    pub fn urlencoded<T>(self) -> ClientixResult<ClientixResponse<T>> where T: DeserializeOwned + Clone {
        match self.result {
            Ok(response) => {
                Ok(ClientixResponse::new(
                    response.version(),
                    response.content_length(),
                    response.status(),
                    response.url().clone(),
                    response.remote_addr(),
                    response.headers().clone(),
                    serde_urlencoded::from_str::<T>(response.text()?.as_str())?
                ))
            },
            Err(error) => Err(error),
        }
    }

}