Rename LevelFilter::compare to LevelFilter::test

spdlog/src/level.rs

@@ -14,7 +14,7 @@ const LOG_LEVEL_SHORT_NAMES: [&str; Level::count()] = ["C", "E", "W", "I", "D",
 /// An enum representing log levels.
 ///
 /// Typical usage includes: specifying the `Level` of [`log!`], and comparing a
-/// `Level` to a [`LevelFilter`] through [`LevelFilter::compare`].
+/// `Level` to a [`LevelFilter`] through [`LevelFilter::test`].
 ///
 /// # Note
 ///
@@ -185,7 +185,7 @@ impl FromStr for Level {
 /// An enum representing log level logical filter conditions.
 ///
 /// A `LevelFilter` may be compared to a [`Level`] through
-/// [`LevelFilter::compare`].
+/// [`LevelFilter::test`].
 ///
 /// # Examples
 ///
@@ -194,10 +194,10 @@ impl FromStr for Level {
 ///
 /// let level_filter: LevelFilter = LevelFilter::MoreSevere(Level::Info);
 ///
-/// assert_eq!(level_filter.compare(Level::Trace), false);
-/// assert_eq!(level_filter.compare(Level::Info), false);
-/// assert_eq!(level_filter.compare(Level::Warn), true);
-/// assert_eq!(level_filter.compare(Level::Error), true);
+/// assert_eq!(level_filter.test(Level::Trace), false);
+/// assert_eq!(level_filter.test(Level::Info), false);
+/// assert_eq!(level_filter.test(Level::Warn), true);
+/// assert_eq!(level_filter.test(Level::Error), true);
 /// ```
 #[repr(align(4))]
 #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
@@ -234,20 +234,20 @@ cfg_if! {
 }
 
 impl LevelFilter {
-    /// Compares the given level with the logical filter condition
+    /// Tests the given level with the logical filter condition
     ///
     /// # Examples
     ///
     /// See the documentation of [`LevelFilter`].
     #[must_use]
-    pub fn compare(&self, level: Level) -> bool {
-        self.__compare_const(level)
+    pub fn test(&self, level: Level) -> bool {
+        self.__test_const(level)
     }
 
     // Users should not use this function directly.
     #[doc(hidden)]
     #[must_use]
-    pub const fn __compare_const(&self, level: Level) -> bool {
+    pub const fn __test_const(&self, level: Level) -> bool {
         let level_num: u16 = level as u16;
 
         match *self {
@@ -385,37 +385,37 @@ mod tests {
 
     #[test]
     fn filter() {
-        assert!(!LevelFilter::Off.compare(Level::Trace));
-        assert!(!LevelFilter::Off.compare(Level::Critical));
-        assert!(!LevelFilter::Off.compare(Level::Warn));
+        assert!(!LevelFilter::Off.test(Level::Trace));
+        assert!(!LevelFilter::Off.test(Level::Critical));
+        assert!(!LevelFilter::Off.test(Level::Warn));
 
-        assert!(LevelFilter::Equal(Level::Error).compare(Level::Error));
-        assert!(!LevelFilter::Equal(Level::Error).compare(Level::Warn));
-        assert!(!LevelFilter::Equal(Level::Error).compare(Level::Critical));
+        assert!(LevelFilter::Equal(Level::Error).test(Level::Error));
+        assert!(!LevelFilter::Equal(Level::Error).test(Level::Warn));
+        assert!(!LevelFilter::Equal(Level::Error).test(Level::Critical));
 
-        assert!(LevelFilter::NotEqual(Level::Error).compare(Level::Trace));
-        assert!(LevelFilter::NotEqual(Level::Error).compare(Level::Info));
-        assert!(!LevelFilter::NotEqual(Level::Error).compare(Level::Error));
+        assert!(LevelFilter::NotEqual(Level::Error).test(Level::Trace));
+        assert!(LevelFilter::NotEqual(Level::Error).test(Level::Info));
+        assert!(!LevelFilter::NotEqual(Level::Error).test(Level::Error));
 
-        assert!(LevelFilter::MoreSevere(Level::Info).compare(Level::Warn));
-        assert!(LevelFilter::MoreSevere(Level::Info).compare(Level::Error));
-        assert!(!LevelFilter::MoreSevere(Level::Info).compare(Level::Info));
+        assert!(LevelFilter::MoreSevere(Level::Info).test(Level::Warn));
+        assert!(LevelFilter::MoreSevere(Level::Info).test(Level::Error));
+        assert!(!LevelFilter::MoreSevere(Level::Info).test(Level::Info));
 
-        assert!(LevelFilter::MoreSevereEqual(Level::Info).compare(Level::Warn));
-        assert!(LevelFilter::MoreSevereEqual(Level::Info).compare(Level::Info));
-        assert!(!LevelFilter::MoreSevereEqual(Level::Info).compare(Level::Trace));
+        assert!(LevelFilter::MoreSevereEqual(Level::Info).test(Level::Warn));
+        assert!(LevelFilter::MoreSevereEqual(Level::Info).test(Level::Info));
+        assert!(!LevelFilter::MoreSevereEqual(Level::Info).test(Level::Trace));
 
-        assert!(LevelFilter::MoreVerbose(Level::Error).compare(Level::Warn));
-        assert!(LevelFilter::MoreVerbose(Level::Error).compare(Level::Info));
-        assert!(!LevelFilter::MoreVerbose(Level::Error).compare(Level::Error));
+        assert!(LevelFilter::MoreVerbose(Level::Error).test(Level::Warn));
+        assert!(LevelFilter::MoreVerbose(Level::Error).test(Level::Info));
+        assert!(!LevelFilter::MoreVerbose(Level::Error).test(Level::Error));
 
-        assert!(LevelFilter::MoreVerboseEqual(Level::Error).compare(Level::Warn));
-        assert!(LevelFilter::MoreVerboseEqual(Level::Error).compare(Level::Error));
-        assert!(!LevelFilter::MoreVerboseEqual(Level::Error).compare(Level::Critical));
+        assert!(LevelFilter::MoreVerboseEqual(Level::Error).test(Level::Warn));
+        assert!(LevelFilter::MoreVerboseEqual(Level::Error).test(Level::Error));
+        assert!(!LevelFilter::MoreVerboseEqual(Level::Error).test(Level::Critical));
 
-        assert!(LevelFilter::All.compare(Level::Trace));
-        assert!(LevelFilter::All.compare(Level::Critical));
-        assert!(LevelFilter::All.compare(Level::Error));
+        assert!(LevelFilter::All.test(Level::Trace));
+        assert!(LevelFilter::All.test(Level::Critical));
+        assert!(LevelFilter::All.test(Level::Error));
     }
 
     #[cfg(feature = "log")]

spdlog/src/lib.rs

@@ -312,8 +312,8 @@ use sync::*;
 /// See the crate level documentation for information on how to configure this.
 ///
 /// This value is checked by the log macros, but not by [`Logger`]s and
-/// [`Sink`]s. Code that manually calls functions on these should compare the
-/// level against this value.
+/// [`Sink`]s. Code that manually calls functions on these should test the level
+/// against this value.
 ///
 /// [`Logger`]: crate::logger::Logger
 /// [`Sink`]: crate::sink::Sink

spdlog/src/log_macros.rs

@@ -25,7 +25,7 @@ macro_rules! log {
     (logger: $logger:expr, $level:expr, $($arg:tt)+) => ({
         let logger = &$logger;
         const LEVEL: $crate::Level = $level;
-        const SHOULD_LOG: bool = $crate::STATIC_LEVEL_FILTER.__compare_const(LEVEL);
+        const SHOULD_LOG: bool = $crate::STATIC_LEVEL_FILTER.__test_const(LEVEL);
         if SHOULD_LOG && logger.should_log(LEVEL) {
             $crate::__log(logger, LEVEL, $crate::source_location_current!(), format_args!($($arg)+));
         }

spdlog/src/logger.rs

@@ -135,7 +135,7 @@ impl Logger {
     /// ```
     #[must_use]
     pub fn should_log(&self, level: Level) -> bool {
-        self.level_filter().compare(level)
+        self.level_filter().test(level)
     }
 
     /// Logs a record.
@@ -423,7 +423,7 @@ impl Logger {
 
     #[must_use]
     fn should_flush(&self, record: &Record) -> bool {
-        self.flush_level_filter().compare(record.level())
+        self.flush_level_filter().test(record.level())
     }
 }
 

spdlog/src/sink/mod.rs

@@ -83,7 +83,7 @@ pub trait Sink: Sync + Send {
     /// Determines if a log message with the specified level would be logged.
     #[must_use]
     fn should_log(&self, level: Level) -> bool {
-        self.level_filter().compare(level)
+        self.level_filter().test(level)
     }
 
     /// Logs a record.