tgt 1.0.0

A simple TUI for Telegram
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

use config::ConfigError;
use std::{fmt::Display, io};
use tokio::sync::mpsc::error::SendError;

#[derive(Debug)]
/// An error type for the application.
/// It is used to represent the application error.
/// It can be one of the following:
/// * Io: An IO error.
/// * Send: A send error.
/// * Config: A configuration error.
/// * ConfigFile: A configuration file error.
pub enum AppError<T> {
    /// It is a wrapper for the `std::io::Error`.
    Io(io::Error),
    /// It is a wrapper for the `tokio::sync::mpsc::error::SendError`.
    Send(SendError<T>),
    /// It is a wrapper for the `config::ConfigError`.
    Config(ConfigError),
    /// It is an invalid action.
    InvalidAction(String),
    /// It is an invalid event.
    InvalidEvent(String),
    /// It is a configuration file error. It is used when a key is already
    /// bound.
    AlreadyBound,
    /// It is an invalid color.
    InvalidColor(String),
}
impl<T> From<io::Error> for AppError<T> {
    fn from(error: io::Error) -> Self {
        Self::Io(error)
    }
}
impl<T> From<SendError<T>> for AppError<T> {
    fn from(error: SendError<T>) -> Self {
        Self::Send(error)
    }
}
impl<T> From<ConfigError> for AppError<T> {
    fn from(error: ConfigError) -> Self {
        Self::Config(error)
    }
}
impl<T> Display for AppError<T> {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        match self {
            Self::Io(error) => write!(f, "IO error: {}", error),
            Self::Send(error) => write!(f, "Send error: {}", error),
            Self::Config(error) => write!(f, "Config error: {}", error),
            Self::InvalidAction(action) => {
                write!(f, "Invalid action: {}", action)
            }
            Self::InvalidEvent(event) => {
                write!(f, "Invalid event: {}", event)
            }
            Self::AlreadyBound => {
                write!(f, "Key already bound")
            }
            Self::InvalidColor(color) => {
                write!(f, "Invalid color: {}", color)
            }
        }
    }
}