fast_log 1.7.8

Rust async log High-performance asynchronous logging
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

use crate::error::LogError;

#[derive(Clone, Copy)]
pub enum LogSize {
    B(usize),
    KB(usize),
    MB(usize),
    GB(usize),
    TB(usize),
    EB(usize),
}

impl LogSize {
    pub fn len(&self) -> usize {
        match self {
            Self::B(b) => *b,
            Self::KB(kb) => kb * 1024,
            Self::MB(mb) => mb * 1024 * 1024,
            Self::GB(gb) => gb * 1024 * 1024 * 1024,
            Self::TB(tb) => tb * 1024 * 1024 * 1024 * 1024,
            Self::EB(eb) => eb * 1024 * 1024 * 1024 * 1024 * 1024,
        }
    }

    pub fn get_len(&self) -> usize {
        self.len()
    }

    pub fn parse(value: &str) -> Result<Self, LogError> {
        if value.ends_with("EB") {
            Ok(Self::EB(
                value.trim_end_matches("EB").parse().unwrap_or_default(),
            ))
        } else if value.ends_with("TB") {
            Ok(Self::TB(
                value.trim_end_matches("TB").parse().unwrap_or_default(),
            ))
        } else if value.ends_with("GB") {
            Ok(Self::GB(
                value.trim_end_matches("GB").parse().unwrap_or_default(),
            ))
        } else if value.ends_with("MB") {
            Ok(Self::MB(
                value.trim_end_matches("MB").parse().unwrap_or_default(),
            ))
        } else if value.ends_with("KB") {
            Ok(Self::KB(
                value.trim_end_matches("KB").parse().unwrap_or_default(),
            ))
        } else if value.ends_with("B") {
            Ok(Self::B(
                value.trim_end_matches("B").parse().unwrap_or_default(),
            ))
        } else {
            Err(LogError::from("unknow LogSize"))
        }
    }
}