zng-unit 0.5.2

Part of the zng project.
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

#![doc(html_favicon_url = "https://zng-ui.github.io/res/zng-logo-icon.png")]
#![doc(html_logo_url = "https://zng-ui.github.io/res/zng-logo.png")]
//!
//! Base unit types.
//!
//! # Crate
//!
#![doc = include_str!(concat!("../", std::env!("CARGO_PKG_README")))]
#![warn(unused_extern_crates)]
#![warn(missing_docs)]

mod angle;
mod byte;
mod color;
mod corner_radius;
mod distance_key;
mod factor;
mod float_eq;
mod orientation;
mod px_density;
mod px_dip;
mod side_offsets;
mod time;
mod transform;

use std::fmt;

#[doc(no_inline)]
pub use euclid;

pub use angle::*;
pub use byte::*;
pub use color::*;
pub use corner_radius::*;
pub use distance_key::*;
pub use factor::*;
pub use float_eq::*;
pub use orientation::*;
pub use px_density::*;
pub use px_dip::*;
pub use side_offsets::*;
pub use time::*;
pub use transform::*;

pub(crate) fn parse_suffix<T: std::str::FromStr>(mut s: &str, suffixes: &[&'static str]) -> Result<T, <T as std::str::FromStr>::Err> {
    for suffix in suffixes {
        if let Some(f) = s.strip_suffix(suffix) {
            s = f;
            break;
        }
    }
    s.parse()
}

/// An error which can be returned when parsing an type composed of integers.
#[derive(Debug)]
#[non_exhaustive]
pub enum ParseIntCompositeError {
    /// Color component parse error.
    Component(std::num::ParseIntError),
    /// Missing color component.
    MissingComponent,
    /// Extra color component.
    ExtraComponent,
    /// Unexpected char.
    UnknownFormat,
}
impl fmt::Display for ParseIntCompositeError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            ParseIntCompositeError::Component(e) => write!(f, "error parsing component, {e}"),
            ParseIntCompositeError::MissingComponent => write!(f, "missing component"),
            ParseIntCompositeError::ExtraComponent => write!(f, "extra component"),
            ParseIntCompositeError::UnknownFormat => write!(f, "unknown format"),
        }
    }
}
impl std::error::Error for ParseIntCompositeError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        if let ParseIntCompositeError::Component(e) = self {
            Some(e)
        } else {
            None
        }
    }
}
impl From<std::num::ParseIntError> for ParseIntCompositeError {
    fn from(value: std::num::ParseIntError) -> Self {
        ParseIntCompositeError::Component(value)
    }
}