spdlog_internal/pattern_parser/
mod.rs

1use std::borrow::Cow;
2
3use strum::IntoEnumIterator;
4use strum_macros::{EnumDiscriminants, EnumIter, EnumString, IntoStaticStr};
5
6pub mod error;
7mod helper;
8pub mod parse;
9mod registry;
10
11pub use error::{Error, Result};
12pub use registry::{check_custom_pattern_names, PatternRegistry};
13
14#[derive(
15    Clone, Copy, Debug, Eq, PartialEq, IntoStaticStr, EnumDiscriminants, EnumIter, EnumString,
16)]
17#[strum_discriminants(derive(IntoStaticStr))]
18pub enum BuiltInFormatterInner {
19    #[strum(serialize = "weekday_name")]
20    AbbrWeekdayName,
21    #[strum(serialize = "weekday_name_full")]
22    WeekdayName,
23    #[strum(serialize = "month_name")]
24    AbbrMonthName,
25    #[strum(serialize = "month_name_full")]
26    MonthName,
27    #[strum(serialize = "datetime")]
28    FullDateTime,
29    #[strum(serialize = "year_short")]
30    ShortYear,
31    #[strum(serialize = "year")]
32    Year,
33    #[strum(serialize = "date_short")]
34    ShortDate,
35    #[strum(serialize = "date")]
36    Date,
37    #[strum(serialize = "month")]
38    Month,
39    #[strum(serialize = "day")]
40    Day,
41    #[strum(serialize = "hour")]
42    Hour,
43    #[strum(serialize = "hour_12")]
44    Hour12,
45    #[strum(serialize = "minute")]
46    Minute,
47    #[strum(serialize = "second")]
48    Second,
49    #[strum(serialize = "millisecond")]
50    Millisecond,
51    #[strum(serialize = "microsecond")]
52    Microsecond,
53    #[strum(serialize = "nanosecond")]
54    Nanosecond,
55    #[strum(serialize = "am_pm")]
56    AmPm,
57    #[strum(serialize = "time_12")]
58    Time12,
59    #[strum(serialize = "time_short")]
60    ShortTime,
61    #[strum(serialize = "time")]
62    Time,
63    #[strum(serialize = "tz_offset")]
64    TzOffset,
65    #[strum(serialize = "unix_timestamp")]
66    UnixTimestamp,
67    #[strum(serialize = "full")]
68    Full,
69    #[strum(serialize = "level")]
70    Level,
71    #[strum(serialize = "level_short")]
72    ShortLevel,
73    #[strum(serialize = "source")]
74    Source,
75    #[strum(serialize = "file_name")]
76    SourceFilename,
77    #[strum(serialize = "file")]
78    SourceFile,
79    #[strum(serialize = "line")]
80    SourceLine,
81    #[strum(serialize = "column")]
82    SourceColumn,
83    #[strum(serialize = "module_path")]
84    SourceModulePath,
85    #[strum(serialize = "logger")]
86    LoggerName,
87    #[strum(serialize = "payload")]
88    Payload,
89    #[strum(serialize = "kv")]
90    KV,
91    #[strum(serialize = "pid")]
92    ProcessId,
93    #[strum(serialize = "tid")]
94    ThreadId,
95    #[strum(serialize = "eol")]
96    Eol,
97}
98
99#[derive(Clone, Debug, Eq, PartialEq)]
100pub struct BuiltInFormatter(BuiltInFormatterInner);
101
102impl BuiltInFormatter {
103    pub fn iter() -> impl Iterator<Item = BuiltInFormatter> {
104        BuiltInFormatterInner::iter().map(BuiltInFormatter)
105    }
106
107    pub fn struct_name(&self) -> &'static str {
108        BuiltInFormatterInnerDiscriminants::from(self.0).into()
109    }
110
111    pub fn placeholder(&self) -> &'static str {
112        self.0.into()
113    }
114
115    pub fn inner(&self) -> BuiltInFormatterInner {
116        self.0
117    }
118}
119
120#[derive(Clone, Debug, Eq, PartialEq)]
121pub enum PatternKind<F> {
122    BuiltIn(BuiltInFormatter),
123    Custom {
124        placeholder: Cow<'static, str>,
125        factory: F,
126    },
127}
128
129impl<F> PatternKind<F> {
130    pub(crate) fn placeholder(&self) -> &str {
131        match self {
132            PatternKind::BuiltIn(f) => f.placeholder(),
133            PatternKind::Custom { placeholder, .. } => placeholder,
134        }
135    }
136
137    pub(crate) fn to_factory_erased(&self) -> PatternKind<()> {
138        match self {
139            PatternKind::BuiltIn(b) => PatternKind::BuiltIn(b.clone()),
140            PatternKind::Custom { placeholder, .. } => PatternKind::Custom {
141                placeholder: placeholder.clone(),
142                factory: (),
143            },
144        }
145    }
146}