andiskaz 0.2.0

A convenience library for writing games and other apps in TUI
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

use std::{error::Error, fmt};

/// Error generated when validating a `TermString` or a grapheme
/// ([`TermGrapheme`](crate::string::TermGrapheme)) and the string starts with a
/// diacrtic.
#[derive(Debug, Clone, Default)]
pub struct DiacriticAtStart;

impl Error for DiacriticAtStart {}

impl fmt::Display for DiacriticAtStart {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        write!(fmt, "The given string with a diacritic")
    }
}

/// Error generated when validating a grapheme
/// ([`TermGrapheme`](crate::string::TermGrapheme)) and the string does not
/// containing exactly one grapheme cluster
/// ([`TermGrapheme`](crate::string::TermGrapheme)).
#[derive(Debug, Clone, Default)]
pub struct NotAGrapheme;

impl Error for NotAGrapheme {}

impl fmt::Display for NotAGrapheme {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        write!(fmt, "The given string is not made of only one grapheme cluster",)
    }
}

/// Error generated when validating a `TermString` and the string contains a
/// control byte.
#[derive(Debug, Clone)]
pub struct InvalidControl {
    /// The position in bytes of the invalid character.
    pub position: usize,
}

impl Error for InvalidControl {}

impl fmt::Display for InvalidControl {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        write!(
            fmt,
            "The string contains a control character in position {}",
            self.position
        )
    }
}

/// Possible errors when creating a
/// [`TermGrapheme`](crate::string::TermGrapheme).
#[derive(Debug, Clone)]
pub enum TermGraphemeError {
    /// Invalid control character found in the given input string.
    InvalidControl(InvalidControl),
    /// The given input string starts with a diacritic.
    DiacriticAtStart(DiacriticAtStart),
    /// The given input is not made of only one grapheme
    /// ([`TermGrapheme`](crate::string::TermGrapheme)).
    NotAGrapheme(NotAGrapheme),
}

impl Error for TermGraphemeError {}

impl fmt::Display for TermGraphemeError {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Self::InvalidControl(error) => write!(fmt, "{}", error),
            Self::DiacriticAtStart(error) => write!(fmt, "{}", error),
            Self::NotAGrapheme(error) => write!(fmt, "{}", error),
        }
    }
}

impl From<InvalidControl> for TermGraphemeError {
    fn from(error: InvalidControl) -> Self {
        TermGraphemeError::InvalidControl(error)
    }
}

impl From<DiacriticAtStart> for TermGraphemeError {
    fn from(error: DiacriticAtStart) -> Self {
        TermGraphemeError::DiacriticAtStart(error)
    }
}

impl From<NotAGrapheme> for TermGraphemeError {
    fn from(error: NotAGrapheme) -> Self {
        TermGraphemeError::NotAGrapheme(error)
    }
}

impl From<TermStringError> for TermGraphemeError {
    fn from(error: TermStringError) -> Self {
        match error {
            TermStringError::InvalidControl(error) => {
                TermGraphemeError::InvalidControl(error)
            },
            TermStringError::DiacriticAtStart(error) => {
                TermGraphemeError::DiacriticAtStart(error)
            },
        }
    }
}

/// Possible errors when creating a
/// [`TermGrapheme`](crate::string::TermGrapheme).
#[derive(Debug, Clone)]
pub enum TermStringError {
    /// Invalid control character found in the given input string.
    InvalidControl(InvalidControl),
    /// The given input string starts with a diacritic.
    DiacriticAtStart(DiacriticAtStart),
}

impl Error for TermStringError {}

impl fmt::Display for TermStringError {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Self::InvalidControl(error) => write!(fmt, "{}", error),
            Self::DiacriticAtStart(error) => write!(fmt, "{}", error),
        }
    }
}

impl From<InvalidControl> for TermStringError {
    fn from(error: InvalidControl) -> Self {
        TermStringError::InvalidControl(error)
    }
}

impl From<DiacriticAtStart> for TermStringError {
    fn from(error: DiacriticAtStart) -> Self {
        TermStringError::DiacriticAtStart(error)
    }
}