ultimate 0.1.0

Rust libraries
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

use std::fmt::Display;

use serde::{
  de::{Unexpected, Visitor},
  Deserialize, Deserializer, Serialize,
};
use tracing::log::Level;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TraceConfig {
  pub enable: bool,

  pub target: bool,

  pub log_level: LogLevel,

  pub log_writer: LogWriterType,

  /// 目录输出目录
  pub log_dir: String,

  /// 目标文件名，默认为 <app name>.log
  pub log_name: Option<String>,
}

#[derive(Debug, Clone, Serialize, PartialEq, Eq)]
#[allow(non_camel_case_types)]
pub enum LogWriterType {
  Console,
  File,
}

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
pub struct LogLevel(Level);

impl Display for LogLevel {
  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    f.pad(self.0.as_str())
  }
}

impl<'de> Deserialize<'de> for LogLevel {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: Deserializer<'de>,
  {
    const MSG: &str = "attempted to convert a string that doesn't match an existing log level";
    struct StrToLogLevel;
    impl<'d> Visitor<'d> for StrToLogLevel {
      type Value = LogLevel;

      fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
        formatter.write_str(MSG)
      }

      fn visit_str<E>(self, v: &str) -> core::result::Result<Self::Value, E>
      where
        E: serde::de::Error,
      {
        let level = if v.eq_ignore_ascii_case("error") {
          Level::Error
        } else if v.eq_ignore_ascii_case("warn") {
          Level::Warn
        } else if v.eq_ignore_ascii_case("info") {
          Level::Info
        } else if v.eq_ignore_ascii_case("debug") {
          Level::Debug
        } else if v.eq_ignore_ascii_case("trace") {
          Level::Trace
        } else {
          return Err(serde::de::Error::invalid_value(Unexpected::Str(v), &MSG));
        };
        Ok(LogLevel(level))
      }
    }

    deserializer.deserialize_str(StrToLogLevel)
  }
}

impl Serialize for LogLevel {
  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  where
    S: serde::Serializer,
  {
    serializer.serialize_str(self.0.as_str())
  }
}

impl<'de> Deserialize<'de> for LogWriterType {
  fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
  where
    D: Deserializer<'de>,
  {
    const MSG: &str = "expect in ('console', 'file').";

    struct StrToLogWriterType;
    impl<'d> Visitor<'d> for StrToLogWriterType {
      type Value = LogWriterType;

      fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
        formatter.write_str(MSG)
      }

      fn visit_str<E>(self, v: &str) -> core::result::Result<Self::Value, E>
      where
        E: serde::de::Error,
      {
        let writer = if v.eq_ignore_ascii_case("console") {
          LogWriterType::Console
        } else if v.eq_ignore_ascii_case("file") {
          LogWriterType::File
        } else {
          return Err(serde::de::Error::invalid_value(Unexpected::Str(v), &MSG));
        };
        Ok(writer)
      }
    }

    deserializer.deserialize_str(StrToLogWriterType)
  }
}