tinify-rs 1.4.2

A Rust client for the Tinify API
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

use serde::Deserialize;
use serde::Serialize;
use std::error;
use std::fmt;
use std::io;
#[cfg(feature = "async")]
use tokio::task;

/// Tinify remote error message received.
#[derive(Serialize, Deserialize, Debug)]
pub struct Upstream {
  pub error: String,
  pub message: String,
}

/// The `TinifyError` enum indicates whether a client or server error occurs.
#[derive(Debug)]
pub enum TinifyError {
  ClientError {
    upstream: Upstream,
  },
  ServerError {
    upstream: Upstream,
  },
  ReqwestError(reqwest::Error),
  ReqwestConvertError(reqwest::header::ToStrError),
  UrlParseError(url::ParseError),
  JsonParseError(serde_json::Error),
  IOError(io::Error),
  #[cfg(feature = "async")]
  TokioError(task::JoinError),
}

impl error::Error for TinifyError {
  fn source(&self) -> Option<&(dyn error::Error + 'static)> {
    match *self {
      TinifyError::ClientError { .. } => None,
      TinifyError::ServerError { .. } => None,
      TinifyError::ReqwestError(ref source) => Some(source),
      TinifyError::ReqwestConvertError(ref source) => Some(source),
      TinifyError::UrlParseError(ref source) => Some(source),
      TinifyError::JsonParseError(ref source) => Some(source),
      TinifyError::IOError(ref source) => Some(source),
      #[cfg(feature = "async")]
      TinifyError::TokioError(ref source) => Some(source),
    }
  }
}

impl fmt::Display for TinifyError {
  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    match *self {
      TinifyError::ClientError { ref upstream } => {
        write!(f, "Tinify Client Error: {}", upstream.message)
      }
      TinifyError::ServerError { ref upstream } => {
        write!(f, "Tinify Server Error: {}", upstream.message)
      }
      TinifyError::ReqwestError(ref err) => err.fmt(f),
      TinifyError::ReqwestConvertError(ref err) => err.fmt(f),
      TinifyError::UrlParseError(ref err) => err.fmt(f),
      TinifyError::JsonParseError(ref err) => err.fmt(f),
      TinifyError::IOError(ref err) => err.fmt(f),
      #[cfg(feature = "async")]
      TinifyError::TokioError(ref err) => err.fmt(f),
    }
  }
}

impl From<io::Error> for TinifyError {
  fn from(err: io::Error) -> Self {
    TinifyError::IOError(err)
  }
}

impl From<reqwest::Error> for TinifyError {
  fn from(err: reqwest::Error) -> Self {
    TinifyError::ReqwestError(err)
  }
}

impl From<reqwest::header::ToStrError> for TinifyError {
  fn from(err: reqwest::header::ToStrError) -> Self {
    TinifyError::ReqwestConvertError(err)
  }
}

impl From<url::ParseError> for TinifyError {
  fn from(err: url::ParseError) -> Self {
    TinifyError::UrlParseError(err)
  }
}

impl From<serde_json::Error> for TinifyError {
  fn from(err: serde_json::Error) -> Self {
    TinifyError::JsonParseError(err)
  }
}

#[cfg(feature = "async")]
impl From<tokio::task::JoinError> for TinifyError {
  fn from(err: tokio::task::JoinError) -> Self {
    TinifyError::TokioError(err)
  }
}