vendor/log/src/macros.rs

   1 // Copyright 2014-2015 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 /// The standard logging macro.
  12 ///
  13 /// This macro will generically log with the specified `Level` and `format!`
  14 /// based argument list.
  15 ///
  16 /// # Examples
  17 ///
  18 /// ```edition2018
  19 /// use log::{log, Level};
  20 ///
  21 /// # fn main() {
  22 /// let data = (42, "Forty-two");
  23 /// let private_data = "private";
  24 ///
  25 /// log!(Level::Error, "Received errors: {}, {}", data.0, data.1);
  26 /// log!(target: "app_events", Level::Warn, "App warning: {}, {}, {}",
  27 ///     data.0, data.1, private_data);
  28 /// # }
  29 /// ```
  30 #[macro_export(local_inner_macros)]
  31 macro_rules! log {
  32     (target: $target:expr, $lvl:expr, $($arg:tt)+) => ({
  33         let lvl = $lvl;
  34         if lvl <= $crate::STATIC_MAX_LEVEL && lvl <= $crate::max_level() {
  35             $crate::__private_api_log(
  36                 __log_format_args!($($arg)+),
  37                 lvl,
  38                 &($target, __log_module_path!(), __log_file!(), __log_line!()),
  39             );
  40         }
  41     });
  42     ($lvl:expr, $($arg:tt)+) => (log!(target: __log_module_path!(), $lvl, $($arg)+))
  43 }
  44
  45 /// Logs a message at the error level.
  46 ///
  47 /// # Examples
  48 ///
  49 /// ```edition2018
  50 /// use log::error;
  51 ///
  52 /// # fn main() {
  53 /// let (err_info, port) = ("No connection", 22);
  54 ///
  55 /// error!("Error: {} on port {}", err_info, port);
  56 /// error!(target: "app_events", "App Error: {}, Port: {}", err_info, 22);
  57 /// # }
  58 /// ```
  59 #[macro_export(local_inner_macros)]
  60 macro_rules! error {
  61     (target: $target:expr, $($arg:tt)+) => (
  62         log!(target: $target, $crate::Level::Error, $($arg)+)
  63     );
  64     ($($arg:tt)+) => (
  65         log!($crate::Level::Error, $($arg)+)
  66     )
  67 }
  68
  69 /// Logs a message at the warn level.
  70 ///
  71 /// # Examples
  72 ///
  73 /// ```edition2018
  74 /// use log::warn;
  75 ///
  76 /// # fn main() {
  77 /// let warn_description = "Invalid Input";
  78 ///
  79 /// warn!("Warning! {}!", warn_description);
  80 /// warn!(target: "input_events", "App received warning: {}", warn_description);
  81 /// # }
  82 /// ```
  83 #[macro_export(local_inner_macros)]
  84 macro_rules! warn {
  85     (target: $target:expr, $($arg:tt)+) => (
  86         log!(target: $target, $crate::Level::Warn, $($arg)+)
  87     );
  88     ($($arg:tt)+) => (
  89         log!($crate::Level::Warn, $($arg)+)
  90     )
  91 }
  92
  93 /// Logs a message at the info level.
  94 ///
  95 /// # Examples
  96 ///
  97 /// ```edition2018
  98 /// use log::info;
  99 ///
 100 /// # fn main() {
 101 /// # struct Connection { port: u32, speed: f32 }
 102 /// let conn_info = Connection { port: 40, speed: 3.20 };
 103 ///
 104 /// info!("Connected to port {} at {} Mb/s", conn_info.port, conn_info.speed);
 105 /// info!(target: "connection_events", "Successfull connection, port: {}, speed: {}",
 106 ///       conn_info.port, conn_info.speed);
 107 /// # }
 108 /// ```
 109 #[macro_export(local_inner_macros)]
 110 macro_rules! info {
 111     (target: $target:expr, $($arg:tt)+) => (
 112         log!(target: $target, $crate::Level::Info, $($arg)+)
 113     );
 114     ($($arg:tt)+) => (
 115         log!($crate::Level::Info, $($arg)+)
 116     )
 117 }
 118
 119 /// Logs a message at the debug level.
 120 ///
 121 /// # Examples
 122 ///
 123 /// ```edition2018
 124 /// use log::debug;
 125 ///
 126 /// # fn main() {
 127 /// # struct Position { x: f32, y: f32 }
 128 /// let pos = Position { x: 3.234, y: -1.223 };
 129 ///
 130 /// debug!("New position: x: {}, y: {}", pos.x, pos.y);
 131 /// debug!(target: "app_events", "New position: x: {}, y: {}", pos.x, pos.y);
 132 /// # }
 133 /// ```
 134 #[macro_export(local_inner_macros)]
 135 macro_rules! debug {
 136     (target: $target:expr, $($arg:tt)+) => (
 137         log!(target: $target, $crate::Level::Debug, $($arg)+)
 138     );
 139     ($($arg:tt)+) => (
 140         log!($crate::Level::Debug, $($arg)+)
 141     )
 142 }
 143
 144 /// Logs a message at the trace level.
 145 ///
 146 /// # Examples
 147 ///
 148 /// ```edition2018
 149 /// use log::trace;
 150 ///
 151 /// # fn main() {
 152 /// # struct Position { x: f32, y: f32 }
 153 /// let pos = Position { x: 3.234, y: -1.223 };
 154 ///
 155 /// trace!("Position is: x: {}, y: {}", pos.x, pos.y);
 156 /// trace!(target: "app_events", "x is {} and y is {}",
 157 ///        if pos.x >= 0.0 { "positive" } else { "negative" },
 158 ///        if pos.y >= 0.0 { "positive" } else { "negative" });
 159 /// # }
 160 /// ```
 161 #[macro_export(local_inner_macros)]
 162 macro_rules! trace {
 163     (target: $target:expr, $($arg:tt)+) => (
 164         log!(target: $target, $crate::Level::Trace, $($arg)+)
 165     );
 166     ($($arg:tt)+) => (
 167         log!($crate::Level::Trace, $($arg)+)
 168     )
 169 }
 170
 171 /// Determines if a message logged at the specified level in that module will
 172 /// be logged.
 173 ///
 174 /// This can be used to avoid expensive computation of log message arguments if
 175 /// the message would be ignored anyway.
 176 ///
 177 /// # Examples
 178 ///
 179 /// ```edition2018
 180 /// use log::Level::Debug;
 181 /// use log::{debug, log_enabled};
 182 ///
 183 /// # fn foo() {
 184 /// if log_enabled!(Debug) {
 185 ///     let data = expensive_call();
 186 ///     debug!("expensive debug data: {} {}", data.x, data.y);
 187 /// }
 188 /// if log_enabled!(target: "Global", Debug) {
 189 ///    let data = expensive_call();
 190 ///    debug!(target: "Global", "expensive debug data: {} {}", data.x, data.y);
 191 /// }
 192 /// # }
 193 /// # struct Data { x: u32, y: u32 }
 194 /// # fn expensive_call() -> Data { Data { x: 0, y: 0 } }
 195 /// # fn main() {}
 196 /// ```
 197 #[macro_export(local_inner_macros)]
 198 macro_rules! log_enabled {
 199     (target: $target:expr, $lvl:expr) => {{
 200         let lvl = $lvl;
 201         lvl <= $crate::STATIC_MAX_LEVEL
 202             && lvl <= $crate::max_level()
 203             && $crate::__private_api_enabled(lvl, $target)
 204     }};
 205     ($lvl:expr) => {
 206         log_enabled!(target: __log_module_path!(), $lvl)
 207     };
 208 }
 209
 210 // The log macro above cannot invoke format_args directly because it uses
 211 // local_inner_macros. A format_args invocation there would resolve to
 212 // $crate::format_args which does not exist. Instead invoke format_args here
 213 // outside of local_inner_macros so that it resolves (probably) to
 214 // core::format_args or std::format_args. Same for the several macros that
 215 // follow.
 216 //
 217 // This is a workaround until we drop support for pre-1.30 compilers. At that
 218 // point we can remove use of local_inner_macros, use $crate:: when invoking
 219 // local macros, and invoke format_args directly.
 220 #[doc(hidden)]
 221 #[macro_export]
 222 macro_rules! __log_format_args {
 223     ($($args:tt)*) => {
 224         format_args!($($args)*)
 225     };
 226 }
 227
 228 #[doc(hidden)]
 229 #[macro_export]
 230 macro_rules! __log_module_path {
 231     () => {
 232         module_path!()
 233     };
 234 }
 235
 236 #[doc(hidden)]
 237 #[macro_export]
 238 macro_rules! __log_file {
 239     () => {
 240         file!()
 241     };
 242 }
 243
 244 #[doc(hidden)]
 245 #[macro_export]
 246 macro_rules! __log_line {
 247     () => {
 248         line!()
 249     };
 250 }