aamos-ledger-rust/target/debug/deps/liblog-d0fa218afbce2067.rmeta

rust
y#rustc 1.96.0 (ac68faa20 2026-05-25)ÁíàÄTËŸ ÜJîÄ)'ß\¥!-3d1337db07d0b3aeÁ¤°ð¾ä-±($²ï=©Ã-7e98a21bfd32b0edÁ‰errorÁ,º|»À|Ÿ|
	__log_keyÁL‚y»kvÁtäx
__log_valueÁ\‘~»ºtó}
__log_value_svalÁ„°‰»kv_svalÁœ�‰
__log_value_serdeÁŒÅŒ»kv_serdeÁ¤¡Œ
__log_value_errorÁŒø�»kv_stdÁ”Ö�serdeÁ,�}»
serde_coreÁ´º·}»ºtž}a$Å~óµÌ™~Ü˜~®D‰óµÌÕ~ÜÔ~AtomicUsizeÁ\ÂóµÌžÜ�	KeyValuesÁLâí»ºt¹íset_boxed_loggerÁ„Èì»À|“ì›
kv_supportÁTç»ºtÒtestsÁ,²£‚$§£íÀmacrosÁ
__logÁ
log_enabledÁ

__log_enabledÁ
__log_loggerÁ
¥
Æ
ç
–
Ç	LOGGERÁSTATEÁ
UNINITIALIZEDÁINITIALIZINGÁINITIALIZEDÁMAX_LOG_LEVEL_FILTERÁLOG_LEVEL_NAMESÁSET_LOGGER_ERRORÁLEVEL_PARSE_ERRORÁ!�#ï
%%þ(×*€*maxÁ*to_level_filterÁ*as_strÁ*ù//	*increment_severityÁ*decrement_severityÁ4�6ï
88þ;×	=€=²=to_levelÁ=Ò=ùBB	=î=‡	
G'aÁGgetÁK�
M‹Oï
Q§R™T›
TbuilderÁTÀTmetadataÁTlevelÁTêT¹	[	Tmodule_path_staticÁTÌ^	Tfile_staticÁTšb›
bæ	bÀb…b”bêb¹	b²bÌbÖbšbbuildÁo>q›
qð
q”qêv›
væ	v”vêvÀ|>LogÁ~enabledÁ~logÁ~flushÁ	NopLoggerÁ‚
„±
„¿
„É
ˆ¥ˆ±
ˆ¿
ˆÉ

set_max_levelÁset_max_level_racyÁ	max_levelÁ
set_loggerÁ�	set_logger_innerÁ’—set_logger_racyÁ•×—×loggerÁ™NOPÁ
__private_apiÁ››››››››››	›
›››KeyÁ©›
›ValueÁ«›
›sealedÁKVsÁ®›
®into_kvsÁ›±›
±�›´›
´�›·±
·¿
·É
›log_implÁ»�›¿
½›
½œ½�›±
Á�›locÁSTATIC_MAX_LEVELÁ
¿

Š
Õ
infoÁ
™
traceÁLevelÁËErrorÁÌ
ÌËWarnÁÏ
ËInfoÁÑ
ËpÓ
ËTraceÁÕ
ØƒÜ�ÞÖ àï
!â‹"ä×#æ§çùLevelFilterÁéOffÁê
é�ì
é˜î
é©ð
épò
éÆô
$%÷ƒ&'(û�)ýÖ*ÿï
+�‹,ƒ×-…§†ùMaybeStaticStrÁˆ›
ˆStaticÁŠ
ŠˆˆBorrowedÁ�
�ˆ.�›
/’›
0”›
”ƒ1—›
—×RecordÁš›
š…šÀš¹	šÌšš2¡›
¡ƒ3¤›
¤×
RecordBuilderÁ§›
§recordÁ4ª›
ª×MetadataÁ›
”ê5±›
±ƒ6´›
´Ö7·›
8¹›
¹�9¼›
¼‹:¿›
¿ï
;Â›
Â§Äù<Æ›
Æ×MetadataBuilderÁÉ›
É…=Ì›
ÌÖ>Ï›
?Ñ›
Ñ�@Ô›
Ô‹A×›
×ï
BÚ›
Ú§ÜùCÞ›
Þ×SetLoggerErrorÁá
áˆDä×ParseLevelErrorÁæ
æˆEé×FGì�HîÖ›GlobalLoggerÁð
›ò×"
"
$
$
'
)
)
)
-
.
2
3
5
5
7
7
:
<
<
<
@
A
E
F
I
J
K
L
L
M
N
N
O
P
P
Q
R
R
W
X
Y
Z
[
]
^
`
a
e
f
g
h
i
j
k
l
m
n
o
t
u
y
z
{
|


€
€
€
�
…
…
…
†
†
†
‡
ˆ
Š
Š
Š
‹
‹
‹
Œ
–
–
–
˜
˜
˜
¸
¸
¸
¹
¹
¹
º
»
»
»
»
»
»
»
½
½
½
½
Á
Ù
Ý
Ý
ß
á
á
ã
ã
å
å
å
ç
ç
ø
ü
ü
þ
€
€
‚
‚
„
„
„
†
†
–
™
™
™
£
¦
¦
¦
¬
¬
¬
³
¶
»
»
¾
¾
Á
Á
Ä
Ä
È
È
È
Î
Ó
Ó
Ö
Ö
Ù
Ù
Ü
Ü
à
à
à
å
å
å
ê
ê
ê
í
í
ï
ó
ó
ó
~®ÛËÌÍ�ÎÏÐ˜ÑÒ©ÓÔpÕÖÆ ¾”šrÿ9Ø·$Š ·$Ðì·$µß·$·$™·$íß·$·$º·$¿c·$še·$µß·$éêëÒìí�îï˜ðñ©òópôõÆSÂ+>È–¨Ýíß·$Ž&ïy·$Äc·$ÛŽ&ØŽ&Š Ž&ÐìŽ&µßŽ&Ž&™Ž&íßŽ&Ž&ºŽ&¿cŽ&šeŽ&µßŽ&·$íßŽ&·$ïyŽ&ÄcŽ&Š ˆŠ‹§Œˆ�ŽÂ�ˆ¹nø)¹›
ÛË(ØË(¿cË(™ˆŠ‹§Œˆ�ŽÂ�ˆ¹nø)¹8µßÂ)Â)ºÂ)íßÂ)Â)šeÂ)Øššžœ…�Àž¹	ŸÌ šòè+O|ì\›
¿cÊ*¿c§§ƒ© õ›¹ÆàÁŽ›
³§§ƒ© õ›¹ÆàÁŽ8ØÁ¯”°êOŽ1ì�&çP›
™,Ðì,µß,,º,íß,,še,¿c,™ÉÉˆË…}Qr1&Hœ›
ÐìÁ-µßÁ-Á-ºÁ-íßÁ-Á-šeÁ-¿cÁ-³ÉÉˆË…}Qr1&Hœ8~‚‚ƒÕ
Oì ÓFQ
~8¥¿cááâºãˆj¸I{Ù[f³Äc·/¿cææçèèˆJI7šty ïÐìù/µßù/ù/™ù/Äcù/®›

›
ç0›
®›
¿cððñ´…bñ±*â~�1×Ëöé’ˆØË÷é”ˆ¡š±ÚËùé�ˆÛËúé·ÏÉëæÜË!Ëûé4éKˆ¹ÑÉìæÞËýéJˆ´ÌÉîæàË#Ëÿé6éOˆ¿×ÉâË�éMˆ¼ÔÉäËƒé—ˆ¤šª§ÆÞÉäáéæòðæË…éQˆÂÚÉ%Ë8é(Ë;é•á—æo§|É„‚ˆ
·ð±
´
ÛÕØŠ #Ðìµß#™5íß)º.¿c
"šeFïy"Äc³~®0Áï51Áï52Áï56Áï51Á°GÙœ
øNÇ 			øHÿœ'H¥�„ª�	é'øIÉ�)Iñ�”ö�	é'øJ—ž(J¾žŒÃž	é'øKãž(
	KŠŸŒ�Ÿ	é'øL¯Ÿ)L×Ÿ”ÜŸ	é'øMýŸ)
M¥ ”ª 	é',ôŸNå 	„ê 	é'	øO…¡!


O¥¡
”ª¡	é'
øPÇ¡ Pæ¡Œë¡	é'øQ‡¢ Q¦¢Œ«¢	é'øRÇ¢!


Rç¢
”ì¢	é'
”‰£	é�£ü©œöÄŽ&\ÅœeoÊw$Ñ~tù¦S†_Á4�Ø	ˆ‹(ˆŠ‹§Œˆ�ŽÂ�ˆ¹nø)¹~‡ŽD§Ø	ˆŽ(Ò@3¤A:AÌÏ‹	áâ&·/1€18?Ôó�	æç&ù/1€18?
 ~‚ƒ�Ž��’”™›ÄËšéˆ§ÉáâæçíÀ…|â”|¬FromStrÁ<Ï|ïy‹â|‹×ç| `íì|ë	Ë,™×\²kélâr
ýd´v¥LÑ|Æ\é‡ç„åŠ–Œý�ÇŒ‘å\ö}„Ä®Dƒ~¼À¿
ªÅŠ,þ(ÆÕ$º4ÇÖ$ÕAÈ™,ÁMÉè,Š[ÊüÓ�€üÓ! A lightweight logging facade.ÁõúüùIF The `log` crate provides a single logging API that abstracts over theÁüÃMJ actual logging implementation. Libraries can use the logging API providedÁü‘MJ by this crate, and the consumer of those libraries can choose the loggingÁüß:7 implementation that is most suitable for its use case.ÁšúüžOL If no logging implementation is selected, the facade falls back to a "noop"ÁüîKH implementation that ignores all log messages. The overhead in this caseÁüº>; is very small - just an integer load, comparison and jump.ÁùúüýPM A log request consists of a _target_, a _level_, and a _body_. A target is aÁüÎPM string which defaults to the module path of the location of the log request,ÁüŸ	OL though that default may be overridden. Logger implementations typically useÁüï	C@ the target to filter requests based on some user configuration.Á³
ú\·
 # UsageÁÃ
úüÇ
RO The basic use of the log crate is through the five logging macros: [`error!`],Áüš30 [`warn!`], [`info!`], [`debug!`] and [`trace!`]ÁüÎ?< where `error!` represents the highest-priority log messagesÁüŽIF and `trace!` the lowest. The log messages are filtered by configuringÁüØ<9 the log level to exclude messages with a lower priority.Áü•
IF Each of these macros accept format strings similarly to [`println!`].Áß
úã
úüç
" [`error!`]: ./macro.error.htmlÁüŠ  [`warn!`]: ./macro.warn.htmlÁü«  [`info!`]: ./macro.info.htmlÁüÌ" [`debug!`]: ./macro.debug.htmlÁüï" [`trace!`]: ./macro.trace.htmlÁü’IF [`println!`]: https://doc.rust-lang.org/stable/std/macro.println.htmlÁÜúüà]Z Avoid writing expressions with side-effects in log statements. They may not be evaluated.Á¾úœÂ ## In librariesÁÖúüÚGD Libraries should link only to the `log` crate, and use the providedÁü¢NK macros to log whatever information will be useful to downstream consumers.Áñú„õ
 ### ExamplesÁ†ú<Š ```Áü’.+ # #[derive(Debug)] pub struct Yak(String);ÁüÁ1. # impl Yak { fn shave(&mut self, _: u32) {} }Áüó52 # fn find_a_razor() -> Result<u32, u32> { Ok(1) }ÁÔ© use log::{info, warn};ÁÄúüÈ)& pub fn shave_the_yak(yak: &mut Yak) {ÁüòJG     info!(target: "yak_events", "Commencing yak shaving for {yak:?}");Á½útÁ     loop {ÁüÐ"         match find_a_razor() {Áôó             Ok(razor) => {Áü’41                 info!("Razor located: {razor}");ÁüÇ%"                 yak.shave(razor);ÁÔí                 break;ÁŒˆ             }Áìš             Err(err) => {Áü¸GD                 warn!("Unable to locate a razor: {err}, retrying");ÁŒ€©\l’
         }ÁL      }Á,ª }Á”° # fn main() {}Á<Ã«WËú¬Ï ## In executablesÁåúüéUR Executables should choose a logging implementation and initialize it early in theÁü¿LI runtime of the program. Logging implementations will typically include aÁüŒ:7 function to do this. Any log messages generated beforeÁüÇ63 the implementation is initialized will be ignored.Áþúü‚A> The executable itself may use the `log` crate to log as well.ÁÄú|È ### WarningÁØúüÜ41 The logging system may only be initialized once.Á‘úÌ• ## Structured loggingÁ¯úü³FC If you enable the `kv` feature you can associate structured valuesÁüúMJ with your log records. If we take the example from before, we can includeÁüÈDA some additional context besides what's in the formatted message:Á�ú<‘«WÜ™ # use serde::Serialize;Áüµ96 # #[derive(Debug, Serialize)] pub struct Yak(String);Áüï1ôWü¡@= # fn find_a_razor() -> Result<u32, std::io::Error> { Ok(1) }Áüâ" # #[cfg(feature = "kv_serde")]ÁŒ… # fn main() {ÁÔ—íX²úü¶)�YüàIF     info!(target: "yak_events", yak:serde; "Commencing yak shaving");Áª út® ¯Zü½ "ÇZôà òZüÿ 2/                 info!(razor; "Razor located");Áü²!%Ø[ÔØ!†\Œó!©\Ü…"             Err(e) => {Áü¡"GD                 warn!(e:err; "Unable to locate a razor, retrying");ÁŒé"©\lû"Æ]L‰#Ü],“#î]<™# # }Áü¡#'$ # #[cfg(not(feature = "kv_serde"))]Á”É#ü]<Ü#«Wä#úüè#96 See the [`kv`] module documentation for more details.Á¢$úü¦$'$ # Available logging implementationsÁÎ$úüÒ$:7 In order to produce log output executables have to useÁü�%74 a logger implementation compatible with the facade.ÁüÅ%<9 There are many available implementations to choose from,Áü‚&+( here are some of the most popular ones:Á®&úì²& * Simple minimal loggers:Á´Ð&     * [env_logger]ÁŒç&     * [colog]ÁÌù&     * [simple_logger]Á¬“'     * [simplelog]Áì©'     * [pretty_env_logger]Á¬Ç'     * [stderrlog]ÁÄÝ'     * [flexi_logger]Á¼ö'     * [call_logger]Á´Ž(     * [std-logger]Áì¥(     * [structured-logger]Á¬Ã(     * [clang_log]ÁŒÙ(     * [ftail]Áüë(&# * Complex configurable frameworks:Á”’)     * [log4rs]Á¤¥)     * [logforth]Á„º)
     * [fern]Á¬Ë)     * [spdlog-rs]Áüá)$! * Adaptors for other facilities:Á”†*     * [syslog]Á¼™*     * [slog-stdlog]Áü±*"     * [systemd-journal-logger]Á¼Ô*     * [android_log]ÁÔì*     * [win_dbg_logger]Á¬‡+     * [db_logger]ÁÄ�+     * [log-to-defmt]ÁÔ¶+     * [logcontrol-log]ÁüÑ+ * For WebAssembly binaries:Á¼ñ+     * [console_log]Áä‰, * For dynamic libraries:Áü¦,b_     * You may need to construct an FFI-safe wrapper over `log` to initialize in your librariesÁ„‰-
 * Utilities:Áœš-     * [log_err]Á´®-     * [log-reload]ÁäÅ-     * [alterable_logger]Áâ-úÜæ- # Implementing a LoggerÁ‚.úü†.PM Loggers implement the [`Log`] trait. Here's a very basic example that simplyÁü×.KH logs all messages at the [`Error`][level_link], [`Warn`][level_link] orÁü£/*' [`Info`][level_link] levels to stdout:ÁÎ/ú<Ò/«WüÚ/'$ use log::{Record, Level, Metadata};Á‚0úÄ†0 struct SimpleLogger;ÁŸ0úü£0$! impl log::Log for SimpleLogger {ÁüÈ085     fn enabled(&self, metadata: &Metadata) -> bool {Áü�1+(         metadata.level() <= Level::InfoÁL1Ü]·1úü»1(%     fn log(&self, record: &Record) {Áüä10-         if self.enabled(
 ~‚ƒ�Ž��’”™›ÄËšéˆ§Éáâæçí_!Ào!â�!¬“Cœ!ïy‹¯!‹×Â! `íÕ!ë	Ëè!×÷!é"
ý"¥$"Æ3"çC"–S"Çc"ås"„Ä®‡"¼À¿
›"ÅŠ«"ÆÕ»"ÇÖË"È™Û"Éèë"Ê_!_!_!Äð{o!D�|�!ŒÅ|œ!Ü|¯!¯!Â!Â!Õ!Õ!T€}4„}”Œ4ó(|üè!Ÿ´%–Š8Ê4—&�,Ÿ8Ê4 &¦8›$§$«8ê4&³,µ8ê4¶&¼8›$½$Á,Ã8lvlÁÄ&Ç8›$È$Ì,ÎÏú
,Ð8keyÁÑ&Ô8¯Õ,ØÙæ&Ú,Û8captureÁ<Ü&ã8¯ä-ç,éêøë,í8»,î&ó8›$ô-ù$ûü%ý,ÿ€ˆ,�8argÁ‚&…8¯†‰*Œ�ü �û 8š8ú¿ž¢,¤8ú¿¥%¨8²8ú¿µ¹,¼8,½'Â8ª„ÄÕ8ú¿ØÜ,ß8,à'å8×Lçðñóõ ,�8,‚'‡8âl‰'–8¿
˜›ê ,8Ê4®$´,Æ8,Ç'Ì8âlÎ'Û8ë\Ý	èéò,êëð,ì8ŸÂíñ$ó8ú¿…$ˆš›è,œ8ê4�$£,¥8,¦'«8âl'º8¹	\¼	ÇÈÉ$Ê,Ì8,Í'Ò8âlÔ'á8 ãæç$éûüÓ ,ýþÐ ÿÏ 
,€ 8,� '† 8¥Lˆ 	‘ ’ — ,“ 8¼À” $˜ ,š 8,› '  8Æ\¢ 	 ® Î 	,¯ 8¼À° ,´ µ ¿ &¶ ,· 8þÀ<¸ 
À Â ,Ä Å Ì ,Æ 8»,Ç 
Í $Ñ Ò 8Õ Ø Ù Û 8Ú $Ü %ë %ý Û!ž"8Ê4Ü!&â!,ä!8Ê4å!&ë!8›$ì!$ð!8ê4ò!&ø!,ú!8ê4û!&�"8›$‚"$†",ˆ"8ú¿‰"&Œ"8›$�"$‘",“"”"œ",•"8ŸÂ–"&™"8¯š"�"* "£"±%¤"°%8®"8ú¿²"¶",¸"8ú¿¹"%¼"8Æ"8ú¿É"Í",Ð"8,Ñ"'Ö"8ª„Ø"é"8ú¿ì"ð",ó"8,ô"'ù"8×Lû"„#…#‡#ª%,•#8,–#'›#8âl�#'ª#8¿
¬#¯#Ÿ%,Á#8Ê4Â#$È#,Ú#8,Û#'à#8âlâ#'ï#8ë\ñ#	ü#ý#†$,þ#ÿ#„$,€$8ŸÂ�$…$$‡$8ú¿™$$œ$®$¯$ü$,°$8ê4±$$·$,¹$8,º$'¿$8âlÁ$'Î$8¹	\Ð$	Û$Ü$Ý$$Þ$,à$8,á$'æ$8âlè$'õ$8 ÷$ú$û$$ý$�%�%$‘%% %%²%Ä¥kü‚cMJ Determines if a message logged at the specified level in that module willÁtÐc be logged.ÁßcúüãcOL This can be used to avoid expensive computation of log message arguments ifÁü³d(% the message would be ignored anyway.ÁÜdútàd # ExamplesÁïdú<ód«Wüûd)& use log::{debug, log_enabled, Level};Á¥eúü©e$! # struct Data { x: u32, y: u32 }ÁüÎe96 # fn expensive_call() -> Data { Data { x: 0, y: 0 } }Áüˆf74 # let my_logger = log::__private_api::GlobalLogger;ÁüÀf#  if log_enabled!(Level::Debug) {Áüäf$!     let data = expensive_call();Áü‰g>;     debug!("expensive debug data: {} {}", data.x, data.y);Á,Ègî]ÎgúüÒg52 if log_enabled!(target: "Global", Level::Debug) {Áüˆh#     let data = expensive_call();Áü¬hOL    debug!(target: "Global", "expensive debug data: {} {}", data.x, data.y);Á,ühî]‚iúü†i63 if log_enabled!(logger: my_logger, Level::Debug) {Áü½i#ØØüáiO…Ù,±jî]<·j«W¿júüÃjQN This macro accepts the same `target` and `logger` arguments as [`macro@log`].Á(|•k÷!¾k³r�lÃl8Ê4Žl&”l,–l8Ê4—l&�l8›$žl$¢l8ê4¤l&ªl,¬l8ê4l&³l8›$´l$¸l,ºl8ú¿»l&¾l8›$¿l*ÅlÈl®mÉlm,Ól8,Ôl'Ùl8élÛl	èlél§m8Ê4êl&ðl,òl8,ól'øl8ýdúl	†m‡m�m,ˆm8Ê4‰m$�m8ê4’m&˜m,šm8ê4›m$¡m,£m8ú¿¤m%¯mêmŠn8Ê4ëm&ñm,óm8Ê4ôm&úm8›$ûm$ÿm,�n8ú¿‚n&…n8›$†n*Œn�n“o�n’o,šn8,›n' n8
,Œ•üÞ•&·$$ïß$ü™–C\œ–ö÷ö·$÷Ž&Û¼Ý¼Þ¼©ß¼à¼Ûá¼ˆcSñŸ«‡zÙ¿ßÀßÁßLessÁÂßÃßÄß~ÅßÆßÇßGreaterÁÈßåºÝÈnûê7#¨–#
$$©–¹
,¯–´Ÿ—·$&'ðyñy'D¼—Á—%%ù/üÜ—4Dß—øøÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
·$·$ðy%ï—%
'”,è—Ü¬š·$)Åc)üÎš6Ñšùúûù·$ú c cˆ¢cµ
 `£cbufÁ `àB¤GS
ûÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
€1ŸÈŸÈ È�O˜éBL(Õš(
)$Öš×ÜšT¯›·$+,-./23üÀ›(TÃ›ï5Û¼Ý¼Þ¼©ß¼à¼Ûá¼ˆcSñŸ«‡zÙ·$**
+ÀÎ›¬žžüà�+( Returns the most verbose logging level.Á¥ž·$**
,ü¢Ÿ,üÖž96 Converts the `Level` to the equivalent `LevelFilter`.Á|©Ÿüü·$Ž&*¹Ÿ*
-$ºŸü¢¡$ü• 52 Returns the string representation of the `Level`.ÁÏ úü× FC This returns the same string as the `fmt::Display` implementation.Á4©¡ýý·$Îý*°¡*
.$±¡üƒ¥+üü¡1. Iterate through all supported logging levels.Á²¢úüº¢KH The order of iteration is from more severe to less severe log messages.ÁŠ£út’£½Ô¥£ú<£«Wœ¹£ use log::Level;ÁÑ£úüÙ£#  let mut levels = Level::iter();Á�¤úü‰¤2/ assert_eq!(Some(Level::Error), levels.next());ÁüÀ¤2/ assert_eq!(Some(Level::Trace), levels.last());Á<÷¤«W$Š¥0**
/ÐZ”¥//ââMapÁåùæ±Å@Iœóë	¶¥�£�£¹ƒ£¹„£þ-'ºˆÉ¬gï51ï5·$€1Íìë�±ùMë�¬™¥ë�úM·$\¢¥¨’Û·’"È’/Ä¥/<closure_kind>Á1<closure_signature>Á1<upvars>Á11/�’ü±ª(üñ¥/, Get the next-highest `Level` from this one.Á¥¦úü¦`] If the current `Level` is at the highest level, the returned `Level` will be the same as theÁ„’§
 current one.Á§§út¯§½ÔÂ§ú<Ê§«WœÖ§ï�î§úäö§ let level = Level::Info;Á—¨úüŸ¨96 assert_eq!(Level::Debug, level.increment_severity());ÁüÝ¨NK assert_eq!(Level::Trace, level.increment_severity().increment_severity());Áü°©pm assert_eq!(Level::Trace, level.increment_severity().increment_severity().increment_severity()); // max levelÁ<¥ª«W”¸ªþþ·$·$*Ëª*
2$Ìªü�°(üÄ«.+ Get the next-lowest `Level` from this one.Á÷«úüÿ«_\ If the current `Level` is at the lowest level, the returned `Level` will be the same as theÁ„ã¬¤”ø¬út€½Ô“ú<›«Wœ§ï�¿úäÇŽ•èúüð85 assert_eq!(Level::Warn, level.decrement_severity());Áü®NK assert_eq!(Level::Error, level.decrement_severity().decrement_severity());Áü€¯pm assert_eq!(Level::Error, level.decrement_severity().decrement_severity().decrement_severity()); // min levelÁ<õ¯«W”ˆ°ÿÿ·$·$*›°*
3$œ°üÃ·%Ž&5·ß5üý·#€¸€�€Ž&�·$4ƒ¸4
5$„¸¹
,Š¸üÃ¸&Ž&7ïß7üþ¸=\�¹‚ƒ‚Ž&ƒ·$ï�6�¹6
7$Ž¹¹
,”¹äþ¹Ž&9:ðyñy:D¡º¦º88ù/üÁº:DÄº„„Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
Ž&Ž&ðy8Ôº8
:”,Íºü�½!Ž&<Åc<üÅ½6È½…†‡…Ž&† c cˆ¢cµ
 `£c¤… `àB¤GS
‡Ë†;Ì½;
<$Í½×Ó½„¦¾Ž&>?@ABEFü½¾.TÀ¾ï5Û¼Ý¼Þ¼©ß¼à¼Ûá¼ˆcSñŸ«‡zÙŽ&==
>ÀË¾ÜïÁüªÁ2/ Returns the most verbose logging level filter.ÁöÁŽ&==
?ü´Ã'ü³Â.+ Converts `self` to the equivalent `Level`.ÁæÂúüîÂ30 Returns `None` if `self` is `LevelFilter::Off`.ÁD»ÃˆˆŽ&±ˆ=ÄÃ=
@$ÅÃü¦Å$ü“Ä;8 Returns the string representation of the `LevelFilter`.ÁÓÄúüÛÄFöŠ4Å‰‰Ž&Îý=´Å=
A$µÅü–É+ü€Æ30 Iterate through all supported filtering levels.Á¸ÆúüÀÆB? The order of iteration is from less to more verbose filtering.Á‡Çút�Ç½Ô¢Çú<ªÇ«WÌ¶Ç use log::LevelFilter;ÁÔÇúüÜÇ)& let mut levels = LevelFilter::iter();ÁŠÈúü’È63 assert_eq!(Some(LevelFilter::Off), levels.next());ÁüÍÈ85 assert_eq!(Some(LevelFilter::Trace), levels.last());Á<ŠÉ«W$�ÉC==
BÐb§ÉBBââ¡�åùæ±Å@Iœóë	¶¥Õ‘D›’Ž&€1Íì°wùM°¬¬É°úMŽ&\µÉ³®¡Â®"Ó®B×ÉBŽ’D¦’DÃ’DDBœ®ü�Ï(ü„Ê52 Get the next-highest `LevelFilter` from this one.Á¾ÊúüÆÊ`] If the current `LevelFilter` is at the highest level, the returned `LevelFilter` will be theÁä«Ë same as the current one.ÁÌËútÔË½ÔçËú<ïË«WÌûËžª™Ìúü¡Ì)& let level_filter = LevelFilter::Info;ÁÏÌúü×ÌFC assert_eq!(LevelFilter::Debug, level_filter.increment_severity());Áü¢Í[X assert_eq!(LevelFilter::Trace, level_filter.increment_severity().increment_severity());Áü‚Î}z assert_eq!(LevelFilter::Trace, level_filter.increment_severity().increment_severity().increment_severity()); // max levelÁ<„Ï«W”—ÏŠŠŽ&Ž&=ªÏ=
E$«Ïü²Ö(ü£Ð41 Get the next-lowest `LevelFilter` from this one.ÁÜÐúüäÐ_\ If the current `LevelFilter` is at the lowest level, the returned `LevelFilter` will be theÁäÈÑ�°éÑútñÑ½Ô„Òú<ŒÒ«WÌ˜Òžª¶Òúü¾Ò)†±ìÒúüôÒEB assert_eq!(LevelFilter::Warn, level_filter.decrement_severity());Áü¾Ó[X assert_eq!(LevelFilter::Error, level_filter.decrement_severity().decrement_severity());ÁüžÔnk assert_eq!(LevelFilter::Off, level_filter.decrement_severity().decrement_severity().decrement_severity());Áü‘Õ�� assert_eq!(LevelFilter::Off, level_filter.decrement_severity().decrement_severity().decrement_severity().decrement_severity()); // min levelÁ<¦Ö«W”¹Ö‹‹Ž&Ž&=ÌÖ=
F$ÍÖÜ½Ø›
HHË(IÂØÄíØðØŒŒË(ç0GôØG
I›
$õØô‹Ú8��Â)ü®Ú%8ŽŽÂ)L·ßLüÚÚ"ÝÚ���Â)�Â)KàÚK
L8$áÚ¹
,çÚüªÛ8‘‘Â)N»NüÐÛ2ÓÛ’“’Â)“Â)´‚M×ÛM
N8$ØÛ¹
,ÞÛü²Ü&8””Â)PïßPüßÜB\âÜ•–•Â)–Â)ï�OîÜO
P8$ïÜ¹
,õÜüËÝ+8——Â)R›eRüýÝ3$€Þ˜™˜Â)™™€1Q™SS›ÞQÍì’Â…Þ¢e’ÂŒˆÞ
R8’Â$œÞº,¢Þ46œˆð›
UUÊ*VWXYZ[]^`a�ðüÏð%Ô¢ð Returns a new builder.Á<Öðº+TT
V›
üÇñ)¬Ÿñ The message body.Á$ÎñššÊ*šäÈäÈ	ArgumentsÁæÈtemplateÁ `çÈÀ `üöMõô]Td›
TÓñT
W›
$ÔñüÉò'ü‘ò%" Metadata about the log directive.ÁDÐò››Ê*›,TÙòT
X›
$ÚòäÏóü•ó'$ The verbosity level of the message.Á,ÖóœœÊ*·$TÜóT
Y›
$ÝóüÖôü—ô,) The name of the target of the directive.Á4Ýô��Ê*ç0TäôT
Z›
$åôüØõ,ü¢õ#  The module path of the message.Á\ßõžžÊ*Û¼Ý¼Þ¼©ß¼à¼Ûá¼ˆcSñŸ«‡zÙç0TëõT
[›
$ìõ¤ö[Ž’\¦’\Ã’\\[\Ò@¤A€1ü�÷8ü¼ö@= The module path of the message, if it is a `'static` string.Á”–÷ŸŸÊ*Û¼Ý¼Þ¼©ß¼à¼Ûá¼ˆcSñŸ«‡zÙÎýT©÷T
]›
$ª÷ü�ù%üÏø+( The source file containing the message.Á$”ù  Ê*ŒÊT™ùT
^›
$šùËù^Ž’_¦’_Ã’__^_ËË€1ü¾ú1üãùHE The source file containing the message, if it is a `'static` string.Á\Åú¡¡Ê*ØÌTÑúT
`›
$Òúü§ü!üðû$! The line containing the message.Á$®ü¢¢Ê*Û¼Ý¼Þ¼©ß¼à¼Ûá¼ˆcSñŸ«‡zÙT³üT
a›
$´üÔï�›
ccº+defghijklmnô�üÒ‘!ü�Ž" Construct new `RecordBuilder`.Á·Žúä¿Ž The default options are:ÁàŽúüèŽ" - `args`: [`format_args!("")`]Áü��1. - `metadata`: [`Metadata::builder().build()`]ÁÜÅ� - `module_path`: `None`Á¤å� - `file`: `None`Á¤þ� - `line`: `None`Á—�úüŸ�NK [`format_args!("")`]: https://doc.rust-lang.org/std/macro.format_args.htmlÁüò�MJ [`Metadata::builder().build()`]: struct.MetadataBuilder.html#method.buildÁÙ‘º+bb
d›
üº•Jüö”1. Set [`args`](struct.Record.html#method.args).Á$Á•££º+ýÄý×bÆ•b
e›
$Ë•À$Ñ•üá—LüÀ–Ž‹ Set [`metadata`](struct.Record.html#method.metadata). Construct a `Metadata` object with [`MetadataBuilder`](struct.MetadataBuilder.html).ÁDè—¤¤º+,€Úbñ—b
f›
$ö—…Dü—üÃ™?üñ˜?< Set [`Metadata::level`](struct.Metadata.html#method.level).Á,Ê™¥¥º+·$±ÛbÐ™b
g›
$Õ™”,Û™üœ›CüÉš@= Set [`Metadata::target`](struct.Metadata.html#method.target)Á4£›¦¦º+ç0ãÜbª›b
h›
$¯›ê4µ›üùœNü¨œ>; Set [`module_path`](struct.Record.html#method.module_path)Á\€�§§º+ŒÊ“ÞbŒ�b
i›
$‘�õ
$—�ü�ŸZü¨žTQ Set [`module_path`](struct.Record.html#method.module_path) to a `'static` stringÁ”–Ÿ¨¨º+ØÌÚßb©Ÿb
j›
$®Ÿõ
$´Ÿü‹¡GüÈ 0- Set [`file`](struct.Record.html#method.file)Á$’¡©©º+ŒÊýàb—¡b
k›
$œ¡Ì$¢¡ü†£Sü¬¢GD Set [`file`](struct.Record.html#method.file) to a `'static` string.Á\�£ªªº+ØÌ·âb™£b
l›
$ž£Ì$¤£üô¤Cü±¤0- Set [`line`](struct.Record.html#method.line)Á$û¤««º+ÁÑÚãb€¥b
m›
$…¥š$‹¥ü·¨!üø§,) Invoke the builder and return a `Record`Á,¾¨¬¬º+Ê*bÄ¨b
n›
$Å¨ü€©"8ô+p´p¤©©<¬©ô+oo
p8¬ý±›
rr,stu‚²üÆ²'Ô™²ÒÂ<Í²Á-qq
s›
äÔ³üš³'žÆ,Û³®®,·$qá³q
t›
$â³üÐ´ü‘´,«Ç4×´¯¯,ç0qÞ´q
u›
$ß´ä±º›
wwÁ-xyz{¶ºüø»#üÔº&# Construct a new `MetadataBuilder`.Áÿºúä‡»³Ò¨»úä°» - `level`: `Level::Info`Á¤Ñ» - `target`: `""`Áÿ»Á-vv
x›
üŒ¾?ü½½<9 Setter for [`level`](struct.Metadata.html#method.level).Á,“¾°°Á-·$Ìëv™¾v
y›
$ž¾ŸÂ¤¾üÚ¿Eü‰¿>; Setter for [`target`](struct.Metadata.html#method.target).Á4á¿±±Á-ç0ýìvè¿v
z›
$í¿ê4ó¿ü”Á#üáÀ  Returns a `Metadata` object.Á,›Á²²Á-,v¡Áv
{›
$¢ÁüáÁ$8³³À.}´}¤ŒÂ<�ÂÀ.||
}8ÔÿÂüÀÂ>; A trait encapsulating the operations required of a logger.Á‰Ã~~ÎìüÿÂ“	� ™ð$ŽÃÌì™ð$•Ã~‘ð=¦ð0·ð$‘ðO¦ðB·ð6€�€�€�üÆÇ/ü ÃDA Determines if a log message with the specified metadata would beÁ\éÃ logged.ÁùÃúü�ÄFC This is used by the `log_enabled!` macro to allow callers to avoidÁüÌÄJG expensive computation of log message arguments if the message would beÁ¬›Å discarded anyway.ÁµÅú´½Å # For implementorsÁØÅúüàÅ@= This method isn't called automatically by the `log!` macros.Áü¥ÆPM It's up to an implementation of the `Log` trait to call `enabled` in its ownÁüúÆGD `log` method implementation to guarantee that filtering is applied.Á<ÉÇ´µ¶´™ðµÁ¯”°êOŽ1ì�&çP¶~ÑÇ~
™ð$ÒÇ…DØÇüéÉ´ûÇ Logs the `Record`.Á–Èú´žÈèò¹ÈúüÁÈGD Note that `enabled` is *not* necessarily called before this method.Áü�ÉC@ Implementations of `log` should perform all necessary filteringÁ|ÕÉ internally.ÁìÉ·¸¹·™ð¸ššžœ…�Àž¹	ŸÌ šòè+O|ì\¹€1~ðÉ~
€™ð$ñÉ 4÷É„€ÌüŽÊ! Flushes any buffered records.Á´Êú´¼Êèò×ÊúüßÊ@–óü¤ËWT It can be called manually on shut-down to ensure any in-flight records are flushed.Á,ƒÌºº™ð€1~‰Ì~
�™ð$ŠÌ„ºÌLÁÌø.Oì ÓFQ
ƒ/*‚‚ø.´ÍÌø.…†‡€�‡…†üêÌ'<íÌ»¼½»ø.¼Á¯”°êOŽ1ì�&çP½„õÌ„
…$öÌüÌÌÍ°Í¾¿À¾ø.¿ššžœ…�Àž¹	ŸÌ šòè+O|ì\À€1„´Í„
†$µÍ»Í|ÎÍ,ÑÍÁÁø.€1„×Í„
‡$ØÍüäÍ08Â¥‰‰ÂÎì©/éÍ~©/�Î¤/Š‹Œ€�Š‹Œ79ü›Î.<žÎÃÄÅÃ¤/ÄÁ¯”°êOŽ1ì�&çPÅˆ¦Îˆ
Š8©/$§Î…DÎôúÎýÎÆÇÈÆ¤/Çššžœ…�Àž¹	ŸÌ šòè+O|ì\È€1ˆ�Ïˆ
‹8©/$‚Ï 4ˆÏ|ÃÏ,ÆÏÉÉ¤/€1ˆÌÏˆ
Œ8©/$ÍÏü¤×(ü‡Õ&# Sets the global maximum log level.Á®Õúü²ÕOL Generally, this should only be called by the active logging implementation.Á‚Öúü†Öqn Note that `Trace` is the maximum level, because it provides the maximum amount of detail in the emitted logs.ÁóµÌˆ×ü‚×!l«×Ž&€1
�”,¹×üñÝ4ü•Ø1. A thread-unsafe version of [`set_max_level`].ÁÇØúüËØLI This function is available on all platforms, even those that do not haveÁü˜Ù<9 support for atomics that is needed by [`set_max_level`].ÁÕÙúüÙÙ?< In almost all cases, [`set_max_level`] should be preferred.Á™Úúd�Ú	 # SafetyÁªÚúü®ÚIF This function is only safe to call when it cannot race with any otherÁüøÚ52 calls to `set_max_level` or `set_max_level_racy`.Á®Ûúü²ÛMJ This can be upheld by (for example) making sure that **there are no otherÁü€ÜB? threads**, and (on embedded) that **interrupts are disabled**.ÁÃÜúüÇÜJG It is safe to use all other logging functions while this function runsÁü’Ý#  (including all logging macros).Á¶ÝúüºÝ,¸¨”ÿÝŽ&€1
Ž”,’Þüñä!üàà*' Returns the current maximum log level.Á‹áúü�á[X The [`log!`], [`error!`], [`warn!`], [`info!`], [`debug!`], and [`trace!`] macros checkÁüëáLI this value and discard any message logged at a higher level. The maximumÁü¸â74 log level is set by the [`set_max_level`] function.Áðâúäôâ [`log!`]: macro.log.htmlÁü‘ã  [`error!`]: macro.error.htmlÁô²ã [`warn!`]: macro.warn.htmlÁôÑã [`info!`]: macro.info.htmlÁüðã  [`debug!`]: macro.debug.htmlÁü‘ä  [`trace!`]: macro.trace.htmlÁü²ä,¸¨LøäŽ&
�üýùIü½í/, Sets the global logger to a `&'static Log`.ÁííúüñíOL This function may only be called once in the lifetime of a program. Any logÁüÁîPM events that occur before the call to `set_logger` completes will be ignored.Á’ïúü–ïGD This function does not typically need to be called manually. LoggerÁüÞïMJ implementations should provide an initialization method that installs theÁ´¬ð logger internally.ÁÃðú”Çð # AvailabilityÁÚðúüÞðNK This method is available even when the `std` feature is disabled. However,ÁüñLI it is currently unavailable on `thumbv6` targets, which lack support forÁüúñIF some atomic operations which are used by this function. Even on thoseÁüÄò30 targets, [`set_logger_racy`] will be available.Áøòúdüò	 # ErrorsÁ‰óúü�ó:7 An error is returned if a logger
 `£c¤… `àB¤GS
ÌË†•¡Œ•
–$¢Œ×¨Œü”�%ù/˜Åc˜üÀ�6Ã�ÍÎÏÍù/Î c cˆ¢cµ
 `£c¤… `àB¤GS
ÏË†—Ç�—
˜$È�×Î�ü�“#üœ’&# Returns a reference to the logger.ÁÃ’úüÇ’EB If a logger has not been set, a no-op implementation is returned.Á4”“µû
™¬Ì—Ó—ø.€¬—™ü\Y WARNING: this is not part of the crate's public API and is subject to change at any timeÁ4Ž™lŸ™©«»½ÁÃðñîp®›œÊ4�™›žô,‰Ë›Ÿ§
�~› ÁD•›¡ž4Ÿš›¢‰ÄL¶äÈ›£LocationÁDÑ•½›¤ë\éž¦¹	\ö«§ÔLƒ¨¨Œbê,yÛÝÊÌ¹»©«˜šœ¬Š¤ÅrãbdSUDF„¬»ºtš„™Ü�µ›
ªªç0¹”ä»ºtÒ„ÑÜÈ,í›
¬¬ç0óTƒ4‡›®Œ¹Ã®›
¯®¯‘ðü¹h®‘ð‘ð°°°ÇüÕFDØ™ðÛ¼Ý¼Þ¼©ß¼à¼Ûá¼ˆcSñŸ«‡zÙ›

›
å·®®
°™ð›
$áüÆ/›
²²Þ0³°³ËüŠ7D�Þ0Û¼Ý¼Þ¼©ß¼à¼Ûá¼ˆcSñŸ«‡zÙÞ0±±
³›
$–¼à›
µµ€1¶°¶åüŒ7D�€1ê¸´´
¶›
$˜Ì¼�1¸¹º€�¹¸ºüÜ.<ßÐÑÒÐ�1ÑÁ¯”°êOŽ1ì�&çPÒ·ç·
¸$è…Dîô»¾ÓÔÕÓ�1Ôššžœ…�Àž¹	ŸÌ šòè+O|ì\Õ€1·Â·
¹$Ã 4É|„	,‡	ÖÖ�1€1·�	·
º$Ž	üí	¹Dð	›×ØÙÚÛÜÝ�äÈäÈ‰ÄæÈœÄ `çÈÀ `üöMõô]Td×·$ØÙÎý•½•½÷²—½filenameÁ¯V˜½š¯V™½colÁ¯Vš½	_filenameÁ¯VirBð¸tý–ÚÛ¼Ý¼Þ¼©ß¼à¼Ûá¼ˆcSñŸ«‡zÙÛ