Upgrade rust/crates/log to 0.4.11
* Regenerate .bp file, no more warnings.
Test: make
Change-Id: Iba4db27ff4b5b8f51eda5e385d53a4d5dcdd821d
diff --git a/src/kv/error.rs b/src/kv/error.rs
index 0f5652f..f68f2da 100644
--- a/src/kv/error.rs
+++ b/src/kv/error.rs
@@ -1,88 +1,70 @@
-use std::fmt;
-
-/// An error encountered while working with structured data.
-#[derive(Debug)]
-pub struct Error {
- inner: Inner
-}
-
-#[derive(Debug)]
-enum Inner {
- #[cfg(feature = "std")]
- Boxed(std_support::BoxedError),
- Msg(&'static str),
- Fmt,
-}
-
-impl Error {
- /// Create an error from a message.
- pub fn msg(msg: &'static str) -> Self {
- Error {
- inner: Inner::Msg(msg),
- }
- }
-}
-
-impl fmt::Display for Error {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- use self::Inner::*;
- match &self.inner {
- #[cfg(feature = "std")]
- &Boxed(ref err) => err.fmt(f),
- &Msg(ref msg) => msg.fmt(f),
- &Fmt => fmt::Error.fmt(f),
- }
- }
-}
-
-impl From<fmt::Error> for Error {
- fn from(_: fmt::Error) -> Self {
- Error {
- inner: Inner::Fmt,
- }
- }
-}
-
-impl From<Error> for fmt::Error {
- fn from(_: Error) -> Self {
- fmt::Error
- }
-}
-
-#[cfg(feature = "std")]
-mod std_support {
- use super::*;
- use std::{error, io};
-
- pub(super) type BoxedError = Box<error::Error + Send + Sync>;
-
- impl Error {
- /// Create an error from a standard error type.
- pub fn boxed<E>(err: E) -> Self
- where
- E: Into<BoxedError>,
- {
- Error {
- inner: Inner::Boxed(err.into())
- }
- }
- }
-
- impl error::Error for Error {
- fn description(&self) -> &str {
- "key values error"
- }
- }
-
- impl From<io::Error> for Error {
- fn from(err: io::Error) -> Self {
- Error::boxed(err)
- }
- }
-
- impl From<Error> for io::Error {
- fn from(err: Error) -> Self {
- io::Error::new(io::ErrorKind::Other, err)
- }
- }
-}
+use std::fmt;
+
+/// An error encountered while working with structured data.
+#[derive(Debug)]
+pub struct Error {
+ inner: Inner,
+}
+
+#[derive(Debug)]
+enum Inner {
+ #[cfg(feature = "std")]
+ Boxed(std_support::BoxedError),
+ Msg(&'static str),
+ Fmt,
+}
+
+impl Error {
+ /// Create an error from a message.
+ pub fn msg(msg: &'static str) -> Self {
+ Error {
+ inner: Inner::Msg(msg),
+ }
+ }
+}
+
+impl fmt::Display for Error {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ use self::Inner::*;
+ match &self.inner {
+ #[cfg(feature = "std")]
+ &Boxed(ref err) => err.fmt(f),
+ &Msg(ref msg) => msg.fmt(f),
+ &Fmt => fmt::Error.fmt(f),
+ }
+ }
+}
+
+impl From<fmt::Error> for Error {
+ fn from(_: fmt::Error) -> Self {
+ Error { inner: Inner::Fmt }
+ }
+}
+
+#[cfg(feature = "std")]
+mod std_support {
+ use super::*;
+ use std::{error, io};
+
+ pub(super) type BoxedError = Box<dyn error::Error + Send + Sync>;
+
+ impl Error {
+ /// Create an error from a standard error type.
+ pub fn boxed<E>(err: E) -> Self
+ where
+ E: Into<BoxedError>,
+ {
+ Error {
+ inner: Inner::Boxed(err.into()),
+ }
+ }
+ }
+
+ impl error::Error for Error {}
+
+ impl From<io::Error> for Error {
+ fn from(err: io::Error) -> Self {
+ Error::boxed(err)
+ }
+ }
+}
diff --git a/src/kv/key.rs b/src/kv/key.rs
index 82f1e85..367f6ed 100644
--- a/src/kv/key.rs
+++ b/src/kv/key.rs
@@ -1,143 +1,139 @@
-//! Structured keys.
-
-use std::fmt;
-use std::cmp;
-use std::hash;
-use std::borrow::Borrow;
-
-/// A type that can be converted into a [`Key`](struct.Key.html).
-pub trait ToKey {
- /// Perform the conversion.
- fn to_key(&self) -> Key;
-}
-
-impl<'a, T> ToKey for &'a T
-where
- T: ToKey + ?Sized,
-{
- fn to_key(&self) -> Key {
- (**self).to_key()
- }
-}
-
-impl<'k> ToKey for Key<'k> {
- fn to_key(&self) -> Key {
- Key {
- key: self.key,
- }
- }
-}
-
-impl ToKey for str {
- fn to_key(&self) -> Key {
- Key::from_str(self)
- }
-}
-
-/// A key in a structured key-value pair.
-#[derive(Clone)]
-pub struct Key<'k> {
- key: &'k str,
-}
-
-impl<'k> Key<'k> {
- /// Get a key from a borrowed string.
- pub fn from_str(key: &'k str) -> Self {
- Key {
- key: key,
- }
- }
-
- /// Get a borrowed string from this key.
- pub fn as_str(&self) -> &str {
- self.key
- }
-}
-
-impl<'k> fmt::Debug for Key<'k> {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- self.key.fmt(f)
- }
-}
-
-impl<'k> fmt::Display for Key<'k> {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- self.key.fmt(f)
- }
-}
-
-impl<'k> hash::Hash for Key<'k> {
- fn hash<H>(&self, state: &mut H)
- where
- H: hash::Hasher,
- {
- self.as_str().hash(state)
- }
-}
-
-impl<'k, 'ko> PartialEq<Key<'ko>> for Key<'k> {
- fn eq(&self, other: &Key<'ko>) -> bool {
- self.as_str().eq(other.as_str())
- }
-}
-
-impl<'k> Eq for Key<'k> {}
-
-impl<'k, 'ko> PartialOrd<Key<'ko>> for Key<'k> {
- fn partial_cmp(&self, other: &Key<'ko>) -> Option<cmp::Ordering> {
- self.as_str().partial_cmp(other.as_str())
- }
-}
-
-impl<'k> Ord for Key<'k> {
- fn cmp(&self, other: &Self) -> cmp::Ordering {
- self.as_str().cmp(other.as_str())
- }
-}
-
-impl<'k> AsRef<str> for Key<'k> {
- fn as_ref(&self) -> &str {
- self.as_str()
- }
-}
-
-impl<'k> Borrow<str> for Key<'k> {
- fn borrow(&self) -> &str {
- self.as_str()
- }
-}
-
-impl<'k> From<&'k str> for Key<'k> {
- fn from(s: &'k str) -> Self {
- Key::from_str(s)
- }
-}
-
-#[cfg(feature = "std")]
-mod std_support {
- use super::*;
-
- use std::borrow::Cow;
-
- impl ToKey for String {
- fn to_key(&self) -> Key {
- Key::from_str(self)
- }
- }
-
- impl<'a> ToKey for Cow<'a, str> {
- fn to_key(&self) -> Key {
- Key::from_str(self)
- }
- }
-}
-
-#[cfg(test)]
-mod tests {
- use super::*;
-
- #[test]
- fn key_from_string() {
- assert_eq!("a key", Key::from_str("a key").as_str());
- }
-}
+//! Structured keys.
+
+use std::borrow::Borrow;
+use std::cmp;
+use std::fmt;
+use std::hash;
+
+/// A type that can be converted into a [`Key`](struct.Key.html).
+pub trait ToKey {
+ /// Perform the conversion.
+ fn to_key(&self) -> Key;
+}
+
+impl<'a, T> ToKey for &'a T
+where
+ T: ToKey + ?Sized,
+{
+ fn to_key(&self) -> Key {
+ (**self).to_key()
+ }
+}
+
+impl<'k> ToKey for Key<'k> {
+ fn to_key(&self) -> Key {
+ Key { key: self.key }
+ }
+}
+
+impl ToKey for str {
+ fn to_key(&self) -> Key {
+ Key::from_str(self)
+ }
+}
+
+/// A key in a structured key-value pair.
+#[derive(Clone)]
+pub struct Key<'k> {
+ key: &'k str,
+}
+
+impl<'k> Key<'k> {
+ /// Get a key from a borrowed string.
+ pub fn from_str(key: &'k str) -> Self {
+ Key { key: key }
+ }
+
+ /// Get a borrowed string from this key.
+ pub fn as_str(&self) -> &str {
+ self.key
+ }
+}
+
+impl<'k> fmt::Debug for Key<'k> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ self.key.fmt(f)
+ }
+}
+
+impl<'k> fmt::Display for Key<'k> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ self.key.fmt(f)
+ }
+}
+
+impl<'k> hash::Hash for Key<'k> {
+ fn hash<H>(&self, state: &mut H)
+ where
+ H: hash::Hasher,
+ {
+ self.as_str().hash(state)
+ }
+}
+
+impl<'k, 'ko> PartialEq<Key<'ko>> for Key<'k> {
+ fn eq(&self, other: &Key<'ko>) -> bool {
+ self.as_str().eq(other.as_str())
+ }
+}
+
+impl<'k> Eq for Key<'k> {}
+
+impl<'k, 'ko> PartialOrd<Key<'ko>> for Key<'k> {
+ fn partial_cmp(&self, other: &Key<'ko>) -> Option<cmp::Ordering> {
+ self.as_str().partial_cmp(other.as_str())
+ }
+}
+
+impl<'k> Ord for Key<'k> {
+ fn cmp(&self, other: &Self) -> cmp::Ordering {
+ self.as_str().cmp(other.as_str())
+ }
+}
+
+impl<'k> AsRef<str> for Key<'k> {
+ fn as_ref(&self) -> &str {
+ self.as_str()
+ }
+}
+
+impl<'k> Borrow<str> for Key<'k> {
+ fn borrow(&self) -> &str {
+ self.as_str()
+ }
+}
+
+impl<'k> From<&'k str> for Key<'k> {
+ fn from(s: &'k str) -> Self {
+ Key::from_str(s)
+ }
+}
+
+#[cfg(feature = "std")]
+mod std_support {
+ use super::*;
+
+ use std::borrow::Cow;
+
+ impl ToKey for String {
+ fn to_key(&self) -> Key {
+ Key::from_str(self)
+ }
+ }
+
+ impl<'a> ToKey for Cow<'a, str> {
+ fn to_key(&self) -> Key {
+ Key::from_str(self)
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn key_from_string() {
+ assert_eq!("a key", Key::from_str("a key").as_str());
+ }
+}
diff --git a/src/kv/mod.rs b/src/kv/mod.rs
index 17226b4..f4c0866 100644
--- a/src/kv/mod.rs
+++ b/src/kv/mod.rs
@@ -1,23 +1,26 @@
-//! **UNSTABLE:** Structured key-value pairs.
-//!
-//! This module is unstable and breaking changes may be made
-//! at any time. See [the tracking issue](https://github.com/rust-lang-nursery/log/issues/328)
-//! for more details.
-//!
-//! Add the `kv_unstable` feature to your `Cargo.toml` to enable
-//! this module:
-//!
-//! ```toml
-//! [dependencies.log]
-//! features = ["kv_unstable"]
-//! ```
-
-mod error;
-mod source;
-mod key;
-pub mod value;
-
-pub use self::error::Error;
-pub use self::source::{Source, Visitor};
-pub use self::key::{Key, ToKey};
-pub use self::value::{Value, ToValue};
+//! **UNSTABLE:** Structured key-value pairs.
+//!
+//! This module is unstable and breaking changes may be made
+//! at any time. See [the tracking issue](https://github.com/rust-lang-nursery/log/issues/328)
+//! for more details.
+//!
+//! Add the `kv_unstable` feature to your `Cargo.toml` to enable
+//! this module:
+//!
+//! ```toml
+//! [dependencies.log]
+//! features = ["kv_unstable"]
+//! ```
+
+mod error;
+mod key;
+mod source;
+
+pub mod value;
+
+pub use self::error::Error;
+pub use self::key::{Key, ToKey};
+pub use self::source::{Source, Visitor};
+
+#[doc(inline)]
+pub use self::value::{ToValue, Value};
diff --git a/src/kv/source.rs b/src/kv/source.rs
index 0538c14..eeac1ec 100644
--- a/src/kv/source.rs
+++ b/src/kv/source.rs
@@ -1,396 +1,393 @@
-//! Sources for key-value pairs.
-
-use std::fmt;
-use kv::{Error, Key, ToKey, Value, ToValue};
-
-/// A source of key-value pairs.
-///
-/// The source may be a single pair, a set of pairs, or a filter over a set of pairs.
-/// Use the [`Visitor`](trait.Visitor.html) trait to inspect the structured data
-/// in a source.
-pub trait Source {
- /// Visit key-value pairs.
- ///
- /// A source doesn't have to guarantee any ordering or uniqueness of key-value pairs.
- /// If the given visitor returns an error then the source may early-return with it,
- /// even if there are more key-value pairs.
- ///
- /// # Implementation notes
- ///
- /// A source should yield the same key-value pairs to a subsequent visitor unless
- /// that visitor itself fails.
- fn visit<'kvs>(&'kvs self, visitor: &mut Visitor<'kvs>) -> Result<(), Error>;
-
- /// Get the value for a given key.
- ///
- /// If the key appears multiple times in the source then which key is returned
- /// is implementation specific.
- ///
- /// # Implementation notes
- ///
- /// A source that can provide a more efficient implementation of this method
- /// should override it.
- fn get<'v>(&'v self, key: Key) -> Option<Value<'v>> {
- struct Get<'k, 'v> {
- key: Key<'k>,
- found: Option<Value<'v>>,
- }
-
- impl<'k, 'kvs> Visitor<'kvs> for Get<'k, 'kvs> {
- fn visit_pair(&mut self, key: Key<'kvs>, value: Value<'kvs>) -> Result<(), Error> {
- if self.key == key {
- self.found = Some(value);
- }
-
- Ok(())
- }
- }
-
- let mut get = Get {
- key,
- found: None,
- };
-
- let _ = self.visit(&mut get);
- get.found
- }
-
- /// Count the number of key-value pairs that can be visited.
- ///
- /// # Implementation notes
- ///
- /// A source that knows the number of key-value pairs upfront may provide a more
- /// efficient implementation.
- ///
- /// A subsequent call to `visit` should yield the same number of key-value pairs
- /// to the visitor, unless that visitor fails part way through.
- fn count(&self) -> usize {
- struct Count(usize);
-
- impl<'kvs> Visitor<'kvs> for Count {
- fn visit_pair(&mut self, _: Key<'kvs>, _: Value<'kvs>) -> Result<(), Error> {
- self.0 += 1;
-
- Ok(())
- }
- }
-
- let mut count = Count(0);
- let _ = self.visit(&mut count);
- count.0
- }
-}
-
-impl<'a, T> Source for &'a T
-where
- T: Source + ?Sized,
-{
- fn visit<'kvs>(&'kvs self, visitor: &mut Visitor<'kvs>) -> Result<(), Error> {
- Source::visit(&**self, visitor)
- }
-
- fn get<'v>(&'v self, key: Key) -> Option<Value<'v>> {
- Source::get(&**self, key)
- }
-
- fn count(&self) -> usize {
- Source::count(&**self)
- }
-}
-
-impl<K, V> Source for (K, V)
-where
- K: ToKey,
- V: ToValue,
-{
- fn visit<'kvs>(&'kvs self, visitor: &mut Visitor<'kvs>) -> Result<(), Error> {
- visitor.visit_pair(self.0.to_key(), self.1.to_value())
- }
-
- fn get<'v>(&'v self, key: Key) -> Option<Value<'v>> {
- if self.0.to_key() == key {
- Some(self.1.to_value())
- } else {
- None
- }
- }
-
- fn count(&self) -> usize {
- 1
- }
-}
-
-impl<S> Source for [S]
-where
- S: Source,
-{
- fn visit<'kvs>(&'kvs self, visitor: &mut Visitor<'kvs>) -> Result<(), Error> {
- for source in self {
- source.visit(visitor)?;
- }
-
- Ok(())
- }
-
- fn count(&self) -> usize {
- self.len()
- }
-}
-
-impl<S> Source for Option<S>
-where
- S: Source,
-{
- fn visit<'kvs>(&'kvs self, visitor: &mut Visitor<'kvs>) -> Result<(), Error> {
- if let Some(ref source) = *self {
- source.visit(visitor)?;
- }
-
- Ok(())
- }
-
- fn count(&self) -> usize {
- self.as_ref().map(Source::count).unwrap_or(0)
- }
-}
-
-/// A visitor for the key-value pairs in a [`Source`](trait.Source.html).
-pub trait Visitor<'kvs> {
- /// Visit a key-value pair.
- fn visit_pair(&mut self, key: Key<'kvs>, value: Value<'kvs>) -> Result<(), Error>;
-}
-
-impl<'a, 'kvs, T> Visitor<'kvs> for &'a mut T
-where
- T: Visitor<'kvs> + ?Sized,
-{
- fn visit_pair(&mut self, key: Key<'kvs>, value: Value<'kvs>) -> Result<(), Error> {
- (**self).visit_pair(key, value)
- }
-}
-
-impl<'a, 'b: 'a, 'kvs> Visitor<'kvs> for fmt::DebugMap<'a, 'b> {
- fn visit_pair(&mut self, key: Key<'kvs>, value: Value<'kvs>) -> Result<(), Error> {
- self.entry(&key, &value);
- Ok(())
- }
-}
-
-impl<'a, 'b: 'a, 'kvs> Visitor<'kvs> for fmt::DebugList<'a, 'b> {
- fn visit_pair(&mut self, key: Key<'kvs>, value: Value<'kvs>) -> Result<(), Error> {
- self.entry(&(key, value));
- Ok(())
- }
-}
-
-impl<'a, 'b: 'a, 'kvs> Visitor<'kvs> for fmt::DebugSet<'a, 'b> {
- fn visit_pair(&mut self, key: Key<'kvs>, value: Value<'kvs>) -> Result<(), Error> {
- self.entry(&(key, value));
- Ok(())
- }
-}
-
-impl<'a, 'b: 'a, 'kvs> Visitor<'kvs> for fmt::DebugTuple<'a, 'b> {
- fn visit_pair(&mut self, key: Key<'kvs>, value: Value<'kvs>) -> Result<(), Error> {
- self.field(&key);
- self.field(&value);
- Ok(())
- }
-}
-
-#[cfg(feature = "std")]
-mod std_support {
- use super::*;
- use std::borrow::Borrow;
- use std::collections::{BTreeMap, HashMap};
- use std::hash::{BuildHasher, Hash};
-
- impl<S> Source for Box<S>
- where
- S: Source + ?Sized,
- {
- fn visit<'kvs>(&'kvs self, visitor: &mut Visitor<'kvs>) -> Result<(), Error> {
- Source::visit(&**self, visitor)
- }
-
- fn get<'v>(&'v self, key: Key) -> Option<Value<'v>> {
- Source::get(&**self, key)
- }
-
- fn count(&self) -> usize {
- Source::count(&**self)
- }
- }
-
- impl<S> Source for Vec<S>
- where
- S: Source,
- {
- fn visit<'kvs>(&'kvs self, visitor: &mut Visitor<'kvs>) -> Result<(), Error> {
- Source::visit(&**self, visitor)
- }
-
- fn get<'v>(&'v self, key: Key) -> Option<Value<'v>> {
- Source::get(&**self, key)
- }
-
- fn count(&self) -> usize {
- Source::count(&**self)
- }
- }
-
- impl<'kvs, V> Visitor<'kvs> for Box<V>
- where
- V: Visitor<'kvs> + ?Sized,
- {
- fn visit_pair(&mut self, key: Key<'kvs>, value: Value<'kvs>) -> Result<(), Error> {
- (**self).visit_pair(key, value)
- }
- }
-
- impl<K, V, S> Source for HashMap<K, V, S>
- where
- K: ToKey + Borrow<str> + Eq + Hash,
- V: ToValue,
- S: BuildHasher,
- {
- fn visit<'kvs>(&'kvs self, visitor: &mut Visitor<'kvs>) -> Result<(), Error> {
- for (key, value) in self {
- visitor.visit_pair(key.to_key(), value.to_value())?;
- }
- Ok(())
- }
-
- fn get<'v>(&'v self, key: Key) -> Option<Value<'v>> {
- HashMap::get(self, key.as_str()).map(|v| v.to_value())
- }
-
- fn count(&self) -> usize {
- self.len()
- }
- }
-
- impl<K, V> Source for BTreeMap<K, V>
- where
- K: ToKey + Borrow<str> + Ord,
- V: ToValue,
- {
- fn visit<'kvs>(&'kvs self, visitor: &mut Visitor<'kvs>) -> Result<(), Error> {
- for (key, value) in self {
- visitor.visit_pair(key.to_key(), value.to_value())?;
- }
- Ok(())
- }
-
- fn get<'v>(&'v self, key: Key) -> Option<Value<'v>> {
- BTreeMap::get(self, key.as_str()).map(|v| v.to_value())
- }
-
- fn count(&self) -> usize {
- self.len()
- }
- }
-
- #[cfg(test)]
- mod tests {
- use super::*;
- use kv::value::test::Token;
- use std::collections::{BTreeMap, HashMap};
-
- #[test]
- fn count() {
- assert_eq!(1, Source::count(&Box::new(("a", 1))));
- assert_eq!(2, Source::count(&vec![("a", 1), ("b", 2)]));
- }
-
- #[test]
- fn get() {
- let source = vec![("a", 1), ("b", 2), ("a", 1)];
- assert_eq!(
- Token::I64(1),
- Source::get(&source, Key::from_str("a")).unwrap().to_token()
- );
-
- let source = Box::new(Option::None::<(&str, i32)>);
- assert!(Source::get(&source, Key::from_str("a")).is_none());
- }
-
- #[test]
- fn hash_map() {
- let mut map = HashMap::new();
- map.insert("a", 1);
- map.insert("b", 2);
-
- assert_eq!(2, Source::count(&map));
- assert_eq!(
- Token::I64(1),
- Source::get(&map, Key::from_str("a")).unwrap().to_token()
- );
- }
-
- #[test]
- fn btree_map() {
- let mut map = BTreeMap::new();
- map.insert("a", 1);
- map.insert("b", 2);
-
- assert_eq!(2, Source::count(&map));
- assert_eq!(
- Token::I64(1),
- Source::get(&map, Key::from_str("a")).unwrap().to_token()
- );
- }
- }
-}
-
-#[cfg(test)]
-mod tests {
- use super::*;
- use kv::value::test::Token;
-
- #[test]
- fn source_is_object_safe() {
- fn _check(_: &Source) {}
- }
-
- #[test]
- fn visitor_is_object_safe() {
- fn _check(_: &Visitor) {}
- }
-
- #[test]
- fn count() {
- struct OnePair {
- key: &'static str,
- value: i32,
- }
-
- impl Source for OnePair {
- fn visit<'kvs>(&'kvs self, visitor: &mut Visitor<'kvs>) -> Result<(), Error> {
- visitor.visit_pair(self.key.to_key(), self.value.to_value())
- }
- }
-
- assert_eq!(1, Source::count(&("a", 1)));
- assert_eq!(2, Source::count(&[("a", 1), ("b", 2)] as &[_]));
- assert_eq!(0, Source::count(&Option::None::<(&str, i32)>));
- assert_eq!(1, Source::count(&OnePair { key: "a", value: 1 }));
- }
-
- #[test]
- fn get() {
- let source = &[("a", 1), ("b", 2), ("a", 1)] as &[_];
- assert_eq!(
- Token::I64(1),
- Source::get(source, Key::from_str("a")).unwrap().to_token()
- );
- assert_eq!(
- Token::I64(2),
- Source::get(source, Key::from_str("b")).unwrap().to_token()
- );
- assert!(Source::get(&source, Key::from_str("c")).is_none());
-
- let source = Option::None::<(&str, i32)>;
- assert!(Source::get(&source, Key::from_str("a")).is_none());
- }
-}
+//! Sources for key-value pairs.
+
+use kv::{Error, Key, ToKey, ToValue, Value};
+use std::fmt;
+
+/// A source of key-value pairs.
+///
+/// The source may be a single pair, a set of pairs, or a filter over a set of pairs.
+/// Use the [`Visitor`](trait.Visitor.html) trait to inspect the structured data
+/// in a source.
+pub trait Source {
+ /// Visit key-value pairs.
+ ///
+ /// A source doesn't have to guarantee any ordering or uniqueness of key-value pairs.
+ /// If the given visitor returns an error then the source may early-return with it,
+ /// even if there are more key-value pairs.
+ ///
+ /// # Implementation notes
+ ///
+ /// A source should yield the same key-value pairs to a subsequent visitor unless
+ /// that visitor itself fails.
+ fn visit<'kvs>(&'kvs self, visitor: &mut dyn Visitor<'kvs>) -> Result<(), Error>;
+
+ /// Get the value for a given key.
+ ///
+ /// If the key appears multiple times in the source then which key is returned
+ /// is implementation specific.
+ ///
+ /// # Implementation notes
+ ///
+ /// A source that can provide a more efficient implementation of this method
+ /// should override it.
+ fn get<'v>(&'v self, key: Key) -> Option<Value<'v>> {
+ struct Get<'k, 'v> {
+ key: Key<'k>,
+ found: Option<Value<'v>>,
+ }
+
+ impl<'k, 'kvs> Visitor<'kvs> for Get<'k, 'kvs> {
+ fn visit_pair(&mut self, key: Key<'kvs>, value: Value<'kvs>) -> Result<(), Error> {
+ if self.key == key {
+ self.found = Some(value);
+ }
+
+ Ok(())
+ }
+ }
+
+ let mut get = Get { key, found: None };
+
+ let _ = self.visit(&mut get);
+ get.found
+ }
+
+ /// Count the number of key-value pairs that can be visited.
+ ///
+ /// # Implementation notes
+ ///
+ /// A source that knows the number of key-value pairs upfront may provide a more
+ /// efficient implementation.
+ ///
+ /// A subsequent call to `visit` should yield the same number of key-value pairs
+ /// to the visitor, unless that visitor fails part way through.
+ fn count(&self) -> usize {
+ struct Count(usize);
+
+ impl<'kvs> Visitor<'kvs> for Count {
+ fn visit_pair(&mut self, _: Key<'kvs>, _: Value<'kvs>) -> Result<(), Error> {
+ self.0 += 1;
+
+ Ok(())
+ }
+ }
+
+ let mut count = Count(0);
+ let _ = self.visit(&mut count);
+ count.0
+ }
+}
+
+impl<'a, T> Source for &'a T
+where
+ T: Source + ?Sized,
+{
+ fn visit<'kvs>(&'kvs self, visitor: &mut dyn Visitor<'kvs>) -> Result<(), Error> {
+ Source::visit(&**self, visitor)
+ }
+
+ fn get<'v>(&'v self, key: Key) -> Option<Value<'v>> {
+ Source::get(&**self, key)
+ }
+
+ fn count(&self) -> usize {
+ Source::count(&**self)
+ }
+}
+
+impl<K, V> Source for (K, V)
+where
+ K: ToKey,
+ V: ToValue,
+{
+ fn visit<'kvs>(&'kvs self, visitor: &mut dyn Visitor<'kvs>) -> Result<(), Error> {
+ visitor.visit_pair(self.0.to_key(), self.1.to_value())
+ }
+
+ fn get<'v>(&'v self, key: Key) -> Option<Value<'v>> {
+ if self.0.to_key() == key {
+ Some(self.1.to_value())
+ } else {
+ None
+ }
+ }
+
+ fn count(&self) -> usize {
+ 1
+ }
+}
+
+impl<S> Source for [S]
+where
+ S: Source,
+{
+ fn visit<'kvs>(&'kvs self, visitor: &mut dyn Visitor<'kvs>) -> Result<(), Error> {
+ for source in self {
+ source.visit(visitor)?;
+ }
+
+ Ok(())
+ }
+
+ fn count(&self) -> usize {
+ self.len()
+ }
+}
+
+impl<S> Source for Option<S>
+where
+ S: Source,
+{
+ fn visit<'kvs>(&'kvs self, visitor: &mut dyn Visitor<'kvs>) -> Result<(), Error> {
+ if let Some(ref source) = *self {
+ source.visit(visitor)?;
+ }
+
+ Ok(())
+ }
+
+ fn count(&self) -> usize {
+ self.as_ref().map(Source::count).unwrap_or(0)
+ }
+}
+
+/// A visitor for the key-value pairs in a [`Source`](trait.Source.html).
+pub trait Visitor<'kvs> {
+ /// Visit a key-value pair.
+ fn visit_pair(&mut self, key: Key<'kvs>, value: Value<'kvs>) -> Result<(), Error>;
+}
+
+impl<'a, 'kvs, T> Visitor<'kvs> for &'a mut T
+where
+ T: Visitor<'kvs> + ?Sized,
+{
+ fn visit_pair(&mut self, key: Key<'kvs>, value: Value<'kvs>) -> Result<(), Error> {
+ (**self).visit_pair(key, value)
+ }
+}
+
+impl<'a, 'b: 'a, 'kvs> Visitor<'kvs> for fmt::DebugMap<'a, 'b> {
+ fn visit_pair(&mut self, key: Key<'kvs>, value: Value<'kvs>) -> Result<(), Error> {
+ self.entry(&key, &value);
+ Ok(())
+ }
+}
+
+impl<'a, 'b: 'a, 'kvs> Visitor<'kvs> for fmt::DebugList<'a, 'b> {
+ fn visit_pair(&mut self, key: Key<'kvs>, value: Value<'kvs>) -> Result<(), Error> {
+ self.entry(&(key, value));
+ Ok(())
+ }
+}
+
+impl<'a, 'b: 'a, 'kvs> Visitor<'kvs> for fmt::DebugSet<'a, 'b> {
+ fn visit_pair(&mut self, key: Key<'kvs>, value: Value<'kvs>) -> Result<(), Error> {
+ self.entry(&(key, value));
+ Ok(())
+ }
+}
+
+impl<'a, 'b: 'a, 'kvs> Visitor<'kvs> for fmt::DebugTuple<'a, 'b> {
+ fn visit_pair(&mut self, key: Key<'kvs>, value: Value<'kvs>) -> Result<(), Error> {
+ self.field(&key);
+ self.field(&value);
+ Ok(())
+ }
+}
+
+#[cfg(feature = "std")]
+mod std_support {
+ use super::*;
+ use std::borrow::Borrow;
+ use std::collections::{BTreeMap, HashMap};
+ use std::hash::{BuildHasher, Hash};
+
+ impl<S> Source for Box<S>
+ where
+ S: Source + ?Sized,
+ {
+ fn visit<'kvs>(&'kvs self, visitor: &mut dyn Visitor<'kvs>) -> Result<(), Error> {
+ Source::visit(&**self, visitor)
+ }
+
+ fn get<'v>(&'v self, key: Key) -> Option<Value<'v>> {
+ Source::get(&**self, key)
+ }
+
+ fn count(&self) -> usize {
+ Source::count(&**self)
+ }
+ }
+
+ impl<S> Source for Vec<S>
+ where
+ S: Source,
+ {
+ fn visit<'kvs>(&'kvs self, visitor: &mut dyn Visitor<'kvs>) -> Result<(), Error> {
+ Source::visit(&**self, visitor)
+ }
+
+ fn get<'v>(&'v self, key: Key) -> Option<Value<'v>> {
+ Source::get(&**self, key)
+ }
+
+ fn count(&self) -> usize {
+ Source::count(&**self)
+ }
+ }
+
+ impl<'kvs, V> Visitor<'kvs> for Box<V>
+ where
+ V: Visitor<'kvs> + ?Sized,
+ {
+ fn visit_pair(&mut self, key: Key<'kvs>, value: Value<'kvs>) -> Result<(), Error> {
+ (**self).visit_pair(key, value)
+ }
+ }
+
+ impl<K, V, S> Source for HashMap<K, V, S>
+ where
+ K: ToKey + Borrow<str> + Eq + Hash,
+ V: ToValue,
+ S: BuildHasher,
+ {
+ fn visit<'kvs>(&'kvs self, visitor: &mut dyn Visitor<'kvs>) -> Result<(), Error> {
+ for (key, value) in self {
+ visitor.visit_pair(key.to_key(), value.to_value())?;
+ }
+ Ok(())
+ }
+
+ fn get<'v>(&'v self, key: Key) -> Option<Value<'v>> {
+ HashMap::get(self, key.as_str()).map(|v| v.to_value())
+ }
+
+ fn count(&self) -> usize {
+ self.len()
+ }
+ }
+
+ impl<K, V> Source for BTreeMap<K, V>
+ where
+ K: ToKey + Borrow<str> + Ord,
+ V: ToValue,
+ {
+ fn visit<'kvs>(&'kvs self, visitor: &mut dyn Visitor<'kvs>) -> Result<(), Error> {
+ for (key, value) in self {
+ visitor.visit_pair(key.to_key(), value.to_value())?;
+ }
+ Ok(())
+ }
+
+ fn get<'v>(&'v self, key: Key) -> Option<Value<'v>> {
+ BTreeMap::get(self, key.as_str()).map(|v| v.to_value())
+ }
+
+ fn count(&self) -> usize {
+ self.len()
+ }
+ }
+
+ #[cfg(test)]
+ mod tests {
+ use super::*;
+ use kv::value::test::Token;
+ use std::collections::{BTreeMap, HashMap};
+
+ #[test]
+ fn count() {
+ assert_eq!(1, Source::count(&Box::new(("a", 1))));
+ assert_eq!(2, Source::count(&vec![("a", 1), ("b", 2)]));
+ }
+
+ #[test]
+ fn get() {
+ let source = vec![("a", 1), ("b", 2), ("a", 1)];
+ assert_eq!(
+ Token::I64(1),
+ Source::get(&source, Key::from_str("a")).unwrap().to_token()
+ );
+
+ let source = Box::new(Option::None::<(&str, i32)>);
+ assert!(Source::get(&source, Key::from_str("a")).is_none());
+ }
+
+ #[test]
+ fn hash_map() {
+ let mut map = HashMap::new();
+ map.insert("a", 1);
+ map.insert("b", 2);
+
+ assert_eq!(2, Source::count(&map));
+ assert_eq!(
+ Token::I64(1),
+ Source::get(&map, Key::from_str("a")).unwrap().to_token()
+ );
+ }
+
+ #[test]
+ fn btree_map() {
+ let mut map = BTreeMap::new();
+ map.insert("a", 1);
+ map.insert("b", 2);
+
+ assert_eq!(2, Source::count(&map));
+ assert_eq!(
+ Token::I64(1),
+ Source::get(&map, Key::from_str("a")).unwrap().to_token()
+ );
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use kv::value::test::Token;
+
+ #[test]
+ fn source_is_object_safe() {
+ fn _check(_: &dyn Source) {}
+ }
+
+ #[test]
+ fn visitor_is_object_safe() {
+ fn _check(_: &dyn Visitor) {}
+ }
+
+ #[test]
+ fn count() {
+ struct OnePair {
+ key: &'static str,
+ value: i32,
+ }
+
+ impl Source for OnePair {
+ fn visit<'kvs>(&'kvs self, visitor: &mut dyn Visitor<'kvs>) -> Result<(), Error> {
+ visitor.visit_pair(self.key.to_key(), self.value.to_value())
+ }
+ }
+
+ assert_eq!(1, Source::count(&("a", 1)));
+ assert_eq!(2, Source::count(&[("a", 1), ("b", 2)] as &[_]));
+ assert_eq!(0, Source::count(&Option::None::<(&str, i32)>));
+ assert_eq!(1, Source::count(&OnePair { key: "a", value: 1 }));
+ }
+
+ #[test]
+ fn get() {
+ let source = &[("a", 1), ("b", 2), ("a", 1)] as &[_];
+ assert_eq!(
+ Token::I64(1),
+ Source::get(source, Key::from_str("a")).unwrap().to_token()
+ );
+ assert_eq!(
+ Token::I64(2),
+ Source::get(source, Key::from_str("b")).unwrap().to_token()
+ );
+ assert!(Source::get(&source, Key::from_str("c")).is_none());
+
+ let source = Option::None::<(&str, i32)>;
+ assert!(Source::get(&source, Key::from_str("a")).is_none());
+ }
+}
diff --git a/src/kv/value/fill.rs b/src/kv/value/fill.rs
new file mode 100644
index 0000000..2e74899
--- /dev/null
+++ b/src/kv/value/fill.rs
@@ -0,0 +1,164 @@
+//! Lazy value initialization.
+
+use std::fmt;
+
+use super::internal::{Erased, Inner, Visitor};
+use super::{Error, Value};
+
+impl<'v> Value<'v> {
+ /// Get a value from a fillable slot.
+ pub fn from_fill<T>(value: &'v T) -> Self
+ where
+ T: Fill + 'static,
+ {
+ Value {
+ inner: Inner::Fill(unsafe { Erased::new_unchecked::<T>(value) }),
+ }
+ }
+}
+
+/// A type that requires extra work to convert into a [`Value`](struct.Value.html).
+///
+/// This trait is a more advanced initialization API than [`ToValue`](trait.ToValue.html).
+/// It's intended for erased values coming from other logging frameworks that may need
+/// to perform extra work to determine the concrete type to use.
+pub trait Fill {
+ /// Fill a value.
+ fn fill(&self, slot: &mut Slot) -> Result<(), Error>;
+}
+
+impl<'a, T> Fill for &'a T
+where
+ T: Fill + ?Sized,
+{
+ fn fill(&self, slot: &mut Slot) -> Result<(), Error> {
+ (**self).fill(slot)
+ }
+}
+
+/// A value slot to fill using the [`Fill`](trait.Fill.html) trait.
+pub struct Slot<'s, 'f> {
+ filled: bool,
+ visitor: &'s mut dyn Visitor<'f>,
+}
+
+impl<'s, 'f> fmt::Debug for Slot<'s, 'f> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ f.debug_struct("Slot").finish()
+ }
+}
+
+impl<'s, 'f> Slot<'s, 'f> {
+ pub(super) fn new(visitor: &'s mut dyn Visitor<'f>) -> Self {
+ Slot {
+ visitor,
+ filled: false,
+ }
+ }
+
+ pub(super) fn fill<F>(&mut self, f: F) -> Result<(), Error>
+ where
+ F: FnOnce(&mut dyn Visitor<'f>) -> Result<(), Error>,
+ {
+ assert!(!self.filled, "the slot has already been filled");
+ self.filled = true;
+
+ f(self.visitor)
+ }
+
+ /// Fill the slot with a value.
+ ///
+ /// The given value doesn't need to satisfy any particular lifetime constraints.
+ ///
+ /// # Panics
+ ///
+ /// Calling more than a single `fill` method on this slot will panic.
+ pub fn fill_any<T>(&mut self, value: T) -> Result<(), Error>
+ where
+ T: Into<Value<'f>>,
+ {
+ self.fill(|visitor| value.into().inner.visit(visitor))
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn fill_value_borrowed() {
+ struct TestFill;
+
+ impl Fill for TestFill {
+ fn fill(&self, slot: &mut Slot) -> Result<(), Error> {
+ let dbg: &dyn fmt::Debug = &1;
+
+ slot.fill_debug(&dbg)
+ }
+ }
+
+ assert_eq!("1", Value::from_fill(&TestFill).to_string());
+ }
+
+ #[test]
+ fn fill_value_owned() {
+ struct TestFill;
+
+ impl Fill for TestFill {
+ fn fill(&self, slot: &mut Slot) -> Result<(), Error> {
+ slot.fill_any("a string")
+ }
+ }
+ }
+
+ #[test]
+ #[should_panic]
+ fn fill_multiple_times_panics() {
+ struct BadFill;
+
+ impl Fill for BadFill {
+ fn fill(&self, slot: &mut Slot) -> Result<(), Error> {
+ slot.fill_any(42)?;
+ slot.fill_any(6789)?;
+
+ Ok(())
+ }
+ }
+
+ let _ = Value::from_fill(&BadFill).to_string();
+ }
+
+ #[test]
+ fn fill_cast() {
+ struct TestFill;
+
+ impl Fill for TestFill {
+ fn fill(&self, slot: &mut Slot) -> Result<(), Error> {
+ slot.fill_any("a string")
+ }
+ }
+
+ assert_eq!(
+ "a string",
+ Value::from_fill(&TestFill)
+ .to_borrowed_str()
+ .expect("invalid value")
+ );
+ }
+
+ #[test]
+ fn fill_debug() {
+ struct TestFill;
+
+ impl Fill for TestFill {
+ fn fill(&self, slot: &mut Slot) -> Result<(), Error> {
+ slot.fill_any(42u64)
+ }
+ }
+
+ assert_eq!(
+ format!("{:04?}", 42u64),
+ format!("{:04?}", Value::from_fill(&TestFill)),
+ )
+ }
+}
diff --git a/src/kv/value/impls.rs b/src/kv/value/impls.rs
index ea18146..8752dbe 100644
--- a/src/kv/value/impls.rs
+++ b/src/kv/value/impls.rs
@@ -1,269 +1,159 @@
-use std::fmt;
-
-use super::{ToValue, Value, Primitive};
-
-impl ToValue for usize {
- fn to_value(&self) -> Value {
- Value::from(*self)
- }
-}
-
-impl<'v> From<usize> for Value<'v> {
- fn from(value: usize) -> Self {
- Value::from_primitive(Primitive::Unsigned(value as u64))
- }
-}
-
-impl ToValue for isize {
- fn to_value(&self) -> Value {
- Value::from(*self)
- }
-}
-
-impl<'v> From<isize> for Value<'v> {
- fn from(value: isize) -> Self {
- Value::from_primitive(Primitive::Signed(value as i64))
- }
-}
-
-impl ToValue for u8 {
- fn to_value(&self) -> Value {
- Value::from(*self)
- }
-}
-
-impl<'v> From<u8> for Value<'v> {
- fn from(value: u8) -> Self {
- Value::from_primitive(Primitive::Unsigned(value as u64))
- }
-}
-
-impl ToValue for u16 {
- fn to_value(&self) -> Value {
- Value::from(*self)
- }
-}
-
-impl<'v> From<u16> for Value<'v> {
- fn from(value: u16) -> Self {
- Value::from_primitive(Primitive::Unsigned(value as u64))
- }
-}
-
-impl ToValue for u32 {
- fn to_value(&self) -> Value {
- Value::from(*self)
- }
-}
-
-impl<'v> From<u32> for Value<'v> {
- fn from(value: u32) -> Self {
- Value::from_primitive(Primitive::Unsigned(value as u64))
- }
-}
-
-impl ToValue for u64 {
- fn to_value(&self) -> Value {
- Value::from(*self)
- }
-}
-
-impl<'v> From<u64> for Value<'v> {
- fn from(value: u64) -> Self {
- Value::from_primitive(Primitive::Unsigned(value))
- }
-}
-
-impl ToValue for i8 {
- fn to_value(&self) -> Value {
- Value::from(*self)
- }
-}
-
-impl<'v> From<i8> for Value<'v> {
- fn from(value: i8) -> Self {
- Value::from_primitive(Primitive::Signed(value as i64))
- }
-}
-
-impl ToValue for i16 {
- fn to_value(&self) -> Value {
- Value::from(*self)
- }
-}
-
-impl<'v> From<i16> for Value<'v> {
- fn from(value: i16) -> Self {
- Value::from_primitive(Primitive::Signed(value as i64))
- }
-}
-
-impl ToValue for i32 {
- fn to_value(&self) -> Value {
- Value::from(*self)
- }
-}
-
-impl<'v> From<i32> for Value<'v> {
- fn from(value: i32) -> Self {
- Value::from_primitive(Primitive::Signed(value as i64))
- }
-}
-
-impl ToValue for i64 {
- fn to_value(&self) -> Value {
- Value::from(*self)
- }
-}
-
-impl<'v> From<i64> for Value<'v> {
- fn from(value: i64) -> Self {
- Value::from_primitive(Primitive::Signed(value))
- }
-}
-
-impl ToValue for f32 {
- fn to_value(&self) -> Value {
- Value::from(*self)
- }
-}
-
-impl<'v> From<f32> for Value<'v> {
- fn from(value: f32) -> Self {
- Value::from_primitive(Primitive::Float(value as f64))
- }
-}
-
-impl ToValue for f64 {
- fn to_value(&self) -> Value {
- Value::from(*self)
- }
-}
-
-impl<'v> From<f64> for Value<'v> {
- fn from(value: f64) -> Self {
- Value::from_primitive(Primitive::Float(value))
- }
-}
-
-impl ToValue for bool {
- fn to_value(&self) -> Value {
- Value::from(*self)
- }
-}
-
-impl<'v> From<bool> for Value<'v> {
- fn from(value: bool) -> Self {
- Value::from_primitive(Primitive::Bool(value))
- }
-}
-
-impl ToValue for char {
- fn to_value(&self) -> Value {
- Value::from(*self)
- }
-}
-
-impl<'v> From<char> for Value<'v> {
- fn from(value: char) -> Self {
- Value::from_primitive(Primitive::Char(value))
- }
-}
-
-impl<'v> ToValue for &'v str {
- fn to_value(&self) -> Value {
- Value::from(*self)
- }
-}
-
-impl<'v> From<&'v str> for Value<'v> {
- fn from(value: &'v str) -> Self {
- Value::from_primitive(Primitive::Str(value))
- }
-}
-
-impl ToValue for () {
- fn to_value(&self) -> Value {
- Value::from_primitive(Primitive::None)
- }
-}
-
-impl<T> ToValue for Option<T>
-where
- T: ToValue,
-{
- fn to_value(&self) -> Value {
- match *self {
- Some(ref value) => value.to_value(),
- None => Value::from_primitive(Primitive::None),
- }
- }
-}
-
-impl<'v> ToValue for fmt::Arguments<'v> {
- fn to_value(&self) -> Value {
- Value::from_debug(self)
- }
-}
-
-#[cfg(feature = "std")]
-mod std_support {
- use super::*;
-
- use std::borrow::Cow;
-
- impl<T> ToValue for Box<T>
- where
- T: ToValue + ?Sized,
- {
- fn to_value(&self) -> Value {
- (**self).to_value()
- }
- }
-
- impl ToValue for String {
- fn to_value(&self) -> Value {
- Value::from_primitive(Primitive::Str(&*self))
- }
- }
-
- impl<'v> ToValue for Cow<'v, str> {
- fn to_value(&self) -> Value {
- Value::from_primitive(Primitive::Str(&*self))
- }
- }
-}
-
-#[cfg(test)]
-mod tests {
- use super::*;
- use kv::value::test::Token;
-
- #[test]
- fn test_to_value_display() {
- assert_eq!(42u64.to_value().to_string(), "42");
- assert_eq!(42i64.to_value().to_string(), "42");
- assert_eq!(42.01f64.to_value().to_string(), "42.01");
- assert_eq!(true.to_value().to_string(), "true");
- assert_eq!('a'.to_value().to_string(), "'a'");
- assert_eq!(format_args!("a {}", "value").to_value().to_string(), "a value");
- assert_eq!("a loong string".to_value().to_string(), "\"a loong string\"");
- assert_eq!(Some(true).to_value().to_string(), "true");
- assert_eq!(().to_value().to_string(), "None");
- assert_eq!(Option::None::<bool>.to_value().to_string(), "None");
- }
-
- #[test]
- fn test_to_value_structured() {
- assert_eq!(42u64.to_value().to_token(), Token::U64(42));
- assert_eq!(42i64.to_value().to_token(), Token::I64(42));
- assert_eq!(42.01f64.to_value().to_token(), Token::F64(42.01));
- assert_eq!(true.to_value().to_token(), Token::Bool(true));
- assert_eq!('a'.to_value().to_token(), Token::Char('a'));
- assert_eq!(format_args!("a {}", "value").to_value().to_token(), Token::Str("a value".into()));
- assert_eq!("a loong string".to_value().to_token(), Token::Str("a loong string".into()));
- assert_eq!(Some(true).to_value().to_token(), Token::Bool(true));
- assert_eq!(().to_value().to_token(), Token::None);
- assert_eq!(Option::None::<bool>.to_value().to_token(), Token::None);
- }
-}
+//! Converting standard types into `Value`s.
+//!
+//! This module provides `ToValue` implementations for commonly
+//! logged types from the standard library.
+
+use std::fmt;
+
+use super::{Primitive, ToValue, Value};
+
+macro_rules! impl_into_owned {
+ ($($into_ty:ty => $convert:ident,)*) => {
+ $(
+ impl ToValue for $into_ty {
+ fn to_value(&self) -> Value {
+ Value::from(*self)
+ }
+ }
+
+ impl<'v> From<$into_ty> for Value<'v> {
+ fn from(value: $into_ty) -> Self {
+ Value::from_primitive(value as $convert)
+ }
+ }
+ )*
+ };
+}
+
+impl<'v> ToValue for &'v str {
+ fn to_value(&self) -> Value {
+ Value::from(*self)
+ }
+}
+
+impl<'v> From<&'v str> for Value<'v> {
+ fn from(value: &'v str) -> Self {
+ Value::from_primitive(value)
+ }
+}
+
+impl<'v> ToValue for fmt::Arguments<'v> {
+ fn to_value(&self) -> Value {
+ Value::from(*self)
+ }
+}
+
+impl<'v> From<fmt::Arguments<'v>> for Value<'v> {
+ fn from(value: fmt::Arguments<'v>) -> Self {
+ Value::from_primitive(value)
+ }
+}
+
+impl ToValue for () {
+ fn to_value(&self) -> Value {
+ Value::from_primitive(Primitive::None)
+ }
+}
+
+impl<T> ToValue for Option<T>
+where
+ T: ToValue,
+{
+ fn to_value(&self) -> Value {
+ match *self {
+ Some(ref value) => value.to_value(),
+ None => Value::from_primitive(Primitive::None),
+ }
+ }
+}
+
+impl_into_owned! [
+ usize => u64,
+ u8 => u64,
+ u16 => u64,
+ u32 => u64,
+ u64 => u64,
+
+ isize => i64,
+ i8 => i64,
+ i16 => i64,
+ i32 => i64,
+ i64 => i64,
+
+ f32 => f64,
+ f64 => f64,
+
+ char => char,
+ bool => bool,
+];
+
+#[cfg(feature = "std")]
+mod std_support {
+ use super::*;
+
+ use std::borrow::Cow;
+
+ impl<T> ToValue for Box<T>
+ where
+ T: ToValue + ?Sized,
+ {
+ fn to_value(&self) -> Value {
+ (**self).to_value()
+ }
+ }
+
+ impl ToValue for String {
+ fn to_value(&self) -> Value {
+ Value::from_primitive(Primitive::Str(&*self))
+ }
+ }
+
+ impl<'v> ToValue for Cow<'v, str> {
+ fn to_value(&self) -> Value {
+ Value::from_primitive(Primitive::Str(&*self))
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use kv::value::test::Token;
+
+ #[test]
+ fn test_to_value_display() {
+ assert_eq!(42u64.to_value().to_string(), "42");
+ assert_eq!(42i64.to_value().to_string(), "42");
+ assert_eq!(42.01f64.to_value().to_string(), "42.01");
+ assert_eq!(true.to_value().to_string(), "true");
+ assert_eq!('a'.to_value().to_string(), "a");
+ assert_eq!(
+ format_args!("a {}", "value").to_value().to_string(),
+ "a value"
+ );
+ assert_eq!("a loong string".to_value().to_string(), "a loong string");
+ assert_eq!(Some(true).to_value().to_string(), "true");
+ assert_eq!(().to_value().to_string(), "None");
+ assert_eq!(Option::None::<bool>.to_value().to_string(), "None");
+ }
+
+ #[test]
+ fn test_to_value_structured() {
+ assert_eq!(42u64.to_value().to_token(), Token::U64(42));
+ assert_eq!(42i64.to_value().to_token(), Token::I64(42));
+ assert_eq!(42.01f64.to_value().to_token(), Token::F64(42.01));
+ assert_eq!(true.to_value().to_token(), Token::Bool(true));
+ assert_eq!('a'.to_value().to_token(), Token::Char('a'));
+ assert_eq!(
+ format_args!("a {}", "value").to_value().to_token(),
+ Token::Str("a value".into())
+ );
+ assert_eq!(
+ "a loong string".to_value().to_token(),
+ Token::Str("a loong string".into())
+ );
+ assert_eq!(Some(true).to_value().to_token(), Token::Bool(true));
+ assert_eq!(().to_value().to_token(), Token::None);
+ assert_eq!(Option::None::<bool>.to_value().to_token(), Token::None);
+ }
+}
diff --git a/src/kv/value/internal.rs b/src/kv/value/internal.rs
deleted file mode 100644
index 5f01a31..0000000
--- a/src/kv/value/internal.rs
+++ /dev/null
@@ -1,264 +0,0 @@
-use std::fmt;
-
-use super::{Fill, Slot, Error};
-use kv;
-
-// `Visitor` is an internal API for visiting the structure of a value.
-// It's not intended to be public (at this stage).
-
-/// A container for a structured value for a specific kind of visitor.
-#[derive(Clone, Copy)]
-pub(super) enum Inner<'v> {
- /// A simple primitive value that can be copied without allocating.
- Primitive(Primitive<'v>),
- /// A value that can be filled.
- Fill(&'v Fill),
- /// A debuggable value.
- Debug(&'v fmt::Debug),
- /// A displayable value.
- Display(&'v fmt::Display),
-
- #[cfg(feature = "kv_unstable_sval")]
- /// A structured value from `sval`.
- Sval(&'v sval_support::Value),
-}
-
-impl<'v> Inner<'v> {
- pub(super) fn visit(&self, visitor: &mut Visitor) -> Result<(), Error> {
- match *self {
- Inner::Primitive(value) => match value {
- Primitive::Signed(value) => visitor.i64(value),
- Primitive::Unsigned(value) => visitor.u64(value),
- Primitive::Float(value) => visitor.f64(value),
- Primitive::Bool(value) => visitor.bool(value),
- Primitive::Char(value) => visitor.char(value),
- Primitive::Str(value) => visitor.str(value),
- Primitive::None => visitor.none(),
- },
- Inner::Fill(value) => value.fill(&mut Slot::new(visitor)),
- Inner::Debug(value) => visitor.debug(value),
- Inner::Display(value) => visitor.display(value),
-
- #[cfg(feature = "kv_unstable_sval")]
- Inner::Sval(value) => visitor.sval(value),
- }
- }
-}
-
-/// The internal serialization contract.
-pub(super) trait Visitor {
- fn debug(&mut self, v: &fmt::Debug) -> Result<(), Error>;
- fn display(&mut self, v: &fmt::Display) -> Result<(), Error> {
- self.debug(&format_args!("{}", v))
- }
-
- fn u64(&mut self, v: u64) -> Result<(), Error>;
- fn i64(&mut self, v: i64) -> Result<(), Error>;
- fn f64(&mut self, v: f64) -> Result<(), Error>;
- fn bool(&mut self, v: bool) -> Result<(), Error>;
- fn char(&mut self, v: char) -> Result<(), Error>;
- fn str(&mut self, v: &str) -> Result<(), Error>;
- fn none(&mut self) -> Result<(), Error>;
-
- #[cfg(feature = "kv_unstable_sval")]
- fn sval(&mut self, v: &sval_support::Value) -> Result<(), Error>;
-}
-
-#[derive(Clone, Copy)]
-pub(super) enum Primitive<'v> {
- Signed(i64),
- Unsigned(u64),
- Float(f64),
- Bool(bool),
- Char(char),
- Str(&'v str),
- None,
-}
-
-mod fmt_support {
- use super::*;
-
- impl<'v> kv::Value<'v> {
- /// Get a value from a debuggable type.
- pub fn from_debug<T>(value: &'v T) -> Self
- where
- T: fmt::Debug,
- {
- kv::Value {
- inner: Inner::Debug(value),
- }
- }
-
- /// Get a value from a displayable type.
- pub fn from_display<T>(value: &'v T) -> Self
- where
- T: fmt::Display,
- {
- kv::Value {
- inner: Inner::Display(value),
- }
- }
- }
-
- impl<'v> fmt::Debug for kv::Value<'v> {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- self.visit(&mut FmtVisitor(f))?;
-
- Ok(())
- }
- }
-
- impl<'v> fmt::Display for kv::Value<'v> {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- self.visit(&mut FmtVisitor(f))?;
-
- Ok(())
- }
- }
-
- struct FmtVisitor<'a, 'b: 'a>(&'a mut fmt::Formatter<'b>);
-
- impl<'a, 'b: 'a> Visitor for FmtVisitor<'a, 'b> {
- fn debug(&mut self, v: &fmt::Debug) -> Result<(), Error> {
- v.fmt(self.0)?;
-
- Ok(())
- }
-
- fn u64(&mut self, v: u64) -> Result<(), Error> {
- self.debug(&format_args!("{:?}", v))
- }
-
- fn i64(&mut self, v: i64) -> Result<(), Error> {
- self.debug(&format_args!("{:?}", v))
- }
-
- fn f64(&mut self, v: f64) -> Result<(), Error> {
- self.debug(&format_args!("{:?}", v))
- }
-
- fn bool(&mut self, v: bool) -> Result<(), Error> {
- self.debug(&format_args!("{:?}", v))
- }
-
- fn char(&mut self, v: char) -> Result<(), Error> {
- self.debug(&format_args!("{:?}", v))
- }
-
- fn str(&mut self, v: &str) -> Result<(), Error> {
- self.debug(&format_args!("{:?}", v))
- }
-
- fn none(&mut self) -> Result<(), Error> {
- self.debug(&format_args!("None"))
- }
-
- #[cfg(feature = "kv_unstable_sval")]
- fn sval(&mut self, v: &sval_support::Value) -> Result<(), Error> {
- sval_support::fmt(self.0, v)
- }
- }
-}
-
-#[cfg(feature = "kv_unstable_sval")]
-pub(super) mod sval_support {
- use super::*;
-
- extern crate sval;
-
- impl<'v> kv::Value<'v> {
- /// Get a value from a structured type.
- pub fn from_sval<T>(value: &'v T) -> Self
- where
- T: sval::Value,
- {
- kv::Value {
- inner: Inner::Sval(value),
- }
- }
- }
-
- impl<'v> sval::Value for kv::Value<'v> {
- fn stream(&self, s: &mut sval::value::Stream) -> sval::value::Result {
- self.visit(&mut SvalVisitor(s)).map_err(Error::into_sval)?;
-
- Ok(())
- }
- }
-
- pub(in kv::value) use self::sval::Value;
-
- pub(super) fn fmt(f: &mut fmt::Formatter, v: &sval::Value) -> Result<(), Error> {
- sval::fmt::debug(f, v)?;
- Ok(())
- }
-
- impl Error {
- fn from_sval(_: sval::value::Error) -> Self {
- Error::msg("`sval` serialization failed")
- }
-
- fn into_sval(self) -> sval::value::Error {
- sval::value::Error::msg("`sval` serialization failed")
- }
- }
-
- struct SvalVisitor<'a, 'b: 'a>(&'a mut sval::value::Stream<'b>);
-
- impl<'a, 'b: 'a> Visitor for SvalVisitor<'a, 'b> {
- fn debug(&mut self, v: &fmt::Debug) -> Result<(), Error> {
- self.0.fmt(format_args!("{:?}", v)).map_err(Error::from_sval)
- }
-
- fn u64(&mut self, v: u64) -> Result<(), Error> {
- self.0.u64(v).map_err(Error::from_sval)
- }
-
- fn i64(&mut self, v: i64) -> Result<(), Error> {
- self.0.i64(v).map_err(Error::from_sval)
- }
-
- fn f64(&mut self, v: f64) -> Result<(), Error> {
- self.0.f64(v).map_err(Error::from_sval)
- }
-
- fn bool(&mut self, v: bool) -> Result<(), Error> {
- self.0.bool(v).map_err(Error::from_sval)
- }
-
- fn char(&mut self, v: char) -> Result<(), Error> {
- self.0.char(v).map_err(Error::from_sval)
- }
-
- fn str(&mut self, v: &str) -> Result<(), Error> {
- self.0.str(v).map_err(Error::from_sval)
- }
-
- fn none(&mut self) -> Result<(), Error> {
- self.0.none().map_err(Error::from_sval)
- }
-
- fn sval(&mut self, v: &sval::Value) -> Result<(), Error> {
- self.0.any(v).map_err(Error::from_sval)
- }
- }
-
- #[cfg(test)]
- mod tests {
- use super::*;
- use kv::value::test::Token;
-
- #[test]
- fn test_from_sval() {
- assert_eq!(kv::Value::from_sval(&42u64).to_token(), Token::Sval);
- }
-
- #[test]
- fn test_sval_structured() {
- let value = kv::Value::from(42u64);
- let expected = vec![sval::test::Token::Unsigned(42)];
-
- assert_eq!(sval::test::tokens(value), expected);
- }
- }
-}
diff --git a/src/kv/value/internal/cast.rs b/src/kv/value/internal/cast.rs
new file mode 100644
index 0000000..aaa4b07
--- /dev/null
+++ b/src/kv/value/internal/cast.rs
@@ -0,0 +1,475 @@
+//! Coerce a `Value` into some concrete types.
+//!
+//! These operations are cheap when the captured value is a simple primitive,
+//! but may end up executing arbitrary caller code if the value is complex.
+//! They will also attempt to downcast erased types into a primitive where possible.
+
+use std::any::TypeId;
+use std::fmt;
+
+use super::{Erased, Inner, Primitive, Visitor};
+use crate::kv::value::{Error, Value};
+
+impl<'v> Value<'v> {
+ /// Try get a `usize` from this value.
+ ///
+ /// This method is cheap for primitive types, but may call arbitrary
+ /// serialization implementations for complex ones.
+ pub fn to_usize(&self) -> Option<usize> {
+ self.inner
+ .cast()
+ .into_primitive()
+ .into_u64()
+ .map(|v| v as usize)
+ }
+
+ /// Try get a `u8` from this value.
+ ///
+ /// This method is cheap for primitive types, but may call arbitrary
+ /// serialization implementations for complex ones.
+ pub fn to_u8(&self) -> Option<u8> {
+ self.inner
+ .cast()
+ .into_primitive()
+ .into_u64()
+ .map(|v| v as u8)
+ }
+
+ /// Try get a `u16` from this value.
+ ///
+ /// This method is cheap for primitive types, but may call arbitrary
+ /// serialization implementations for complex ones.
+ pub fn to_u16(&self) -> Option<u16> {
+ self.inner
+ .cast()
+ .into_primitive()
+ .into_u64()
+ .map(|v| v as u16)
+ }
+
+ /// Try get a `u32` from this value.
+ ///
+ /// This method is cheap for primitive types, but may call arbitrary
+ /// serialization implementations for complex ones.
+ pub fn to_u32(&self) -> Option<u32> {
+ self.inner
+ .cast()
+ .into_primitive()
+ .into_u64()
+ .map(|v| v as u32)
+ }
+
+ /// Try get a `u64` from this value.
+ ///
+ /// This method is cheap for primitive types, but may call arbitrary
+ /// serialization implementations for complex ones.
+ pub fn to_u64(&self) -> Option<u64> {
+ self.inner.cast().into_primitive().into_u64()
+ }
+
+ /// Try get a `isize` from this value.
+ ///
+ /// This method is cheap for primitive types, but may call arbitrary
+ /// serialization implementations for complex ones.
+ pub fn to_isize(&self) -> Option<isize> {
+ self.inner
+ .cast()
+ .into_primitive()
+ .into_i64()
+ .map(|v| v as isize)
+ }
+
+ /// Try get a `i8` from this value.
+ ///
+ /// This method is cheap for primitive types, but may call arbitrary
+ /// serialization implementations for complex ones.
+ pub fn to_i8(&self) -> Option<i8> {
+ self.inner
+ .cast()
+ .into_primitive()
+ .into_i64()
+ .map(|v| v as i8)
+ }
+
+ /// Try get a `i16` from this value.
+ ///
+ /// This method is cheap for primitive types, but may call arbitrary
+ /// serialization implementations for complex ones.
+ pub fn to_i16(&self) -> Option<i16> {
+ self.inner
+ .cast()
+ .into_primitive()
+ .into_i64()
+ .map(|v| v as i16)
+ }
+
+ /// Try get a `i32` from this value.
+ ///
+ /// This method is cheap for primitive types, but may call arbitrary
+ /// serialization implementations for complex ones.
+ pub fn to_i32(&self) -> Option<i32> {
+ self.inner
+ .cast()
+ .into_primitive()
+ .into_i64()
+ .map(|v| v as i32)
+ }
+
+ /// Try get a `i64` from this value.
+ ///
+ /// This method is cheap for primitive types, but may call arbitrary
+ /// serialization implementations for complex ones.
+ pub fn to_i64(&self) -> Option<i64> {
+ self.inner.cast().into_primitive().into_i64()
+ }
+
+ /// Try get a `f32` from this value.
+ ///
+ /// This method is cheap for primitive types, but may call arbitrary
+ /// serialization implementations for complex ones.
+ pub fn to_f32(&self) -> Option<f32> {
+ self.inner
+ .cast()
+ .into_primitive()
+ .into_f64()
+ .map(|v| v as f32)
+ }
+
+ /// Try get a `f64` from this value.
+ ///
+ /// This method is cheap for primitive types, but may call arbitrary
+ /// serialization implementations for complex ones.
+ pub fn to_f64(&self) -> Option<f64> {
+ self.inner.cast().into_primitive().into_f64()
+ }
+
+ /// Try get a `bool` from this value.
+ ///
+ /// This method is cheap for primitive types, but may call arbitrary
+ /// serialization implementations for complex ones.
+ pub fn to_bool(&self) -> Option<bool> {
+ self.inner.cast().into_primitive().into_bool()
+ }
+
+ /// Try get a `char` from this value.
+ ///
+ /// This method is cheap for primitive types, but may call arbitrary
+ /// serialization implementations for complex ones.
+ pub fn to_char(&self) -> Option<char> {
+ self.inner.cast().into_primitive().into_char()
+ }
+
+ /// Try get a `str` from this value.
+ ///
+ /// This method is cheap for primitive types. It won't allocate an owned
+ /// `String` if the value is a complex type.
+ pub fn to_borrowed_str(&self) -> Option<&str> {
+ self.inner.cast().into_primitive().into_borrowed_str()
+ }
+}
+
+impl<'v> Inner<'v> {
+ /// Cast the inner value to another type.
+ fn cast(self) -> Cast<'v> {
+ struct CastVisitor<'v>(Cast<'v>);
+
+ impl<'v> Visitor<'v> for CastVisitor<'v> {
+ fn debug(&mut self, _: &dyn fmt::Debug) -> Result<(), Error> {
+ Ok(())
+ }
+
+ fn u64(&mut self, v: u64) -> Result<(), Error> {
+ self.0 = Cast::Primitive(Primitive::Unsigned(v));
+ Ok(())
+ }
+
+ fn i64(&mut self, v: i64) -> Result<(), Error> {
+ self.0 = Cast::Primitive(Primitive::Signed(v));
+ Ok(())
+ }
+
+ fn f64(&mut self, v: f64) -> Result<(), Error> {
+ self.0 = Cast::Primitive(Primitive::Float(v));
+ Ok(())
+ }
+
+ fn bool(&mut self, v: bool) -> Result<(), Error> {
+ self.0 = Cast::Primitive(Primitive::Bool(v));
+ Ok(())
+ }
+
+ fn char(&mut self, v: char) -> Result<(), Error> {
+ self.0 = Cast::Primitive(Primitive::Char(v));
+ Ok(())
+ }
+
+ fn borrowed_str(&mut self, v: &'v str) -> Result<(), Error> {
+ self.0 = Cast::Primitive(Primitive::Str(v));
+ Ok(())
+ }
+
+ #[cfg(not(feature = "std"))]
+ fn str(&mut self, _: &str) -> Result<(), Error> {
+ Ok(())
+ }
+
+ #[cfg(feature = "std")]
+ fn str(&mut self, v: &str) -> Result<(), Error> {
+ self.0 = Cast::String(v.into());
+ Ok(())
+ }
+
+ fn none(&mut self) -> Result<(), Error> {
+ self.0 = Cast::Primitive(Primitive::None);
+ Ok(())
+ }
+
+ #[cfg(feature = "kv_unstable_sval")]
+ fn sval(&mut self, v: &dyn super::sval::Value) -> Result<(), Error> {
+ self.0 = super::sval::cast(v);
+ Ok(())
+ }
+ }
+
+ // Try downcast an erased value first
+ // It also lets us avoid the Visitor infrastructure for simple primitives
+ let primitive = match self {
+ Inner::Primitive(value) => Some(value),
+ Inner::Fill(value) => value.downcast_primitive(),
+ Inner::Debug(value) => value.downcast_primitive(),
+ Inner::Display(value) => value.downcast_primitive(),
+
+ #[cfg(feature = "sval")]
+ Inner::Sval(value) => value.downcast_primitive(),
+ };
+
+ primitive.map(Cast::Primitive).unwrap_or_else(|| {
+ // If the erased value isn't a primitive then we visit it
+ let mut cast = CastVisitor(Cast::Primitive(Primitive::None));
+ let _ = self.visit(&mut cast);
+ cast.0
+ })
+ }
+}
+
+pub(super) enum Cast<'v> {
+ Primitive(Primitive<'v>),
+ #[cfg(feature = "std")]
+ String(String),
+}
+
+impl<'v> Cast<'v> {
+ fn into_primitive(self) -> Primitive<'v> {
+ match self {
+ Cast::Primitive(value) => value,
+ #[cfg(feature = "std")]
+ _ => Primitive::None,
+ }
+ }
+}
+
+impl<'v> Primitive<'v> {
+ fn into_borrowed_str(self) -> Option<&'v str> {
+ if let Primitive::Str(value) = self {
+ Some(value)
+ } else {
+ None
+ }
+ }
+
+ fn into_u64(self) -> Option<u64> {
+ match self {
+ Primitive::Unsigned(value) => Some(value),
+ Primitive::Signed(value) => Some(value as u64),
+ Primitive::Float(value) => Some(value as u64),
+ _ => None,
+ }
+ }
+
+ fn into_i64(self) -> Option<i64> {
+ match self {
+ Primitive::Signed(value) => Some(value),
+ Primitive::Unsigned(value) => Some(value as i64),
+ Primitive::Float(value) => Some(value as i64),
+ _ => None,
+ }
+ }
+
+ fn into_f64(self) -> Option<f64> {
+ match self {
+ Primitive::Float(value) => Some(value),
+ Primitive::Unsigned(value) => Some(value as f64),
+ Primitive::Signed(value) => Some(value as f64),
+ _ => None,
+ }
+ }
+
+ fn into_char(self) -> Option<char> {
+ if let Primitive::Char(value) = self {
+ Some(value)
+ } else {
+ None
+ }
+ }
+
+ fn into_bool(self) -> Option<bool> {
+ if let Primitive::Bool(value) = self {
+ Some(value)
+ } else {
+ None
+ }
+ }
+}
+
+impl<'v, T: ?Sized + 'static> Erased<'v, T> {
+ // NOTE: This function is a perfect candidate for memoization
+ // The outcome could be stored in a `Cell<Primitive>`
+ fn downcast_primitive(self) -> Option<Primitive<'v>> {
+ macro_rules! type_ids {
+ ($($value:ident : $ty:ty => $cast:expr,)*) => {{
+ struct TypeIds;
+
+ impl TypeIds {
+ fn downcast_primitive<'v, T: ?Sized>(&self, value: Erased<'v, T>) -> Option<Primitive<'v>> {
+ $(
+ if TypeId::of::<$ty>() == value.type_id {
+ let $value = unsafe { value.downcast_unchecked::<$ty>() };
+ return Some(Primitive::from($cast));
+ }
+ )*
+
+ None
+ }
+ }
+
+ TypeIds
+ }};
+ }
+
+ let type_ids = type_ids![
+ value: usize => *value as u64,
+ value: u8 => *value as u64,
+ value: u16 => *value as u64,
+ value: u32 => *value as u64,
+ value: u64 => *value,
+
+ value: isize => *value as i64,
+ value: i8 => *value as i64,
+ value: i16 => *value as i64,
+ value: i32 => *value as i64,
+ value: i64 => *value,
+
+ value: f32 => *value as f64,
+ value: f64 => *value,
+
+ value: char => *value,
+ value: bool => *value,
+
+ value: &str => *value,
+ ];
+
+ type_ids.downcast_primitive(self)
+ }
+}
+
+#[cfg(feature = "std")]
+mod std_support {
+ use super::*;
+
+ use std::borrow::Cow;
+
+ impl<'v> Value<'v> {
+ /// Try get a `usize` from this value.
+ ///
+ /// This method is cheap for primitive types, but may call arbitrary
+ /// serialization implementations for complex ones. If the serialization
+ /// implementation produces a short lived string it will be allocated.
+ pub fn to_str(&self) -> Option<Cow<str>> {
+ self.inner.cast().into_str()
+ }
+ }
+
+ impl<'v> Cast<'v> {
+ pub(super) fn into_str(self) -> Option<Cow<'v, str>> {
+ match self {
+ Cast::Primitive(Primitive::Str(value)) => Some(value.into()),
+ Cast::String(value) => Some(value.into()),
+ _ => None,
+ }
+ }
+ }
+
+ #[cfg(test)]
+ mod tests {
+ use crate::kv::ToValue;
+
+ #[test]
+ fn primitive_cast() {
+ assert_eq!(
+ "a string",
+ "a string"
+ .to_owned()
+ .to_value()
+ .to_borrowed_str()
+ .expect("invalid value")
+ );
+ assert_eq!(
+ "a string",
+ &*"a string".to_value().to_str().expect("invalid value")
+ );
+ assert_eq!(
+ "a string",
+ &*"a string"
+ .to_owned()
+ .to_value()
+ .to_str()
+ .expect("invalid value")
+ );
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use crate::kv::ToValue;
+
+ #[test]
+ fn primitive_cast() {
+ assert_eq!(
+ "a string",
+ "a string"
+ .to_value()
+ .to_borrowed_str()
+ .expect("invalid value")
+ );
+ assert_eq!(
+ "a string",
+ Some("a string")
+ .to_value()
+ .to_borrowed_str()
+ .expect("invalid value")
+ );
+
+ assert_eq!(1u8, 1u64.to_value().to_u8().expect("invalid value"));
+ assert_eq!(1u16, 1u64.to_value().to_u16().expect("invalid value"));
+ assert_eq!(1u32, 1u64.to_value().to_u32().expect("invalid value"));
+ assert_eq!(1u64, 1u64.to_value().to_u64().expect("invalid value"));
+ assert_eq!(1usize, 1u64.to_value().to_usize().expect("invalid value"));
+
+ assert_eq!(-1i8, -1i64.to_value().to_i8().expect("invalid value"));
+ assert_eq!(-1i16, -1i64.to_value().to_i16().expect("invalid value"));
+ assert_eq!(-1i32, -1i64.to_value().to_i32().expect("invalid value"));
+ assert_eq!(-1i64, -1i64.to_value().to_i64().expect("invalid value"));
+ assert_eq!(-1isize, -1i64.to_value().to_isize().expect("invalid value"));
+
+ assert!(1f32.to_value().to_f32().is_some(), "invalid value");
+ assert!(1f64.to_value().to_f64().is_some(), "invalid value");
+
+ assert_eq!(1u32, 1i64.to_value().to_u32().expect("invalid value"));
+ assert_eq!(1i32, 1u64.to_value().to_i32().expect("invalid value"));
+ assert!(1f32.to_value().to_i32().is_some(), "invalid value");
+
+ assert_eq!('a', 'a'.to_value().to_char().expect("invalid value"));
+ assert_eq!(true, true.to_value().to_bool().expect("invalid value"));
+ }
+}
diff --git a/src/kv/value/internal/fmt.rs b/src/kv/value/internal/fmt.rs
new file mode 100644
index 0000000..66817d4
--- /dev/null
+++ b/src/kv/value/internal/fmt.rs
@@ -0,0 +1,249 @@
+//! Integration between `Value` and `std::fmt`.
+//!
+//! This module allows any `Value` to implement the `fmt::Debug` and `fmt::Display` traits,
+//! and for any `fmt::Debug` or `fmt::Display` to be captured as a `Value`.
+
+use std::fmt;
+
+use super::{Erased, Inner, Visitor};
+use crate::kv;
+use crate::kv::value::{Error, Slot};
+
+impl<'v> kv::Value<'v> {
+ /// Get a value from a debuggable type.
+ pub fn from_debug<T>(value: &'v T) -> Self
+ where
+ T: fmt::Debug + 'static,
+ {
+ kv::Value {
+ inner: Inner::Debug(unsafe { Erased::new_unchecked::<T>(value) }),
+ }
+ }
+
+ /// Get a value from a displayable type.
+ pub fn from_display<T>(value: &'v T) -> Self
+ where
+ T: fmt::Display + 'static,
+ {
+ kv::Value {
+ inner: Inner::Display(unsafe { Erased::new_unchecked::<T>(value) }),
+ }
+ }
+}
+
+impl<'s, 'f> Slot<'s, 'f> {
+ /// Fill the slot with a debuggable value.
+ ///
+ /// The given value doesn't need to satisfy any particular lifetime constraints.
+ ///
+ /// # Panics
+ ///
+ /// Calling more than a single `fill` method on this slot will panic.
+ pub fn fill_debug<T>(&mut self, value: T) -> Result<(), Error>
+ where
+ T: fmt::Debug,
+ {
+ self.fill(|visitor| visitor.debug(&value))
+ }
+
+ /// Fill the slot with a displayable value.
+ ///
+ /// The given value doesn't need to satisfy any particular lifetime constraints.
+ ///
+ /// # Panics
+ ///
+ /// Calling more than a single `fill` method on this slot will panic.
+ pub fn fill_display<T>(&mut self, value: T) -> Result<(), Error>
+ where
+ T: fmt::Display,
+ {
+ self.fill(|visitor| visitor.display(&value))
+ }
+}
+
+pub(in kv::value) use self::fmt::{Arguments, Debug, Display};
+
+impl<'v> fmt::Debug for kv::Value<'v> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ struct DebugVisitor<'a, 'b: 'a>(&'a mut fmt::Formatter<'b>);
+
+ impl<'a, 'b: 'a, 'v> Visitor<'v> for DebugVisitor<'a, 'b> {
+ fn debug(&mut self, v: &dyn fmt::Debug) -> Result<(), Error> {
+ fmt::Debug::fmt(v, self.0)?;
+
+ Ok(())
+ }
+
+ fn display(&mut self, v: &dyn fmt::Display) -> Result<(), Error> {
+ fmt::Display::fmt(v, self.0)?;
+
+ Ok(())
+ }
+
+ fn u64(&mut self, v: u64) -> Result<(), Error> {
+ fmt::Debug::fmt(&v, self.0)?;
+
+ Ok(())
+ }
+
+ fn i64(&mut self, v: i64) -> Result<(), Error> {
+ fmt::Debug::fmt(&v, self.0)?;
+
+ Ok(())
+ }
+
+ fn f64(&mut self, v: f64) -> Result<(), Error> {
+ fmt::Debug::fmt(&v, self.0)?;
+
+ Ok(())
+ }
+
+ fn bool(&mut self, v: bool) -> Result<(), Error> {
+ fmt::Debug::fmt(&v, self.0)?;
+
+ Ok(())
+ }
+
+ fn char(&mut self, v: char) -> Result<(), Error> {
+ fmt::Debug::fmt(&v, self.0)?;
+
+ Ok(())
+ }
+
+ fn str(&mut self, v: &str) -> Result<(), Error> {
+ fmt::Debug::fmt(&v, self.0)?;
+
+ Ok(())
+ }
+
+ fn none(&mut self) -> Result<(), Error> {
+ self.debug(&format_args!("None"))
+ }
+
+ #[cfg(feature = "kv_unstable_sval")]
+ fn sval(&mut self, v: &dyn super::sval::Value) -> Result<(), Error> {
+ super::sval::fmt(self.0, v)
+ }
+ }
+
+ self.visit(&mut DebugVisitor(f)).map_err(|_| fmt::Error)?;
+
+ Ok(())
+ }
+}
+
+impl<'v> fmt::Display for kv::Value<'v> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ struct DisplayVisitor<'a, 'b: 'a>(&'a mut fmt::Formatter<'b>);
+
+ impl<'a, 'b: 'a, 'v> Visitor<'v> for DisplayVisitor<'a, 'b> {
+ fn debug(&mut self, v: &dyn fmt::Debug) -> Result<(), Error> {
+ fmt::Debug::fmt(v, self.0)?;
+
+ Ok(())
+ }
+
+ fn display(&mut self, v: &dyn fmt::Display) -> Result<(), Error> {
+ fmt::Display::fmt(v, self.0)?;
+
+ Ok(())
+ }
+
+ fn u64(&mut self, v: u64) -> Result<(), Error> {
+ fmt::Display::fmt(&v, self.0)?;
+
+ Ok(())
+ }
+
+ fn i64(&mut self, v: i64) -> Result<(), Error> {
+ fmt::Display::fmt(&v, self.0)?;
+
+ Ok(())
+ }
+
+ fn f64(&mut self, v: f64) -> Result<(), Error> {
+ fmt::Display::fmt(&v, self.0)?;
+
+ Ok(())
+ }
+
+ fn bool(&mut self, v: bool) -> Result<(), Error> {
+ fmt::Display::fmt(&v, self.0)?;
+
+ Ok(())
+ }
+
+ fn char(&mut self, v: char) -> Result<(), Error> {
+ fmt::Display::fmt(&v, self.0)?;
+
+ Ok(())
+ }
+
+ fn str(&mut self, v: &str) -> Result<(), Error> {
+ fmt::Display::fmt(&v, self.0)?;
+
+ Ok(())
+ }
+
+ fn none(&mut self) -> Result<(), Error> {
+ self.debug(&format_args!("None"))
+ }
+
+ #[cfg(feature = "kv_unstable_sval")]
+ fn sval(&mut self, v: &dyn super::sval::Value) -> Result<(), Error> {
+ super::sval::fmt(self.0, v)
+ }
+ }
+
+ self.visit(&mut DisplayVisitor(f)).map_err(|_| fmt::Error)?;
+
+ Ok(())
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ use crate::kv::value::ToValue;
+
+ #[test]
+ fn fmt_cast() {
+ assert_eq!(
+ 42u32,
+ kv::Value::from_debug(&42u64)
+ .to_u32()
+ .expect("invalid value")
+ );
+
+ assert_eq!(
+ "a string",
+ kv::Value::from_display(&"a string")
+ .to_borrowed_str()
+ .expect("invalid value")
+ );
+ }
+
+ #[test]
+ fn fmt_debug() {
+ assert_eq!(
+ format!("{:?}", "a string"),
+ format!("{:?}", "a string".to_value()),
+ );
+
+ assert_eq!(
+ format!("{:04?}", 42u64),
+ format!("{:04?}", 42u64.to_value()),
+ );
+ }
+
+ #[test]
+ fn fmt_display() {
+ assert_eq!(
+ format!("{}", "a string"),
+ format!("{}", "a string".to_value()),
+ );
+
+ assert_eq!(format!("{:04}", 42u64), format!("{:04}", 42u64.to_value()),);
+ }
+}
diff --git a/src/kv/value/internal/mod.rs b/src/kv/value/internal/mod.rs
new file mode 100644
index 0000000..01b72a7
--- /dev/null
+++ b/src/kv/value/internal/mod.rs
@@ -0,0 +1,181 @@
+//! The internal `Value` serialization API.
+//!
+//! This implementation isn't intended to be public. It may need to change
+//! for optimizations or to support new external serialization frameworks.
+
+use std::any::TypeId;
+
+use super::{Error, Fill, Slot};
+
+pub(super) mod cast;
+pub(super) mod fmt;
+#[cfg(feature = "kv_unstable_sval")]
+pub(super) mod sval;
+
+/// A container for a structured value for a specific kind of visitor.
+#[derive(Clone, Copy)]
+pub(super) enum Inner<'v> {
+ /// A simple primitive value that can be copied without allocating.
+ Primitive(Primitive<'v>),
+ /// A value that can be filled.
+ Fill(Erased<'v, dyn Fill + 'static>),
+ /// A debuggable value.
+ Debug(Erased<'v, dyn fmt::Debug + 'static>),
+ /// A displayable value.
+ Display(Erased<'v, dyn fmt::Display + 'static>),
+
+ #[cfg(feature = "kv_unstable_sval")]
+ /// A structured value from `sval`.
+ Sval(Erased<'v, dyn sval::Value + 'static>),
+}
+
+impl<'v> Inner<'v> {
+ pub(super) fn visit(self, visitor: &mut dyn Visitor<'v>) -> Result<(), Error> {
+ match self {
+ Inner::Primitive(value) => value.visit(visitor),
+ Inner::Fill(value) => value.get().fill(&mut Slot::new(visitor)),
+ Inner::Debug(value) => visitor.debug(value.get()),
+ Inner::Display(value) => visitor.display(value.get()),
+
+ #[cfg(feature = "kv_unstable_sval")]
+ Inner::Sval(value) => visitor.sval(value.get()),
+ }
+ }
+}
+
+/// The internal serialization contract.
+pub(super) trait Visitor<'v> {
+ fn debug(&mut self, v: &dyn fmt::Debug) -> Result<(), Error>;
+ fn display(&mut self, v: &dyn fmt::Display) -> Result<(), Error> {
+ self.debug(&format_args!("{}", v))
+ }
+
+ fn u64(&mut self, v: u64) -> Result<(), Error>;
+ fn i64(&mut self, v: i64) -> Result<(), Error>;
+ fn f64(&mut self, v: f64) -> Result<(), Error>;
+ fn bool(&mut self, v: bool) -> Result<(), Error>;
+ fn char(&mut self, v: char) -> Result<(), Error>;
+
+ fn str(&mut self, v: &str) -> Result<(), Error>;
+ fn borrowed_str(&mut self, v: &'v str) -> Result<(), Error> {
+ self.str(v)
+ }
+
+ fn none(&mut self) -> Result<(), Error>;
+
+ #[cfg(feature = "kv_unstable_sval")]
+ fn sval(&mut self, v: &dyn sval::Value) -> Result<(), Error>;
+}
+
+/// A captured primitive value.
+///
+/// These values are common and cheap to copy around.
+#[derive(Clone, Copy)]
+pub(super) enum Primitive<'v> {
+ Signed(i64),
+ Unsigned(u64),
+ Float(f64),
+ Bool(bool),
+ Char(char),
+ Str(&'v str),
+ Fmt(fmt::Arguments<'v>),
+ None,
+}
+
+impl<'v> Primitive<'v> {
+ fn visit(self, visitor: &mut dyn Visitor<'v>) -> Result<(), Error> {
+ match self {
+ Primitive::Signed(value) => visitor.i64(value),
+ Primitive::Unsigned(value) => visitor.u64(value),
+ Primitive::Float(value) => visitor.f64(value),
+ Primitive::Bool(value) => visitor.bool(value),
+ Primitive::Char(value) => visitor.char(value),
+ Primitive::Str(value) => visitor.borrowed_str(value),
+ Primitive::Fmt(value) => visitor.debug(&value),
+ Primitive::None => visitor.none(),
+ }
+ }
+}
+
+impl<'v> From<u64> for Primitive<'v> {
+ fn from(v: u64) -> Self {
+ Primitive::Unsigned(v)
+ }
+}
+
+impl<'v> From<i64> for Primitive<'v> {
+ fn from(v: i64) -> Self {
+ Primitive::Signed(v)
+ }
+}
+
+impl<'v> From<f64> for Primitive<'v> {
+ fn from(v: f64) -> Self {
+ Primitive::Float(v)
+ }
+}
+
+impl<'v> From<bool> for Primitive<'v> {
+ fn from(v: bool) -> Self {
+ Primitive::Bool(v)
+ }
+}
+
+impl<'v> From<char> for Primitive<'v> {
+ fn from(v: char) -> Self {
+ Primitive::Char(v)
+ }
+}
+
+impl<'v> From<&'v str> for Primitive<'v> {
+ fn from(v: &'v str) -> Self {
+ Primitive::Str(v)
+ }
+}
+
+impl<'v> From<fmt::Arguments<'v>> for Primitive<'v> {
+ fn from(v: fmt::Arguments<'v>) -> Self {
+ Primitive::Fmt(v)
+ }
+}
+
+/// A downcastable dynamic type.
+pub(super) struct Erased<'v, T: ?Sized> {
+ type_id: TypeId,
+ inner: &'v T,
+}
+
+impl<'v, T: ?Sized> Clone for Erased<'v, T> {
+ fn clone(&self) -> Self {
+ Erased {
+ type_id: self.type_id,
+ inner: self.inner,
+ }
+ }
+}
+
+impl<'v, T: ?Sized> Copy for Erased<'v, T> {}
+
+impl<'v, T: ?Sized> Erased<'v, T> {
+ // SAFETY: `U: Unsize<T>` and the underlying value `T` must not change
+ // We could add a safe variant of this method with the `Unsize` trait
+ pub(super) unsafe fn new_unchecked<U>(inner: &'v T) -> Self
+ where
+ U: 'static,
+ T: 'static,
+ {
+ Erased {
+ type_id: TypeId::of::<U>(),
+ inner,
+ }
+ }
+
+ pub(super) fn get(self) -> &'v T {
+ self.inner
+ }
+
+ // SAFETY: The underlying type of `T` is `U`
+ pub(super) unsafe fn downcast_unchecked<U>(self) -> &'v U {
+ &*(self.inner as *const T as *const U)
+ }
+}
diff --git a/src/kv/value/internal/sval.rs b/src/kv/value/internal/sval.rs
new file mode 100644
index 0000000..618a036
--- /dev/null
+++ b/src/kv/value/internal/sval.rs
@@ -0,0 +1,210 @@
+//! Integration between `Value` and `sval`.
+//!
+//! This module allows any `Value` to implement the `sval::Value` trait,
+//! and for any `sval::Value` to be captured as a `Value`.
+
+extern crate sval;
+
+use std::fmt;
+
+use super::cast::Cast;
+use super::{Erased, Inner, Primitive, Visitor};
+use crate::kv;
+use crate::kv::value::{Error, Slot};
+
+impl<'v> kv::Value<'v> {
+ /// Get a value from a structured type.
+ pub fn from_sval<T>(value: &'v T) -> Self
+ where
+ T: sval::Value + 'static,
+ {
+ kv::Value {
+ inner: Inner::Sval(unsafe { Erased::new_unchecked::<T>(value) }),
+ }
+ }
+}
+
+impl<'s, 'f> Slot<'s, 'f> {
+ /// Fill the slot with a structured value.
+ ///
+ /// The given value doesn't need to satisfy any particular lifetime constraints.
+ ///
+ /// # Panics
+ ///
+ /// Calling more than a single `fill` method on this slot will panic.
+ pub fn fill_sval<T>(&mut self, value: T) -> Result<(), Error>
+ where
+ T: sval::Value,
+ {
+ self.fill(|visitor| visitor.sval(&value))
+ }
+}
+
+impl<'v> sval::Value for kv::Value<'v> {
+ fn stream(&self, s: &mut sval::value::Stream) -> sval::value::Result {
+ struct SvalVisitor<'a, 'b: 'a>(&'a mut sval::value::Stream<'b>);
+
+ impl<'a, 'b: 'a, 'v> Visitor<'v> for SvalVisitor<'a, 'b> {
+ fn debug(&mut self, v: &dyn fmt::Debug) -> Result<(), Error> {
+ self.0
+ .fmt(format_args!("{:?}", v))
+ .map_err(Error::from_sval)
+ }
+
+ fn u64(&mut self, v: u64) -> Result<(), Error> {
+ self.0.u64(v).map_err(Error::from_sval)
+ }
+
+ fn i64(&mut self, v: i64) -> Result<(), Error> {
+ self.0.i64(v).map_err(Error::from_sval)
+ }
+
+ fn f64(&mut self, v: f64) -> Result<(), Error> {
+ self.0.f64(v).map_err(Error::from_sval)
+ }
+
+ fn bool(&mut self, v: bool) -> Result<(), Error> {
+ self.0.bool(v).map_err(Error::from_sval)
+ }
+
+ fn char(&mut self, v: char) -> Result<(), Error> {
+ self.0.char(v).map_err(Error::from_sval)
+ }
+
+ fn str(&mut self, v: &str) -> Result<(), Error> {
+ self.0.str(v).map_err(Error::from_sval)
+ }
+
+ fn none(&mut self) -> Result<(), Error> {
+ self.0.none().map_err(Error::from_sval)
+ }
+
+ fn sval(&mut self, v: &dyn sval::Value) -> Result<(), Error> {
+ self.0.any(v).map_err(Error::from_sval)
+ }
+ }
+
+ self.visit(&mut SvalVisitor(s)).map_err(Error::into_sval)?;
+
+ Ok(())
+ }
+}
+
+pub(in kv::value) use self::sval::Value;
+
+pub(super) fn fmt(f: &mut fmt::Formatter, v: &dyn sval::Value) -> Result<(), Error> {
+ sval::fmt::debug(f, v)?;
+ Ok(())
+}
+
+pub(super) fn cast<'v>(v: &dyn sval::Value) -> Cast<'v> {
+ struct CastStream<'v>(Cast<'v>);
+
+ impl<'v> sval::Stream for CastStream<'v> {
+ fn u64(&mut self, v: u64) -> sval::stream::Result {
+ self.0 = Cast::Primitive(Primitive::Unsigned(v));
+ Ok(())
+ }
+
+ fn i64(&mut self, v: i64) -> sval::stream::Result {
+ self.0 = Cast::Primitive(Primitive::Signed(v));
+ Ok(())
+ }
+
+ fn f64(&mut self, v: f64) -> sval::stream::Result {
+ self.0 = Cast::Primitive(Primitive::Float(v));
+ Ok(())
+ }
+
+ fn char(&mut self, v: char) -> sval::stream::Result {
+ self.0 = Cast::Primitive(Primitive::Char(v));
+ Ok(())
+ }
+
+ fn bool(&mut self, v: bool) -> sval::stream::Result {
+ self.0 = Cast::Primitive(Primitive::Bool(v));
+ Ok(())
+ }
+
+ #[cfg(feature = "std")]
+ fn str(&mut self, s: &str) -> sval::stream::Result {
+ self.0 = Cast::String(s.into());
+ Ok(())
+ }
+ }
+
+ let mut cast = CastStream(Cast::Primitive(Primitive::None));
+ let _ = sval::stream(&mut cast, v);
+
+ cast.0
+}
+
+impl Error {
+ fn from_sval(_: sval::value::Error) -> Self {
+ Error::msg("`sval` serialization failed")
+ }
+
+ fn into_sval(self) -> sval::value::Error {
+ sval::value::Error::msg("`sval` serialization failed")
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use kv::value::test::Token;
+
+ #[test]
+ fn test_from_sval() {
+ assert_eq!(kv::Value::from_sval(&42u64).to_token(), Token::Sval);
+ }
+
+ #[test]
+ fn test_sval_structured() {
+ let value = kv::Value::from(42u64);
+ let expected = vec![sval::test::Token::Unsigned(42)];
+
+ assert_eq!(sval::test::tokens(value), expected);
+ }
+
+ #[test]
+ fn sval_cast() {
+ assert_eq!(
+ 42u32,
+ kv::Value::from_sval(&42u64)
+ .to_u32()
+ .expect("invalid value")
+ );
+
+ assert_eq!(
+ "a string",
+ kv::Value::from_sval(&"a string")
+ .to_borrowed_str()
+ .expect("invalid value")
+ );
+
+ #[cfg(feature = "std")]
+ assert_eq!(
+ "a string",
+ kv::Value::from_sval(&"a string")
+ .to_str()
+ .expect("invalid value")
+ );
+ }
+
+ #[test]
+ fn sval_debug() {
+ struct TestSval;
+
+ impl sval::Value for TestSval {
+ fn stream(&self, stream: &mut sval::value::Stream) -> sval::value::Result {
+ stream.u64(42)
+ }
+ }
+
+ assert_eq!(
+ format!("{:04?}", 42u64),
+ format!("{:04?}", kv::Value::from_sval(&TestSval)),
+ );
+ }
+}
diff --git a/src/kv/value/mod.rs b/src/kv/value/mod.rs
index 1695afb..1d59dbf 100644
--- a/src/kv/value/mod.rs
+++ b/src/kv/value/mod.rs
@@ -1,155 +1,56 @@
-//! Structured values.
-
-use std::fmt;
-
-mod internal;
-mod impls;
-
-#[cfg(test)]
-pub(in kv) mod test;
-
-pub use kv::Error;
-
-use self::internal::{Inner, Visitor, Primitive};
-
-/// A type that can be converted into a [`Value`](struct.Value.html).
-pub trait ToValue {
- /// Perform the conversion.
- fn to_value(&self) -> Value;
-}
-
-impl<'a, T> ToValue for &'a T
-where
- T: ToValue + ?Sized,
-{
- fn to_value(&self) -> Value {
- (**self).to_value()
- }
-}
-
-impl<'v> ToValue for Value<'v> {
- fn to_value(&self) -> Value {
- Value {
- inner: self.inner,
- }
- }
-}
-
-/// A type that requires extra work to convert into a [`Value`](struct.Value.html).
-///
-/// This trait is a more advanced initialization API than [`ToValue`](trait.ToValue.html).
-/// It's intended for erased values coming from other logging frameworks that may need
-/// to perform extra work to determine the concrete type to use.
-pub trait Fill {
- /// Fill a value.
- fn fill(&self, slot: &mut Slot) -> Result<(), Error>;
-}
-
-impl<'a, T> Fill for &'a T
-where
- T: Fill + ?Sized,
-{
- fn fill(&self, slot: &mut Slot) -> Result<(), Error> {
- (**self).fill(slot)
- }
-}
-
-/// A value slot to fill using the [`Fill`](trait.Fill.html) trait.
-pub struct Slot<'a> {
- filled: bool,
- visitor: &'a mut Visitor,
-}
-
-impl<'a> fmt::Debug for Slot<'a> {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- f.debug_struct("Slot").finish()
- }
-}
-
-impl<'a> Slot<'a> {
- fn new(visitor: &'a mut Visitor) -> Self {
- Slot {
- visitor,
- filled: false,
- }
- }
-
- /// Fill the slot with a value.
- ///
- /// The given value doesn't need to satisfy any particular lifetime constraints.
- ///
- /// # Panics
- ///
- /// Calling `fill` more than once will panic.
- pub fn fill(&mut self, value: Value) -> Result<(), Error> {
- assert!(!self.filled, "the slot has already been filled");
- self.filled = true;
-
- value.visit(self.visitor)
- }
-}
-
-/// A value in a structured key-value pair.
-pub struct Value<'v> {
- inner: Inner<'v>,
-}
-
-impl<'v> Value<'v> {
- /// Get a value from an internal `Visit`.
- fn from_primitive(value: Primitive<'v>) -> Self {
- Value {
- inner: Inner::Primitive(value),
- }
- }
-
- /// Get a value from a fillable slot.
- pub fn from_fill<T>(value: &'v T) -> Self
- where
- T: Fill,
- {
- Value {
- inner: Inner::Fill(value),
- }
- }
-
- fn visit(&self, visitor: &mut Visitor) -> Result<(), Error> {
- self.inner.visit(visitor)
- }
-}
-
-#[cfg(test)]
-mod tests {
- use super::*;
-
- #[test]
- fn fill_value() {
- struct TestFill;
-
- impl Fill for TestFill {
- fn fill(&self, slot: &mut Slot) -> Result<(), Error> {
- let dbg: &fmt::Debug = &1;
-
- slot.fill(Value::from_debug(&dbg))
- }
- }
-
- assert_eq!("1", Value::from_fill(&TestFill).to_string());
- }
-
- #[test]
- #[should_panic]
- fn fill_multiple_times_panics() {
- struct BadFill;
-
- impl Fill for BadFill {
- fn fill(&self, slot: &mut Slot) -> Result<(), Error> {
- slot.fill(42.into())?;
- slot.fill(6789.into())?;
-
- Ok(())
- }
- }
-
- let _ = Value::from_fill(&BadFill).to_string();
- }
-}
+//! Structured values.
+
+mod fill;
+mod impls;
+mod internal;
+
+#[cfg(test)]
+pub(in kv) mod test;
+
+pub use self::fill::{Fill, Slot};
+pub use kv::Error;
+
+use self::internal::{Inner, Primitive, Visitor};
+
+/// A type that can be converted into a [`Value`](struct.Value.html).
+pub trait ToValue {
+ /// Perform the conversion.
+ fn to_value(&self) -> Value;
+}
+
+impl<'a, T> ToValue for &'a T
+where
+ T: ToValue + ?Sized,
+{
+ fn to_value(&self) -> Value {
+ (**self).to_value()
+ }
+}
+
+impl<'v> ToValue for Value<'v> {
+ fn to_value(&self) -> Value {
+ Value { inner: self.inner }
+ }
+}
+
+/// A value in a structured key-value pair.
+pub struct Value<'v> {
+ inner: Inner<'v>,
+}
+
+impl<'v> Value<'v> {
+ /// Get a value from an internal primitive.
+ fn from_primitive<T>(value: T) -> Self
+ where
+ T: Into<Primitive<'v>>,
+ {
+ Value {
+ inner: Inner::Primitive(value.into()),
+ }
+ }
+
+ /// Visit the value using an internal visitor.
+ fn visit<'a>(&'a self, visitor: &mut dyn Visitor<'a>) -> Result<(), Error> {
+ self.inner.visit(visitor)
+ }
+}
diff --git a/src/kv/value/test.rs b/src/kv/value/test.rs
index c9c03dc..c8d6d5c 100644
--- a/src/kv/value/test.rs
+++ b/src/kv/value/test.rs
@@ -1,81 +1,81 @@
-// Test support for inspecting Values
-
-use std::fmt;
-use std::str;
-
-use super::{Value, Error};
-use super::internal;
-
-#[derive(Debug, PartialEq)]
-pub(in kv) enum Token {
- U64(u64),
- I64(i64),
- F64(f64),
- Char(char),
- Bool(bool),
- Str(String),
- None,
-
- #[cfg(feature = "kv_unstable_sval")]
- Sval,
-}
-
-#[cfg(test)]
-impl<'v> Value<'v> {
- pub(in kv) fn to_token(&self) -> Token {
- struct TestVisitor(Option<Token>);
-
- impl internal::Visitor for TestVisitor {
- fn debug(&mut self, v: &fmt::Debug) -> Result<(), Error> {
- self.0 = Some(Token::Str(format!("{:?}", v)));
- Ok(())
- }
-
- fn u64(&mut self, v: u64) -> Result<(), Error> {
- self.0 = Some(Token::U64(v));
- Ok(())
- }
-
- fn i64(&mut self, v: i64) -> Result<(), Error> {
- self.0 = Some(Token::I64(v));
- Ok(())
- }
-
- fn f64(&mut self, v: f64) -> Result<(), Error> {
- self.0 = Some(Token::F64(v));
- Ok(())
- }
-
- fn bool(&mut self, v: bool) -> Result<(), Error> {
- self.0 = Some(Token::Bool(v));
- Ok(())
- }
-
- fn char(&mut self, v: char) -> Result<(), Error> {
- self.0 = Some(Token::Char(v));
- Ok(())
- }
-
- fn str(&mut self, v: &str) -> Result<(), Error> {
- self.0 = Some(Token::Str(v.into()));
- Ok(())
- }
-
- fn none(&mut self) -> Result<(), Error> {
- self.0 = Some(Token::None);
- Ok(())
- }
-
- #[cfg(feature = "kv_unstable_sval")]
- fn sval(&mut self, _: &internal::sval_support::Value) -> Result<(), Error> {
- self.0 = Some(Token::Sval);
- Ok(())
- }
- }
-
- let mut visitor = TestVisitor(None);
- self.visit(&mut visitor).unwrap();
-
- visitor.0.unwrap()
- }
-}
+// Test support for inspecting Values
+
+use std::fmt;
+use std::str;
+
+use super::internal;
+use super::{Error, Value};
+
+#[derive(Debug, PartialEq)]
+pub(in kv) enum Token {
+ U64(u64),
+ I64(i64),
+ F64(f64),
+ Char(char),
+ Bool(bool),
+ Str(String),
+ None,
+
+ #[cfg(feature = "kv_unstable_sval")]
+ Sval,
+}
+
+#[cfg(test)]
+impl<'v> Value<'v> {
+ pub(in kv) fn to_token(&self) -> Token {
+ struct TestVisitor(Option<Token>);
+
+ impl<'v> internal::Visitor<'v> for TestVisitor {
+ fn debug(&mut self, v: &dyn fmt::Debug) -> Result<(), Error> {
+ self.0 = Some(Token::Str(format!("{:?}", v)));
+ Ok(())
+ }
+
+ fn u64(&mut self, v: u64) -> Result<(), Error> {
+ self.0 = Some(Token::U64(v));
+ Ok(())
+ }
+
+ fn i64(&mut self, v: i64) -> Result<(), Error> {
+ self.0 = Some(Token::I64(v));
+ Ok(())
+ }
+
+ fn f64(&mut self, v: f64) -> Result<(), Error> {
+ self.0 = Some(Token::F64(v));
+ Ok(())
+ }
+
+ fn bool(&mut self, v: bool) -> Result<(), Error> {
+ self.0 = Some(Token::Bool(v));
+ Ok(())
+ }
+
+ fn char(&mut self, v: char) -> Result<(), Error> {
+ self.0 = Some(Token::Char(v));
+ Ok(())
+ }
+
+ fn str(&mut self, v: &str) -> Result<(), Error> {
+ self.0 = Some(Token::Str(v.into()));
+ Ok(())
+ }
+
+ fn none(&mut self) -> Result<(), Error> {
+ self.0 = Some(Token::None);
+ Ok(())
+ }
+
+ #[cfg(feature = "kv_unstable_sval")]
+ fn sval(&mut self, _: &dyn internal::sval::Value) -> Result<(), Error> {
+ self.0 = Some(Token::Sval);
+ Ok(())
+ }
+ }
+
+ let mut visitor = TestVisitor(None);
+ self.visit(&mut visitor).unwrap();
+
+ visitor.0.unwrap()
+ }
+}
diff --git a/src/lib.rs b/src/lib.rs
index c79219d..83b78d0 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,1668 +1,1679 @@
-// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! A lightweight logging facade.
-//!
-//! The `log` crate provides a single logging API that abstracts over the
-//! actual logging implementation. Libraries can use the logging API provided
-//! by this crate, and the consumer of those libraries can choose the logging
-//! implementation that is most suitable for its use case.
-//!
-//! If no logging implementation is selected, the facade falls back to a "noop"
-//! implementation that ignores all log messages. The overhead in this case
-//! is very small - just an integer load, comparison and jump.
-//!
-//! A log request consists of a _target_, a _level_, and a _body_. A target is a
-//! string which defaults to the module path of the location of the log request,
-//! though that default may be overridden. Logger implementations typically use
-//! the target to filter requests based on some user configuration.
-//!
-//! # Use
-//!
-//! The basic use of the log crate is through the five logging macros: [`error!`],
-//! [`warn!`], [`info!`], [`debug!`] and [`trace!`]
-//! where `error!` represents the highest-priority log messages
-//! and `trace!` the lowest. The log messages are filtered by configuring
-//! the log level to exclude messages with a lower priority.
-//! 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
-//! [`println!`]: https://doc.rust-lang.org/stable/std/macro.println.html
-//!
-//! ## In libraries
-//!
-//! Libraries should link only to the `log` crate, and use the provided
-//! macros to log whatever information will be useful to downstream consumers.
-//!
-//! ### Examples
-//!
-//! ```edition2018
-//! # #[derive(Debug)] pub struct Yak(String);
-//! # impl Yak { fn shave(&mut self, _: u32) {} }
-//! # fn find_a_razor() -> Result<u32, u32> { Ok(1) }
-//! use log::{info, warn};
-//!
-//! pub fn shave_the_yak(yak: &mut Yak) {
-//! info!(target: "yak_events", "Commencing yak shaving for {:?}", yak);
-//!
-//! loop {
-//! match find_a_razor() {
-//! Ok(razor) => {
-//! info!("Razor located: {}", razor);
-//! yak.shave(razor);
-//! break;
-//! }
-//! Err(err) => {
-//! warn!("Unable to locate a razor: {}, retrying", err);
-//! }
-//! }
-//! }
-//! }
-//! # fn main() {}
-//! ```
-//!
-//! ## In executables
-//!
-//! Executables should choose a logging implementation and initialize it early in the
-//! runtime of the program. Logging implementations will typically include a
-//! function to do this. Any log messages generated before
-//! the implementation is initialized will be ignored.
-//!
-//! The executable itself may use the `log` crate to log as well.
-//!
-//! ### Warning
-//!
-//! The logging system may only be initialized once.
-//!
-//! # Available logging implementations
-//!
-//! In order to produce log output executables have to use
-//! a logger implementation compatible with the facade.
-//! There are many available implementations to choose from,
-//! here are some of the most popular ones:
-//!
-//! * Simple minimal loggers:
-//! * [env_logger]
-//! * [simple_logger]
-//! * [simplelog]
-//! * [pretty_env_logger]
-//! * [stderrlog]
-//! * [flexi_logger]
-//! * Complex configurable frameworks:
-//! * [log4rs]
-//! * [fern]
-//! * Adaptors for other facilities:
-//! * [syslog]
-//! * [slog-stdlog]
-//!
-//! # Implementing a Logger
-//!
-//! Loggers implement the [`Log`] trait. Here's a very basic example that simply
-//! logs all messages at the [`Error`][level_link], [`Warn`][level_link] or
-//! [`Info`][level_link] levels to stdout:
-//!
-//! ```edition2018
-//! use log::{Record, Level, Metadata};
-//!
-//! struct SimpleLogger;
-//!
-//! impl log::Log for SimpleLogger {
-//! fn enabled(&self, metadata: &Metadata) -> bool {
-//! metadata.level() <= Level::Info
-//! }
-//!
-//! fn log(&self, record: &Record) {
-//! if self.enabled(record.metadata()) {
-//! println!("{} - {}", record.level(), record.args());
-//! }
-//! }
-//!
-//! fn flush(&self) {}
-//! }
-//!
-//! # fn main() {}
-//! ```
-//!
-//! Loggers are installed by calling the [`set_logger`] function. The maximum
-//! log level also needs to be adjusted via the [`set_max_level`] function. The
-//! logging facade uses this as an optimization to improve performance of log
-//! messages at levels that are disabled. It's important to set it, as it
-//! defaults to [`Off`][filter_link], so no log messages will ever be captured!
-//! In the case of our example logger, we'll want to set the maximum log level
-//! to [`Info`][filter_link], since we ignore any [`Debug`][level_link] or
-//! [`Trace`][level_link] level log messages. A logging implementation should
-//! provide a function that wraps a call to [`set_logger`] and
-//! [`set_max_level`], handling initialization of the logger:
-//!
-//! ```edition2018
-//! # use log::{Level, Metadata};
-//! # struct SimpleLogger;
-//! # impl log::Log for SimpleLogger {
-//! # fn enabled(&self, _: &Metadata) -> bool { false }
-//! # fn log(&self, _: &log::Record) {}
-//! # fn flush(&self) {}
-//! # }
-//! # fn main() {}
-//! use log::{SetLoggerError, LevelFilter};
-//!
-//! static LOGGER: SimpleLogger = SimpleLogger;
-//!
-//! pub fn init() -> Result<(), SetLoggerError> {
-//! log::set_logger(&LOGGER)
-//! .map(|()| log::set_max_level(LevelFilter::Info))
-//! }
-//! ```
-//!
-//! Implementations that adjust their configurations at runtime should take care
-//! to adjust the maximum log level as well.
-//!
-//! # Use with `std`
-//!
-//! `set_logger` requires you to provide a `&'static Log`, which can be hard to
-//! obtain if your logger depends on some runtime configuration. The
-//! `set_boxed_logger` function is available with the `std` Cargo feature. It is
-//! identical to `set_logger` except that it takes a `Box<Log>` rather than a
-//! `&'static Log`:
-//!
-//! ```edition2018
-//! # use log::{Level, LevelFilter, Log, SetLoggerError, Metadata};
-//! # struct SimpleLogger;
-//! # impl log::Log for SimpleLogger {
-//! # fn enabled(&self, _: &Metadata) -> bool { false }
-//! # fn log(&self, _: &log::Record) {}
-//! # fn flush(&self) {}
-//! # }
-//! # fn main() {}
-//! # #[cfg(feature = "std")]
-//! pub fn init() -> Result<(), SetLoggerError> {
-//! log::set_boxed_logger(Box::new(SimpleLogger))
-//! .map(|()| log::set_max_level(LevelFilter::Info))
-//! }
-//! ```
-//!
-//! # Compile time filters
-//!
-//! Log levels can be statically disabled at compile time via Cargo features. Log invocations at
-//! disabled levels will be skipped and will not even be present in the resulting binary unless the
-//! log level is specified dynamically. This level is configured separately for release and debug
-//! builds. The features are:
-//!
-//! * `max_level_off`
-//! * `max_level_error`
-//! * `max_level_warn`
-//! * `max_level_info`
-//! * `max_level_debug`
-//! * `max_level_trace`
-//! * `release_max_level_off`
-//! * `release_max_level_error`
-//! * `release_max_level_warn`
-//! * `release_max_level_info`
-//! * `release_max_level_debug`
-//! * `release_max_level_trace`
-//!
-//! These features control the value of the `STATIC_MAX_LEVEL` constant. The logging macros check
-//! this value before logging a message. By default, no levels are disabled.
-//!
-//! Libraries should avoid using the max level features because they're global and can't be changed
-//! once they're set.
-//!
-//! For example, a crate can disable trace level logs in debug builds and trace, debug, and info
-//! level logs in release builds with the following configuration:
-//!
-//! ```toml
-//! [dependencies]
-//! log = { version = "0.4", features = ["max_level_debug", "release_max_level_warn"] }
-//! ```
-//! # Crate Feature Flags
-//!
-//! The following crate feature flags are avaliable in addition to the filters. They are
-//! configured in your `Cargo.toml`.
-//!
-//! * `std` allows use of `std` crate instead of the default `core`. Enables using `std::error` and
-//! `set_boxed_logger` functionality.
-//! * `serde` enables support for serialization and deserialization of `Level` and `LevelFilter`.
-//!
-//! ```toml
-//! [dependencies]
-//! log = { version = "0.4", features = ["std", "serde"] }
-//! ```
-//!
-//! # Version compatibility
-//!
-//! The 0.3 and 0.4 versions of the `log` crate are almost entirely compatible. Log messages
-//! made using `log` 0.3 will forward transparently to a logger implementation using `log` 0.4. Log
-//! messages made using `log` 0.4 will forward to a logger implementation using `log` 0.3, but the
-//! module path and file name information associated with the message will unfortunately be lost.
-//!
-//! [`Log`]: trait.Log.html
-//! [level_link]: enum.Level.html
-//! [filter_link]: enum.LevelFilter.html
-//! [`set_logger`]: fn.set_logger.html
-//! [`set_max_level`]: fn.set_max_level.html
-//! [`try_set_logger_raw`]: fn.try_set_logger_raw.html
-//! [`shutdown_logger_raw`]: fn.shutdown_logger_raw.html
-//! [env_logger]: https://docs.rs/env_logger/*/env_logger/
-//! [simple_logger]: https://github.com/borntyping/rust-simple_logger
-//! [simplelog]: https://github.com/drakulix/simplelog.rs
-//! [pretty_env_logger]: https://docs.rs/pretty_env_logger/*/pretty_env_logger/
-//! [stderrlog]: https://docs.rs/stderrlog/*/stderrlog/
-//! [flexi_logger]: https://docs.rs/flexi_logger/*/flexi_logger/
-//! [syslog]: https://docs.rs/syslog/*/syslog/
-//! [slog-stdlog]: https://docs.rs/slog-stdlog/*/slog_stdlog/
-//! [log4rs]: https://docs.rs/log4rs/*/log4rs/
-//! [fern]: https://docs.rs/fern/*/fern/
-
-#![doc(
- html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
- html_favicon_url = "https://www.rust-lang.org/favicon.ico",
- html_root_url = "https://docs.rs/log/0.4.8"
-)]
-#![warn(missing_docs)]
-#![deny(missing_debug_implementations)]
-#![cfg_attr(all(not(feature = "std"), not(test)), no_std)]
-// When compiled for the rustc compiler itself we want to make sure that this is
-// an unstable crate
-#![cfg_attr(rustbuild, feature(staged_api, rustc_private))]
-#![cfg_attr(rustbuild, unstable(feature = "rustc_private", issue = "27812"))]
-
-#[cfg(all(not(feature = "std"), not(test)))]
-extern crate core as std;
-
-#[macro_use]
-extern crate cfg_if;
-
-use std::cmp;
-#[cfg(feature = "std")]
-use std::error;
-use std::fmt;
-use std::mem;
-use std::str::FromStr;
-use std::sync::atomic::{AtomicUsize, Ordering};
-
-// FIXME: ATOMIC_USIZE_INIT was deprecated in rust 1.34. Silence the
-// deprecation warning until our MSRV >= 1.24, where we can use the
-// replacement const fn `AtomicUsize::new`
-#[allow(deprecated)]
-use std::sync::atomic::ATOMIC_USIZE_INIT;
-
-#[macro_use]
-mod macros;
-mod serde;
-
-#[cfg(feature = "kv_unstable")]
-pub mod kv;
-
-// The LOGGER static holds a pointer to the global logger. It is protected by
-// the STATE static which determines whether LOGGER has been initialized yet.
-static mut LOGGER: &'static Log = &NopLogger;
-
-#[allow(deprecated)]
-static STATE: AtomicUsize = ATOMIC_USIZE_INIT;
-
-// There are three different states that we care about: the logger's
-// uninitialized, the logger's initializing (set_logger's been called but
-// LOGGER hasn't actually been set yet), or the logger's active.
-const UNINITIALIZED: usize = 0;
-const INITIALIZING: usize = 1;
-const INITIALIZED: usize = 2;
-
-#[allow(deprecated)]
-static MAX_LOG_LEVEL_FILTER: AtomicUsize = ATOMIC_USIZE_INIT;
-
-static LOG_LEVEL_NAMES: [&'static str; 6] = ["OFF", "ERROR", "WARN", "INFO", "DEBUG", "TRACE"];
-
-static SET_LOGGER_ERROR: &'static str = "attempted to set a logger after the logging system \
- was already initialized";
-static LEVEL_PARSE_ERROR: &'static str =
- "attempted to convert a string that doesn't match an existing log level";
-
-/// An enum representing the available verbosity levels of the logger.
-///
-/// Typical usage includes: checking if a certain `Level` is enabled with
-/// [`log_enabled!`](macro.log_enabled.html), specifying the `Level` of
-/// [`log!`](macro.log.html), and comparing a `Level` directly to a
-/// [`LevelFilter`](enum.LevelFilter.html).
-#[repr(usize)]
-#[derive(Copy, Eq, Debug, Hash)]
-pub enum Level {
- /// The "error" level.
- ///
- /// Designates very serious errors.
- Error = 1, // This way these line up with the discriminants for LevelFilter below
- /// The "warn" level.
- ///
- /// Designates hazardous situations.
- Warn,
- /// The "info" level.
- ///
- /// Designates useful information.
- Info,
- /// The "debug" level.
- ///
- /// Designates lower priority information.
- Debug,
- /// The "trace" level.
- ///
- /// Designates very low priority, often extremely verbose, information.
- Trace,
-}
-
-impl Clone for Level {
- #[inline]
- fn clone(&self) -> Level {
- *self
- }
-}
-
-impl PartialEq for Level {
- #[inline]
- fn eq(&self, other: &Level) -> bool {
- *self as usize == *other as usize
- }
-}
-
-impl PartialEq<LevelFilter> for Level {
- #[inline]
- fn eq(&self, other: &LevelFilter) -> bool {
- *self as usize == *other as usize
- }
-}
-
-impl PartialOrd for Level {
- #[inline]
- fn partial_cmp(&self, other: &Level) -> Option<cmp::Ordering> {
- Some(self.cmp(other))
- }
-
- #[inline]
- fn lt(&self, other: &Level) -> bool {
- (*self as usize) < *other as usize
- }
-
- #[inline]
- fn le(&self, other: &Level) -> bool {
- *self as usize <= *other as usize
- }
-
- #[inline]
- fn gt(&self, other: &Level) -> bool {
- *self as usize > *other as usize
- }
-
- #[inline]
- fn ge(&self, other: &Level) -> bool {
- *self as usize >= *other as usize
- }
-}
-
-impl PartialOrd<LevelFilter> for Level {
- #[inline]
- fn partial_cmp(&self, other: &LevelFilter) -> Option<cmp::Ordering> {
- Some((*self as usize).cmp(&(*other as usize)))
- }
-
- #[inline]
- fn lt(&self, other: &LevelFilter) -> bool {
- (*self as usize) < *other as usize
- }
-
- #[inline]
- fn le(&self, other: &LevelFilter) -> bool {
- *self as usize <= *other as usize
- }
-
- #[inline]
- fn gt(&self, other: &LevelFilter) -> bool {
- *self as usize > *other as usize
- }
-
- #[inline]
- fn ge(&self, other: &LevelFilter) -> bool {
- *self as usize >= *other as usize
- }
-}
-
-impl Ord for Level {
- #[inline]
- fn cmp(&self, other: &Level) -> cmp::Ordering {
- (*self as usize).cmp(&(*other as usize))
- }
-}
-
-fn ok_or<T, E>(t: Option<T>, e: E) -> Result<T, E> {
- match t {
- Some(t) => Ok(t),
- None => Err(e),
- }
-}
-
-// Reimplemented here because std::ascii is not available in libcore
-fn eq_ignore_ascii_case(a: &str, b: &str) -> bool {
- fn to_ascii_uppercase(c: u8) -> u8 {
- if c >= b'a' && c <= b'z' {
- c - b'a' + b'A'
- } else {
- c
- }
- }
-
- if a.len() == b.len() {
- a.bytes()
- .zip(b.bytes())
- .all(|(a, b)| to_ascii_uppercase(a) == to_ascii_uppercase(b))
- } else {
- false
- }
-}
-
-impl FromStr for Level {
- type Err = ParseLevelError;
- fn from_str(level: &str) -> Result<Level, Self::Err> {
- ok_or(
- LOG_LEVEL_NAMES
- .iter()
- .position(|&name| eq_ignore_ascii_case(name, level))
- .into_iter()
- .filter(|&idx| idx != 0)
- .map(|idx| Level::from_usize(idx).unwrap())
- .next(),
- ParseLevelError(()),
- )
- }
-}
-
-impl fmt::Display for Level {
- fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
- fmt.pad(LOG_LEVEL_NAMES[*self as usize])
- }
-}
-
-impl Level {
- fn from_usize(u: usize) -> Option<Level> {
- match u {
- 1 => Some(Level::Error),
- 2 => Some(Level::Warn),
- 3 => Some(Level::Info),
- 4 => Some(Level::Debug),
- 5 => Some(Level::Trace),
- _ => None,
- }
- }
-
- /// Returns the most verbose logging level.
- #[inline]
- pub fn max() -> Level {
- Level::Trace
- }
-
- /// Converts the `Level` to the equivalent `LevelFilter`.
- #[inline]
- pub fn to_level_filter(&self) -> LevelFilter {
- LevelFilter::from_usize(*self as usize).unwrap()
- }
-}
-
-/// An enum representing the available verbosity level filters of the logger.
-///
-/// A `LevelFilter` may be compared directly to a [`Level`]. Use this type
-/// to get and set the maximum log level with [`max_level()`] and [`set_max_level`].
-///
-/// [`Level`]: enum.Level.html
-/// [`max_level()`]: fn.max_level.html
-/// [`set_max_level`]: fn.set_max_level.html
-#[repr(usize)]
-#[derive(Copy, Eq, Debug, Hash)]
-pub enum LevelFilter {
- /// A level lower than all log levels.
- Off,
- /// Corresponds to the `Error` log level.
- Error,
- /// Corresponds to the `Warn` log level.
- Warn,
- /// Corresponds to the `Info` log level.
- Info,
- /// Corresponds to the `Debug` log level.
- Debug,
- /// Corresponds to the `Trace` log level.
- Trace,
-}
-
-// Deriving generates terrible impls of these traits
-
-impl Clone for LevelFilter {
- #[inline]
- fn clone(&self) -> LevelFilter {
- *self
- }
-}
-
-impl PartialEq for LevelFilter {
- #[inline]
- fn eq(&self, other: &LevelFilter) -> bool {
- *self as usize == *other as usize
- }
-}
-
-impl PartialEq<Level> for LevelFilter {
- #[inline]
- fn eq(&self, other: &Level) -> bool {
- other.eq(self)
- }
-}
-
-impl PartialOrd for LevelFilter {
- #[inline]
- fn partial_cmp(&self, other: &LevelFilter) -> Option<cmp::Ordering> {
- Some(self.cmp(other))
- }
-
- #[inline]
- fn lt(&self, other: &LevelFilter) -> bool {
- (*self as usize) < *other as usize
- }
-
- #[inline]
- fn le(&self, other: &LevelFilter) -> bool {
- *self as usize <= *other as usize
- }
-
- #[inline]
- fn gt(&self, other: &LevelFilter) -> bool {
- *self as usize > *other as usize
- }
-
- #[inline]
- fn ge(&self, other: &LevelFilter) -> bool {
- *self as usize >= *other as usize
- }
-}
-
-impl PartialOrd<Level> for LevelFilter {
- #[inline]
- fn partial_cmp(&self, other: &Level) -> Option<cmp::Ordering> {
- Some((*self as usize).cmp(&(*other as usize)))
- }
-
- #[inline]
- fn lt(&self, other: &Level) -> bool {
- (*self as usize) < *other as usize
- }
-
- #[inline]
- fn le(&self, other: &Level) -> bool {
- *self as usize <= *other as usize
- }
-
- #[inline]
- fn gt(&self, other: &Level) -> bool {
- *self as usize > *other as usize
- }
-
- #[inline]
- fn ge(&self, other: &Level) -> bool {
- *self as usize >= *other as usize
- }
-}
-
-impl Ord for LevelFilter {
- #[inline]
- fn cmp(&self, other: &LevelFilter) -> cmp::Ordering {
- (*self as usize).cmp(&(*other as usize))
- }
-}
-
-impl FromStr for LevelFilter {
- type Err = ParseLevelError;
- fn from_str(level: &str) -> Result<LevelFilter, Self::Err> {
- ok_or(
- LOG_LEVEL_NAMES
- .iter()
- .position(|&name| eq_ignore_ascii_case(name, level))
- .map(|p| LevelFilter::from_usize(p).unwrap()),
- ParseLevelError(()),
- )
- }
-}
-
-impl fmt::Display for LevelFilter {
- fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
- fmt.pad(LOG_LEVEL_NAMES[*self as usize])
- }
-}
-
-impl LevelFilter {
- fn from_usize(u: usize) -> Option<LevelFilter> {
- match u {
- 0 => Some(LevelFilter::Off),
- 1 => Some(LevelFilter::Error),
- 2 => Some(LevelFilter::Warn),
- 3 => Some(LevelFilter::Info),
- 4 => Some(LevelFilter::Debug),
- 5 => Some(LevelFilter::Trace),
- _ => None,
- }
- }
- /// Returns the most verbose logging level filter.
- #[inline]
- pub fn max() -> LevelFilter {
- LevelFilter::Trace
- }
-
- /// Converts `self` to the equivalent `Level`.
- ///
- /// Returns `None` if `self` is `LevelFilter::Off`.
- #[inline]
- pub fn to_level(&self) -> Option<Level> {
- Level::from_usize(*self as usize)
- }
-}
-
-#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug)]
-enum MaybeStaticStr<'a> {
- Static(&'static str),
- Borrowed(&'a str),
-}
-
-impl<'a> MaybeStaticStr<'a> {
- #[inline]
- fn get(&self) -> &'a str {
- match *self {
- MaybeStaticStr::Static(s) => s,
- MaybeStaticStr::Borrowed(s) => s,
- }
- }
-}
-
-/// The "payload" of a log message.
-///
-/// # Use
-///
-/// `Record` structures are passed as parameters to the [`log`][method.log]
-/// method of the [`Log`] trait. Logger implementors manipulate these
-/// structures in order to display log messages. `Record`s are automatically
-/// created by the [`log!`] macro and so are not seen by log users.
-///
-/// Note that the [`level()`] and [`target()`] accessors are equivalent to
-/// `self.metadata().level()` and `self.metadata().target()` respectively.
-/// These methods are provided as a convenience for users of this structure.
-///
-/// # Example
-///
-/// The following example shows a simple logger that displays the level,
-/// module path, and message of any `Record` that is passed to it.
-///
-/// ```edition2018
-/// struct SimpleLogger;
-///
-/// impl log::Log for SimpleLogger {
-/// fn enabled(&self, metadata: &log::Metadata) -> bool {
-/// true
-/// }
-///
-/// fn log(&self, record: &log::Record) {
-/// if !self.enabled(record.metadata()) {
-/// return;
-/// }
-///
-/// println!("{}:{} -- {}",
-/// record.level(),
-/// record.target(),
-/// record.args());
-/// }
-/// fn flush(&self) {}
-/// }
-/// ```
-///
-/// [method.log]: trait.Log.html#tymethod.log
-/// [`Log`]: trait.Log.html
-/// [`log!`]: macro.log.html
-/// [`level()`]: struct.Record.html#method.level
-/// [`target()`]: struct.Record.html#method.target
-#[derive(Clone, Debug)]
-pub struct Record<'a> {
- metadata: Metadata<'a>,
- args: fmt::Arguments<'a>,
- module_path: Option<MaybeStaticStr<'a>>,
- file: Option<MaybeStaticStr<'a>>,
- line: Option<u32>,
- #[cfg(feature = "kv_unstable")]
- key_values: KeyValues<'a>,
-}
-
-// This wrapper type is only needed so we can
-// `#[derive(Debug)]` on `Record`. It also
-// provides a useful `Debug` implementation for
-// the underlying `Source`.
-#[cfg(feature = "kv_unstable")]
-#[derive(Clone)]
-struct KeyValues<'a>(&'a kv::Source);
-
-#[cfg(feature = "kv_unstable")]
-impl<'a> fmt::Debug for KeyValues<'a> {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- let mut visitor = f.debug_map();
- self.0.visit(&mut visitor)?;
- visitor.finish()
- }
-}
-
-impl<'a> Record<'a> {
- /// Returns a new builder.
- #[inline]
- pub fn builder() -> RecordBuilder<'a> {
- RecordBuilder::new()
- }
-
- /// The message body.
- #[inline]
- pub fn args(&self) -> &fmt::Arguments<'a> {
- &self.args
- }
-
- /// Metadata about the log directive.
- #[inline]
- pub fn metadata(&self) -> &Metadata<'a> {
- &self.metadata
- }
-
- /// The verbosity level of the message.
- #[inline]
- pub fn level(&self) -> Level {
- self.metadata.level()
- }
-
- /// The name of the target of the directive.
- #[inline]
- pub fn target(&self) -> &'a str {
- self.metadata.target()
- }
-
- /// The module path of the message.
- #[inline]
- pub fn module_path(&self) -> Option<&'a str> {
- self.module_path.map(|s| s.get())
- }
-
- /// The module path of the message, if it is a `'static` string.
- #[inline]
- pub fn module_path_static(&self) -> Option<&'static str> {
- match self.module_path {
- Some(MaybeStaticStr::Static(s)) => Some(s),
- _ => None,
- }
- }
-
- /// The source file containing the message.
- #[inline]
- pub fn file(&self) -> Option<&'a str> {
- self.file.map(|s| s.get())
- }
-
- /// The module path of the message, if it is a `'static` string.
- #[inline]
- pub fn file_static(&self) -> Option<&'static str> {
- match self.file {
- Some(MaybeStaticStr::Static(s)) => Some(s),
- _ => None,
- }
- }
-
- /// The line containing the message.
- #[inline]
- pub fn line(&self) -> Option<u32> {
- self.line
- }
-
- /// The structued key-value pairs associated with the message.
- #[cfg(feature = "kv_unstable")]
- #[inline]
- pub fn key_values(&self) -> &kv::Source {
- self.key_values.0
- }
-
- /// Create a new [`Builder`](struct.Builder.html) based on this record.
- #[cfg(feature = "kv_unstable")]
- #[inline]
- pub fn to_builder(&self) -> RecordBuilder {
- RecordBuilder {
- record: Record {
- metadata: Metadata {
- level: self.metadata.level,
- target: self.metadata.target,
- },
- args: self.args,
- module_path: self.module_path,
- file: self.file,
- line: self.line,
- key_values: self.key_values.clone(),
- }
- }
- }
-}
-
-/// Builder for [`Record`](struct.Record.html).
-///
-/// Typically should only be used by log library creators or for testing and "shim loggers".
-/// The `RecordBuilder` can set the different parameters of `Record` object, and returns
-/// the created object when `build` is called.
-///
-/// # Examples
-///
-///
-/// ```edition2018
-/// use log::{Level, Record};
-///
-/// let record = Record::builder()
-/// .args(format_args!("Error!"))
-/// .level(Level::Error)
-/// .target("myApp")
-/// .file(Some("server.rs"))
-/// .line(Some(144))
-/// .module_path(Some("server"))
-/// .build();
-/// ```
-///
-/// Alternatively, use [`MetadataBuilder`](struct.MetadataBuilder.html):
-///
-/// ```edition2018
-/// use log::{Record, Level, MetadataBuilder};
-///
-/// let error_metadata = MetadataBuilder::new()
-/// .target("myApp")
-/// .level(Level::Error)
-/// .build();
-///
-/// let record = Record::builder()
-/// .metadata(error_metadata)
-/// .args(format_args!("Error!"))
-/// .line(Some(433))
-/// .file(Some("app.rs"))
-/// .module_path(Some("server"))
-/// .build();
-/// ```
-#[derive(Debug)]
-pub struct RecordBuilder<'a> {
- record: Record<'a>,
-}
-
-impl<'a> RecordBuilder<'a> {
- /// Construct new `RecordBuilder`.
- ///
- /// The default options are:
- ///
- /// - `args`: [`format_args!("")`]
- /// - `metadata`: [`Metadata::builder().build()`]
- /// - `module_path`: `None`
- /// - `file`: `None`
- /// - `line`: `None`
- ///
- /// [`format_args!("")`]: https://doc.rust-lang.org/std/macro.format_args.html
- /// [`Metadata::builder().build()`]: struct.MetadataBuilder.html#method.build
- #[inline]
- pub fn new() -> RecordBuilder<'a> {
- #[cfg(feature = "kv_unstable")]
- return RecordBuilder {
- record: Record {
- args: format_args!(""),
- metadata: Metadata::builder().build(),
- module_path: None,
- file: None,
- line: None,
- key_values: KeyValues(&Option::None::<(kv::Key, kv::Value)>),
- },
- };
-
- #[cfg(not(feature = "kv_unstable"))]
- return RecordBuilder {
- record: Record {
- args: format_args!(""),
- metadata: Metadata::builder().build(),
- module_path: None,
- file: None,
- line: None,
- },
- };
- }
-
- /// Set [`args`](struct.Record.html#method.args).
- #[inline]
- pub fn args(&mut self, args: fmt::Arguments<'a>) -> &mut RecordBuilder<'a> {
- self.record.args = args;
- self
- }
-
- /// Set [`metadata`](struct.Record.html#method.metadata). Construct a `Metadata` object with [`MetadataBuilder`](struct.MetadataBuilder.html).
- #[inline]
- pub fn metadata(&mut self, metadata: Metadata<'a>) -> &mut RecordBuilder<'a> {
- self.record.metadata = metadata;
- self
- }
-
- /// Set [`Metadata::level`](struct.Metadata.html#method.level).
- #[inline]
- pub fn level(&mut self, level: Level) -> &mut RecordBuilder<'a> {
- self.record.metadata.level = level;
- self
- }
-
- /// Set [`Metadata::target`](struct.Metadata.html#method.target)
- #[inline]
- pub fn target(&mut self, target: &'a str) -> &mut RecordBuilder<'a> {
- self.record.metadata.target = target;
- self
- }
-
- /// Set [`module_path`](struct.Record.html#method.module_path)
- #[inline]
- pub fn module_path(&mut self, path: Option<&'a str>) -> &mut RecordBuilder<'a> {
- self.record.module_path = path.map(MaybeStaticStr::Borrowed);
- self
- }
-
- /// Set [`module_path`](struct.Record.html#method.module_path) to a `'static` string
- #[inline]
- pub fn module_path_static(&mut self, path: Option<&'static str>) -> &mut RecordBuilder<'a> {
- self.record.module_path = path.map(MaybeStaticStr::Static);
- self
- }
-
- /// Set [`file`](struct.Record.html#method.file)
- #[inline]
- pub fn file(&mut self, file: Option<&'a str>) -> &mut RecordBuilder<'a> {
- self.record.file = file.map(MaybeStaticStr::Borrowed);
- self
- }
-
- /// Set [`file`](struct.Record.html#method.file) to a `'static` string.
- #[inline]
- pub fn file_static(&mut self, file: Option<&'static str>) -> &mut RecordBuilder<'a> {
- self.record.file = file.map(MaybeStaticStr::Static);
- self
- }
-
- /// Set [`line`](struct.Record.html#method.line)
- #[inline]
- pub fn line(&mut self, line: Option<u32>) -> &mut RecordBuilder<'a> {
- self.record.line = line;
- self
- }
-
- /// Set [`key_values`](struct.Record.html#method.key_values)
- #[cfg(feature = "kv_unstable")]
- #[inline]
- pub fn key_values(&mut self, kvs: &'a kv::Source) -> &mut RecordBuilder<'a> {
- self.record.key_values = KeyValues(kvs);
- self
- }
-
- /// Invoke the builder and return a `Record`
- #[inline]
- pub fn build(&self) -> Record<'a> {
- self.record.clone()
- }
-}
-
-/// Metadata about a log message.
-///
-/// # Use
-///
-/// `Metadata` structs are created when users of the library use
-/// logging macros.
-///
-/// They are consumed by implementations of the `Log` trait in the
-/// `enabled` method.
-///
-/// `Record`s use `Metadata` to determine the log message's severity
-/// and target.
-///
-/// Users should use the `log_enabled!` macro in their code to avoid
-/// constructing expensive log messages.
-///
-/// # Examples
-///
-/// ```edition2018
-/// use log::{Record, Level, Metadata};
-///
-/// struct MyLogger;
-///
-/// impl log::Log for MyLogger {
-/// fn enabled(&self, metadata: &Metadata) -> bool {
-/// metadata.level() <= Level::Info
-/// }
-///
-/// fn log(&self, record: &Record) {
-/// if self.enabled(record.metadata()) {
-/// println!("{} - {}", record.level(), record.args());
-/// }
-/// }
-/// fn flush(&self) {}
-/// }
-///
-/// # fn main(){}
-/// ```
-#[derive(Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug)]
-pub struct Metadata<'a> {
- level: Level,
- target: &'a str,
-}
-
-impl<'a> Metadata<'a> {
- /// Returns a new builder.
- #[inline]
- pub fn builder() -> MetadataBuilder<'a> {
- MetadataBuilder::new()
- }
-
- /// The verbosity level of the message.
- #[inline]
- pub fn level(&self) -> Level {
- self.level
- }
-
- /// The name of the target of the directive.
- #[inline]
- pub fn target(&self) -> &'a str {
- self.target
- }
-}
-
-/// Builder for [`Metadata`](struct.Metadata.html).
-///
-/// Typically should only be used by log library creators or for testing and "shim loggers".
-/// The `MetadataBuilder` can set the different parameters of a `Metadata` object, and returns
-/// the created object when `build` is called.
-///
-/// # Example
-///
-/// ```edition2018
-/// let target = "myApp";
-/// use log::{Level, MetadataBuilder};
-/// let metadata = MetadataBuilder::new()
-/// .level(Level::Debug)
-/// .target(target)
-/// .build();
-/// ```
-#[derive(Eq, PartialEq, Ord, PartialOrd, Hash, Debug)]
-pub struct MetadataBuilder<'a> {
- metadata: Metadata<'a>,
-}
-
-impl<'a> MetadataBuilder<'a> {
- /// Construct a new `MetadataBuilder`.
- ///
- /// The default options are:
- ///
- /// - `level`: `Level::Info`
- /// - `target`: `""`
- #[inline]
- pub fn new() -> MetadataBuilder<'a> {
- MetadataBuilder {
- metadata: Metadata {
- level: Level::Info,
- target: "",
- },
- }
- }
-
- /// Setter for [`level`](struct.Metadata.html#method.level).
- #[inline]
- pub fn level(&mut self, arg: Level) -> &mut MetadataBuilder<'a> {
- self.metadata.level = arg;
- self
- }
-
- /// Setter for [`target`](struct.Metadata.html#method.target).
- #[inline]
- pub fn target(&mut self, target: &'a str) -> &mut MetadataBuilder<'a> {
- self.metadata.target = target;
- self
- }
-
- /// Returns a `Metadata` object.
- #[inline]
- pub fn build(&self) -> Metadata<'a> {
- self.metadata.clone()
- }
-}
-
-/// A trait encapsulating the operations required of a logger.
-pub trait Log: Sync + Send {
- /// Determines if a log message with the specified metadata would be
- /// logged.
- ///
- /// This is used by the `log_enabled!` macro to allow callers to avoid
- /// expensive computation of log message arguments if the message would be
- /// discarded anyway.
- fn enabled(&self, metadata: &Metadata) -> bool;
-
- /// Logs the `Record`.
- ///
- /// Note that `enabled` is *not* necessarily called before this method.
- /// Implementations of `log` should perform all necessary filtering
- /// internally.
- fn log(&self, record: &Record);
-
- /// Flushes any buffered records.
- fn flush(&self);
-}
-
-// Just used as a dummy initial value for LOGGER
-struct NopLogger;
-
-impl Log for NopLogger {
- fn enabled(&self, _: &Metadata) -> bool {
- false
- }
-
- fn log(&self, _: &Record) {}
- fn flush(&self) {}
-}
-
-/// Sets the global maximum log level.
-///
-/// Generally, this should only be called by the active logging implementation.
-#[inline]
-pub fn set_max_level(level: LevelFilter) {
- MAX_LOG_LEVEL_FILTER.store(level as usize, Ordering::SeqCst)
-}
-
-/// Returns the current maximum log level.
-///
-/// The [`log!`], [`error!`], [`warn!`], [`info!`], [`debug!`], and [`trace!`] macros check
-/// this value and discard any message logged at a higher level. The maximum
-/// 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
-/// [`set_max_level`]: fn.set_max_level.html
-#[inline(always)]
-pub fn max_level() -> LevelFilter {
- unsafe { mem::transmute(MAX_LOG_LEVEL_FILTER.load(Ordering::Relaxed)) }
-}
-
-/// Sets the global logger to a `Box<Log>`.
-///
-/// This is a simple convenience wrapper over `set_logger`, which takes a
-/// `Box<Log>` rather than a `&'static Log`. See the documentation for
-/// [`set_logger`] for more details.
-///
-/// Requires the `std` feature.
-///
-/// # Errors
-///
-/// An error is returned if a logger has already been set.
-///
-/// [`set_logger`]: fn.set_logger.html
-#[cfg(all(feature = "std", atomic_cas))]
-pub fn set_boxed_logger(logger: Box<Log>) -> Result<(), SetLoggerError> {
- set_logger_inner(|| unsafe { &*Box::into_raw(logger) })
-}
-
-/// Sets the global logger to a `&'static Log`.
-///
-/// This function may only be called once in the lifetime of a program. Any log
-/// events that occur before the call to `set_logger` completes will be ignored.
-///
-/// This function does not typically need to be called manually. Logger
-/// implementations should provide an initialization method that installs the
-/// logger internally.
-///
-/// # Availability
-///
-/// This method is available even when the `std` feature is disabled. However,
-/// it is currently unavailable on `thumbv6` targets, which lack support for
-/// some atomic operations which are used by this function. Even on those
-/// targets, [`set_logger_racy`] will be available.
-///
-/// # Errors
-///
-/// An error is returned if a logger has already been set.
-///
-/// # Examples
-///
-/// ```edition2018
-/// use log::{error, info, warn, Record, Level, Metadata, LevelFilter};
-///
-/// static MY_LOGGER: MyLogger = MyLogger;
-///
-/// struct MyLogger;
-///
-/// impl log::Log for MyLogger {
-/// fn enabled(&self, metadata: &Metadata) -> bool {
-/// metadata.level() <= Level::Info
-/// }
-///
-/// fn log(&self, record: &Record) {
-/// if self.enabled(record.metadata()) {
-/// println!("{} - {}", record.level(), record.args());
-/// }
-/// }
-/// fn flush(&self) {}
-/// }
-///
-/// # fn main(){
-/// log::set_logger(&MY_LOGGER).unwrap();
-/// log::set_max_level(LevelFilter::Info);
-///
-/// info!("hello log");
-/// warn!("warning");
-/// error!("oops");
-/// # }
-/// ```
-///
-/// [`set_logger_racy`]: fn.set_logger_racy.html
-#[cfg(atomic_cas)]
-pub fn set_logger(logger: &'static Log) -> Result<(), SetLoggerError> {
- set_logger_inner(|| logger)
-}
-
-#[cfg(atomic_cas)]
-fn set_logger_inner<F>(make_logger: F) -> Result<(), SetLoggerError>
-where
- F: FnOnce() -> &'static Log,
-{
- unsafe {
- match STATE.compare_and_swap(UNINITIALIZED, INITIALIZING, Ordering::SeqCst) {
- UNINITIALIZED => {
- LOGGER = make_logger();
- STATE.store(INITIALIZED, Ordering::SeqCst);
- Ok(())
- }
- INITIALIZING => {
- while STATE.load(Ordering::SeqCst) == INITIALIZING {}
- Err(SetLoggerError(()))
- }
- _ => Err(SetLoggerError(())),
- }
- }
-}
-
-/// A thread-unsafe version of [`set_logger`].
-///
-/// This function is available on all platforms, even those that do not have
-/// support for atomics that is needed by [`set_logger`].
-///
-/// In almost all cases, [`set_logger`] should be preferred.
-///
-/// # Safety
-///
-/// This function is only safe to call when no other logger initialization
-/// function is called while this function still executes.
-///
-/// This can be upheld by (for example) making sure that **there are no other
-/// threads**, and (on embedded) that **interrupts are disabled**.
-///
-/// It is safe to use other logging functions while this function runs
-/// (including all logging macros).
-///
-/// [`set_logger`]: fn.set_logger.html
-pub unsafe fn set_logger_racy(logger: &'static Log) -> Result<(), SetLoggerError> {
- match STATE.load(Ordering::SeqCst) {
- UNINITIALIZED => {
- LOGGER = logger;
- STATE.store(INITIALIZED, Ordering::SeqCst);
- Ok(())
- }
- INITIALIZING => {
- // This is just plain UB, since we were racing another initialization function
- unreachable!("set_logger_racy must not be used with other initialization functions")
- }
- _ => Err(SetLoggerError(())),
- }
-}
-
-/// The type returned by [`set_logger`] if [`set_logger`] has already been called.
-///
-/// [`set_logger`]: fn.set_logger.html
-#[allow(missing_copy_implementations)]
-#[derive(Debug)]
-pub struct SetLoggerError(());
-
-impl fmt::Display for SetLoggerError {
- fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
- fmt.write_str(SET_LOGGER_ERROR)
- }
-}
-
-// The Error trait is not available in libcore
-#[cfg(feature = "std")]
-impl error::Error for SetLoggerError {
- fn description(&self) -> &str {
- SET_LOGGER_ERROR
- }
-}
-
-/// The type returned by [`from_str`] when the string doesn't match any of the log levels.
-///
-/// [`from_str`]: https://doc.rust-lang.org/std/str/trait.FromStr.html#tymethod.from_str
-#[allow(missing_copy_implementations)]
-#[derive(Debug, PartialEq)]
-pub struct ParseLevelError(());
-
-impl fmt::Display for ParseLevelError {
- fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
- fmt.write_str(LEVEL_PARSE_ERROR)
- }
-}
-
-// The Error trait is not available in libcore
-#[cfg(feature = "std")]
-impl error::Error for ParseLevelError {
- fn description(&self) -> &str {
- LEVEL_PARSE_ERROR
- }
-}
-
-/// Returns a reference to the logger.
-///
-/// If a logger has not been set, a no-op implementation is returned.
-pub fn logger() -> &'static Log {
- unsafe {
- if STATE.load(Ordering::SeqCst) != INITIALIZED {
- static NOP: NopLogger = NopLogger;
- &NOP
- } else {
- LOGGER
- }
- }
-}
-
-// WARNING: this is not part of the crate's public API and is subject to change at any time
-#[doc(hidden)]
-pub fn __private_api_log(
- args: fmt::Arguments,
- level: Level,
- &(target, module_path, file, line): &(&str, &'static str, &'static str, u32),
-) {
- logger().log(
- &Record::builder()
- .args(args)
- .level(level)
- .target(target)
- .module_path_static(Some(module_path))
- .file_static(Some(file))
- .line(Some(line))
- .build(),
- );
-}
-
-// WARNING: this is not part of the crate's public API and is subject to change at any time
-#[doc(hidden)]
-pub fn __private_api_enabled(level: Level, target: &str) -> bool {
- logger().enabled(&Metadata::builder().level(level).target(target).build())
-}
-
-/// The statically resolved maximum log level.
-///
-/// See the crate level documentation for information on how to configure this.
-///
-/// This value is checked by the log macros, but not by the `Log`ger returned by
-/// the [`logger`] function. Code that manually calls functions on that value
-/// should compare the level against this value.
-///
-/// [`logger`]: fn.logger.html
-pub const STATIC_MAX_LEVEL: LevelFilter = MAX_LEVEL_INNER;
-
-cfg_if! {
- if #[cfg(all(not(debug_assertions), feature = "release_max_level_off"))] {
- const MAX_LEVEL_INNER: LevelFilter = LevelFilter::Off;
- } else if #[cfg(all(not(debug_assertions), feature = "release_max_level_error"))] {
- const MAX_LEVEL_INNER: LevelFilter = LevelFilter::Error;
- } else if #[cfg(all(not(debug_assertions), feature = "release_max_level_warn"))] {
- const MAX_LEVEL_INNER: LevelFilter = LevelFilter::Warn;
- } else if #[cfg(all(not(debug_assertions), feature = "release_max_level_info"))] {
- const MAX_LEVEL_INNER: LevelFilter = LevelFilter::Info;
- } else if #[cfg(all(not(debug_assertions), feature = "release_max_level_debug"))] {
- const MAX_LEVEL_INNER: LevelFilter = LevelFilter::Debug;
- } else if #[cfg(all(not(debug_assertions), feature = "release_max_level_trace"))] {
- const MAX_LEVEL_INNER: LevelFilter = LevelFilter::Trace;
- } else if #[cfg(feature = "max_level_off")] {
- const MAX_LEVEL_INNER: LevelFilter = LevelFilter::Off;
- } else if #[cfg(feature = "max_level_error")] {
- const MAX_LEVEL_INNER: LevelFilter = LevelFilter::Error;
- } else if #[cfg(feature = "max_level_warn")] {
- const MAX_LEVEL_INNER: LevelFilter = LevelFilter::Warn;
- } else if #[cfg(feature = "max_level_info")] {
- const MAX_LEVEL_INNER: LevelFilter = LevelFilter::Info;
- } else if #[cfg(feature = "max_level_debug")] {
- const MAX_LEVEL_INNER: LevelFilter = LevelFilter::Debug;
- } else {
- const MAX_LEVEL_INNER: LevelFilter = LevelFilter::Trace;
- }
-}
-
-#[cfg(test)]
-mod tests {
- extern crate std;
- use super::{Level, LevelFilter, ParseLevelError};
- use tests::std::string::ToString;
-
- #[test]
- fn test_levelfilter_from_str() {
- let tests = [
- ("off", Ok(LevelFilter::Off)),
- ("error", Ok(LevelFilter::Error)),
- ("warn", Ok(LevelFilter::Warn)),
- ("info", Ok(LevelFilter::Info)),
- ("debug", Ok(LevelFilter::Debug)),
- ("trace", Ok(LevelFilter::Trace)),
- ("OFF", Ok(LevelFilter::Off)),
- ("ERROR", Ok(LevelFilter::Error)),
- ("WARN", Ok(LevelFilter::Warn)),
- ("INFO", Ok(LevelFilter::Info)),
- ("DEBUG", Ok(LevelFilter::Debug)),
- ("TRACE", Ok(LevelFilter::Trace)),
- ("asdf", Err(ParseLevelError(()))),
- ];
- for &(s, ref expected) in &tests {
- assert_eq!(expected, &s.parse());
- }
- }
-
- #[test]
- fn test_level_from_str() {
- let tests = [
- ("OFF", Err(ParseLevelError(()))),
- ("error", Ok(Level::Error)),
- ("warn", Ok(Level::Warn)),
- ("info", Ok(Level::Info)),
- ("debug", Ok(Level::Debug)),
- ("trace", Ok(Level::Trace)),
- ("ERROR", Ok(Level::Error)),
- ("WARN", Ok(Level::Warn)),
- ("INFO", Ok(Level::Info)),
- ("DEBUG", Ok(Level::Debug)),
- ("TRACE", Ok(Level::Trace)),
- ("asdf", Err(ParseLevelError(()))),
- ];
- for &(s, ref expected) in &tests {
- assert_eq!(expected, &s.parse());
- }
- }
-
- #[test]
- fn test_level_show() {
- assert_eq!("INFO", Level::Info.to_string());
- assert_eq!("ERROR", Level::Error.to_string());
- }
-
- #[test]
- fn test_levelfilter_show() {
- assert_eq!("OFF", LevelFilter::Off.to_string());
- assert_eq!("ERROR", LevelFilter::Error.to_string());
- }
-
- #[test]
- fn test_cross_cmp() {
- assert!(Level::Debug > LevelFilter::Error);
- assert!(LevelFilter::Warn < Level::Trace);
- assert!(LevelFilter::Off < Level::Error);
- }
-
- #[test]
- fn test_cross_eq() {
- assert!(Level::Error == LevelFilter::Error);
- assert!(LevelFilter::Off != Level::Error);
- assert!(Level::Trace == LevelFilter::Trace);
- }
-
- #[test]
- fn test_to_level() {
- assert_eq!(Some(Level::Error), LevelFilter::Error.to_level());
- assert_eq!(None, LevelFilter::Off.to_level());
- assert_eq!(Some(Level::Debug), LevelFilter::Debug.to_level());
- }
-
- #[test]
- fn test_to_level_filter() {
- assert_eq!(LevelFilter::Error, Level::Error.to_level_filter());
- assert_eq!(LevelFilter::Trace, Level::Trace.to_level_filter());
- }
-
- #[test]
- #[cfg(feature = "std")]
- fn test_error_trait() {
- use super::SetLoggerError;
- use std::error::Error;
- let e = SetLoggerError(());
- assert_eq!(
- e.description(),
- "attempted to set a logger after the logging system \
- was already initialized"
- );
- }
-
- #[test]
- fn test_metadata_builder() {
- use super::MetadataBuilder;
- let target = "myApp";
- let metadata_test = MetadataBuilder::new()
- .level(Level::Debug)
- .target(target)
- .build();
- assert_eq!(metadata_test.level(), Level::Debug);
- assert_eq!(metadata_test.target(), "myApp");
- }
-
- #[test]
- fn test_metadata_convenience_builder() {
- use super::Metadata;
- let target = "myApp";
- let metadata_test = Metadata::builder()
- .level(Level::Debug)
- .target(target)
- .build();
- assert_eq!(metadata_test.level(), Level::Debug);
- assert_eq!(metadata_test.target(), "myApp");
- }
-
- #[test]
- fn test_record_builder() {
- use super::{MetadataBuilder, RecordBuilder};
- let target = "myApp";
- let metadata = MetadataBuilder::new().target(target).build();
- let fmt_args = format_args!("hello");
- let record_test = RecordBuilder::new()
- .args(fmt_args)
- .metadata(metadata)
- .module_path(Some("foo"))
- .file(Some("bar"))
- .line(Some(30))
- .build();
- assert_eq!(record_test.metadata().target(), "myApp");
- assert_eq!(record_test.module_path(), Some("foo"));
- assert_eq!(record_test.file(), Some("bar"));
- assert_eq!(record_test.line(), Some(30));
- }
-
- #[test]
- fn test_record_convenience_builder() {
- use super::{Metadata, Record};
- let target = "myApp";
- let metadata = Metadata::builder().target(target).build();
- let fmt_args = format_args!("hello");
- let record_test = Record::builder()
- .args(fmt_args)
- .metadata(metadata)
- .module_path(Some("foo"))
- .file(Some("bar"))
- .line(Some(30))
- .build();
- assert_eq!(record_test.target(), "myApp");
- assert_eq!(record_test.module_path(), Some("foo"));
- assert_eq!(record_test.file(), Some("bar"));
- assert_eq!(record_test.line(), Some(30));
- }
-
- #[test]
- fn test_record_complete_builder() {
- use super::{Level, Record};
- let target = "myApp";
- let record_test = Record::builder()
- .module_path(Some("foo"))
- .file(Some("bar"))
- .line(Some(30))
- .target(target)
- .level(Level::Error)
- .build();
- assert_eq!(record_test.target(), "myApp");
- assert_eq!(record_test.level(), Level::Error);
- assert_eq!(record_test.module_path(), Some("foo"));
- assert_eq!(record_test.file(), Some("bar"));
- assert_eq!(record_test.line(), Some(30));
- }
-
- #[test]
- #[cfg(feature = "kv_unstable")]
- fn test_record_key_values_builder() {
- use super::Record;
- use kv::{self, Visitor};
-
- struct TestVisitor {
- seen_pairs: usize,
- }
-
- impl<'kvs> Visitor<'kvs> for TestVisitor {
- fn visit_pair(
- &mut self,
- _: kv::Key<'kvs>,
- _: kv::Value<'kvs>
- ) -> Result<(), kv::Error> {
- self.seen_pairs += 1;
- Ok(())
- }
- }
-
- let kvs: &[(&str, i32)] = &[
- ("a", 1),
- ("b", 2)
- ];
- let record_test = Record::builder()
- .key_values(&kvs)
- .build();
-
- let mut visitor = TestVisitor {
- seen_pairs: 0,
- };
-
- record_test.key_values().visit(&mut visitor).unwrap();
-
- assert_eq!(2, visitor.seen_pairs);
- }
-}
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! A lightweight logging facade.
+//!
+//! The `log` crate provides a single logging API that abstracts over the
+//! actual logging implementation. Libraries can use the logging API provided
+//! by this crate, and the consumer of those libraries can choose the logging
+//! implementation that is most suitable for its use case.
+//!
+//! If no logging implementation is selected, the facade falls back to a "noop"
+//! implementation that ignores all log messages. The overhead in this case
+//! is very small - just an integer load, comparison and jump.
+//!
+//! A log request consists of a _target_, a _level_, and a _body_. A target is a
+//! string which defaults to the module path of the location of the log request,
+//! though that default may be overridden. Logger implementations typically use
+//! the target to filter requests based on some user configuration.
+//!
+//! # Use
+//!
+//! The basic use of the log crate is through the five logging macros: [`error!`],
+//! [`warn!`], [`info!`], [`debug!`] and [`trace!`]
+//! where `error!` represents the highest-priority log messages
+//! and `trace!` the lowest. The log messages are filtered by configuring
+//! the log level to exclude messages with a lower priority.
+//! 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
+//! [`println!`]: https://doc.rust-lang.org/stable/std/macro.println.html
+//!
+//! ## In libraries
+//!
+//! Libraries should link only to the `log` crate, and use the provided
+//! macros to log whatever information will be useful to downstream consumers.
+//!
+//! ### Examples
+//!
+//! ```edition2018
+//! # #[derive(Debug)] pub struct Yak(String);
+//! # impl Yak { fn shave(&mut self, _: u32) {} }
+//! # fn find_a_razor() -> Result<u32, u32> { Ok(1) }
+//! use log::{info, warn};
+//!
+//! pub fn shave_the_yak(yak: &mut Yak) {
+//! info!(target: "yak_events", "Commencing yak shaving for {:?}", yak);
+//!
+//! loop {
+//! match find_a_razor() {
+//! Ok(razor) => {
+//! info!("Razor located: {}", razor);
+//! yak.shave(razor);
+//! break;
+//! }
+//! Err(err) => {
+//! warn!("Unable to locate a razor: {}, retrying", err);
+//! }
+//! }
+//! }
+//! }
+//! # fn main() {}
+//! ```
+//!
+//! ## In executables
+//!
+//! Executables should choose a logging implementation and initialize it early in the
+//! runtime of the program. Logging implementations will typically include a
+//! function to do this. Any log messages generated before
+//! the implementation is initialized will be ignored.
+//!
+//! The executable itself may use the `log` crate to log as well.
+//!
+//! ### Warning
+//!
+//! The logging system may only be initialized once.
+//!
+//! # Available logging implementations
+//!
+//! In order to produce log output executables have to use
+//! a logger implementation compatible with the facade.
+//! There are many available implementations to choose from,
+//! here are some of the most popular ones:
+//!
+//! * Simple minimal loggers:
+//! * [env_logger]
+//! * [simple_logger]
+//! * [simplelog]
+//! * [pretty_env_logger]
+//! * [stderrlog]
+//! * [flexi_logger]
+//! * Complex configurable frameworks:
+//! * [log4rs]
+//! * [fern]
+//! * Adaptors for other facilities:
+//! * [syslog]
+//! * [slog-stdlog]
+//!
+//! # Implementing a Logger
+//!
+//! Loggers implement the [`Log`] trait. Here's a very basic example that simply
+//! logs all messages at the [`Error`][level_link], [`Warn`][level_link] or
+//! [`Info`][level_link] levels to stdout:
+//!
+//! ```edition2018
+//! use log::{Record, Level, Metadata};
+//!
+//! struct SimpleLogger;
+//!
+//! impl log::Log for SimpleLogger {
+//! fn enabled(&self, metadata: &Metadata) -> bool {
+//! metadata.level() <= Level::Info
+//! }
+//!
+//! fn log(&self, record: &Record) {
+//! if self.enabled(record.metadata()) {
+//! println!("{} - {}", record.level(), record.args());
+//! }
+//! }
+//!
+//! fn flush(&self) {}
+//! }
+//!
+//! # fn main() {}
+//! ```
+//!
+//! Loggers are installed by calling the [`set_logger`] function. The maximum
+//! log level also needs to be adjusted via the [`set_max_level`] function. The
+//! logging facade uses this as an optimization to improve performance of log
+//! messages at levels that are disabled. It's important to set it, as it
+//! defaults to [`Off`][filter_link], so no log messages will ever be captured!
+//! In the case of our example logger, we'll want to set the maximum log level
+//! to [`Info`][filter_link], since we ignore any [`Debug`][level_link] or
+//! [`Trace`][level_link] level log messages. A logging implementation should
+//! provide a function that wraps a call to [`set_logger`] and
+//! [`set_max_level`], handling initialization of the logger:
+//!
+//! ```edition2018
+//! # use log::{Level, Metadata};
+//! # struct SimpleLogger;
+//! # impl log::Log for SimpleLogger {
+//! # fn enabled(&self, _: &Metadata) -> bool { false }
+//! # fn log(&self, _: &log::Record) {}
+//! # fn flush(&self) {}
+//! # }
+//! # fn main() {}
+//! use log::{SetLoggerError, LevelFilter};
+//!
+//! static LOGGER: SimpleLogger = SimpleLogger;
+//!
+//! pub fn init() -> Result<(), SetLoggerError> {
+//! log::set_logger(&LOGGER)
+//! .map(|()| log::set_max_level(LevelFilter::Info))
+//! }
+//! ```
+//!
+//! Implementations that adjust their configurations at runtime should take care
+//! to adjust the maximum log level as well.
+//!
+//! # Use with `std`
+//!
+//! `set_logger` requires you to provide a `&'static Log`, which can be hard to
+//! obtain if your logger depends on some runtime configuration. The
+//! `set_boxed_logger` function is available with the `std` Cargo feature. It is
+//! identical to `set_logger` except that it takes a `Box<Log>` rather than a
+//! `&'static Log`:
+//!
+//! ```edition2018
+//! # use log::{Level, LevelFilter, Log, SetLoggerError, Metadata};
+//! # struct SimpleLogger;
+//! # impl log::Log for SimpleLogger {
+//! # fn enabled(&self, _: &Metadata) -> bool { false }
+//! # fn log(&self, _: &log::Record) {}
+//! # fn flush(&self) {}
+//! # }
+//! # fn main() {}
+//! # #[cfg(feature = "std")]
+//! pub fn init() -> Result<(), SetLoggerError> {
+//! log::set_boxed_logger(Box::new(SimpleLogger))
+//! .map(|()| log::set_max_level(LevelFilter::Info))
+//! }
+//! ```
+//!
+//! # Compile time filters
+//!
+//! Log levels can be statically disabled at compile time via Cargo features. Log invocations at
+//! disabled levels will be skipped and will not even be present in the resulting binary.
+//! This level is configured separately for release and debug builds. The features are:
+//!
+//! * `max_level_off`
+//! * `max_level_error`
+//! * `max_level_warn`
+//! * `max_level_info`
+//! * `max_level_debug`
+//! * `max_level_trace`
+//! * `release_max_level_off`
+//! * `release_max_level_error`
+//! * `release_max_level_warn`
+//! * `release_max_level_info`
+//! * `release_max_level_debug`
+//! * `release_max_level_trace`
+//!
+//! These features control the value of the `STATIC_MAX_LEVEL` constant. The logging macros check
+//! this value before logging a message. By default, no levels are disabled.
+//!
+//! Libraries should avoid using the max level features because they're global and can't be changed
+//! once they're set.
+//!
+//! For example, a crate can disable trace level logs in debug builds and trace, debug, and info
+//! level logs in release builds with the following configuration:
+//!
+//! ```toml
+//! [dependencies]
+//! log = { version = "0.4", features = ["max_level_debug", "release_max_level_warn"] }
+//! ```
+//! # Crate Feature Flags
+//!
+//! The following crate feature flags are available in addition to the filters. They are
+//! configured in your `Cargo.toml`.
+//!
+//! * `std` allows use of `std` crate instead of the default `core`. Enables using `std::error` and
+//! `set_boxed_logger` functionality.
+//! * `serde` enables support for serialization and deserialization of `Level` and `LevelFilter`.
+//!
+//! ```toml
+//! [dependencies]
+//! log = { version = "0.4", features = ["std", "serde"] }
+//! ```
+//!
+//! # Version compatibility
+//!
+//! The 0.3 and 0.4 versions of the `log` crate are almost entirely compatible. Log messages
+//! made using `log` 0.3 will forward transparently to a logger implementation using `log` 0.4. Log
+//! messages made using `log` 0.4 will forward to a logger implementation using `log` 0.3, but the
+//! module path and file name information associated with the message will unfortunately be lost.
+//!
+//! [`Log`]: trait.Log.html
+//! [level_link]: enum.Level.html
+//! [filter_link]: enum.LevelFilter.html
+//! [`set_logger`]: fn.set_logger.html
+//! [`set_max_level`]: fn.set_max_level.html
+//! [`try_set_logger_raw`]: fn.try_set_logger_raw.html
+//! [`shutdown_logger_raw`]: fn.shutdown_logger_raw.html
+//! [env_logger]: https://docs.rs/env_logger/*/env_logger/
+//! [simple_logger]: https://github.com/borntyping/rust-simple_logger
+//! [simplelog]: https://github.com/drakulix/simplelog.rs
+//! [pretty_env_logger]: https://docs.rs/pretty_env_logger/*/pretty_env_logger/
+//! [stderrlog]: https://docs.rs/stderrlog/*/stderrlog/
+//! [flexi_logger]: https://docs.rs/flexi_logger/*/flexi_logger/
+//! [syslog]: https://docs.rs/syslog/*/syslog/
+//! [slog-stdlog]: https://docs.rs/slog-stdlog/*/slog_stdlog/
+//! [log4rs]: https://docs.rs/log4rs/*/log4rs/
+//! [fern]: https://docs.rs/fern/*/fern/
+
+#![doc(
+ html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
+ html_favicon_url = "https://www.rust-lang.org/favicon.ico",
+ html_root_url = "https://docs.rs/log/0.4.11"
+)]
+#![warn(missing_docs)]
+#![deny(missing_debug_implementations)]
+#![cfg_attr(all(not(feature = "std"), not(test)), no_std)]
+// When compiled for the rustc compiler itself we want to make sure that this is
+// an unstable crate
+#![cfg_attr(rustbuild, feature(staged_api, rustc_private))]
+#![cfg_attr(rustbuild, unstable(feature = "rustc_private", issue = "27812"))]
+
+#[cfg(all(not(feature = "std"), not(test)))]
+extern crate core as std;
+
+#[macro_use]
+extern crate cfg_if;
+
+use std::cmp;
+#[cfg(feature = "std")]
+use std::error;
+use std::fmt;
+use std::mem;
+use std::str::FromStr;
+use std::sync::atomic::{AtomicUsize, Ordering};
+
+#[macro_use]
+mod macros;
+mod serde;
+
+#[cfg(feature = "kv_unstable")]
+pub mod kv;
+
+// The LOGGER static holds a pointer to the global logger. It is protected by
+// the STATE static which determines whether LOGGER has been initialized yet.
+static mut LOGGER: &dyn Log = &NopLogger;
+
+static STATE: AtomicUsize = AtomicUsize::new(0);
+
+// There are three different states that we care about: the logger's
+// uninitialized, the logger's initializing (set_logger's been called but
+// LOGGER hasn't actually been set yet), or the logger's active.
+const UNINITIALIZED: usize = 0;
+const INITIALIZING: usize = 1;
+const INITIALIZED: usize = 2;
+
+static MAX_LOG_LEVEL_FILTER: AtomicUsize = AtomicUsize::new(0);
+
+static LOG_LEVEL_NAMES: [&str; 6] = ["OFF", "ERROR", "WARN", "INFO", "DEBUG", "TRACE"];
+
+static SET_LOGGER_ERROR: &str = "attempted to set a logger after the logging system \
+ was already initialized";
+static LEVEL_PARSE_ERROR: &str =
+ "attempted to convert a string that doesn't match an existing log level";
+
+/// An enum representing the available verbosity levels of the logger.
+///
+/// Typical usage includes: checking if a certain `Level` is enabled with
+/// [`log_enabled!`](macro.log_enabled.html), specifying the `Level` of
+/// [`log!`](macro.log.html), and comparing a `Level` directly to a
+/// [`LevelFilter`](enum.LevelFilter.html).
+#[repr(usize)]
+#[derive(Copy, Eq, Debug, Hash)]
+pub enum Level {
+ /// The "error" level.
+ ///
+ /// Designates very serious errors.
+ // This way these line up with the discriminants for LevelFilter below
+ // This works because Rust treats field-less enums the same way as C does:
+ // https://doc.rust-lang.org/reference/items/enumerations.html#custom-discriminant-values-for-field-less-enumerations
+ Error = 1,
+ /// The "warn" level.
+ ///
+ /// Designates hazardous situations.
+ Warn,
+ /// The "info" level.
+ ///
+ /// Designates useful information.
+ Info,
+ /// The "debug" level.
+ ///
+ /// Designates lower priority information.
+ Debug,
+ /// The "trace" level.
+ ///
+ /// Designates very low priority, often extremely verbose, information.
+ Trace,
+}
+
+impl Clone for Level {
+ #[inline]
+ fn clone(&self) -> Level {
+ *self
+ }
+}
+
+impl PartialEq for Level {
+ #[inline]
+ fn eq(&self, other: &Level) -> bool {
+ *self as usize == *other as usize
+ }
+}
+
+impl PartialEq<LevelFilter> for Level {
+ #[inline]
+ fn eq(&self, other: &LevelFilter) -> bool {
+ *self as usize == *other as usize
+ }
+}
+
+impl PartialOrd for Level {
+ #[inline]
+ fn partial_cmp(&self, other: &Level) -> Option<cmp::Ordering> {
+ Some(self.cmp(other))
+ }
+
+ #[inline]
+ fn lt(&self, other: &Level) -> bool {
+ (*self as usize) < *other as usize
+ }
+
+ #[inline]
+ fn le(&self, other: &Level) -> bool {
+ *self as usize <= *other as usize
+ }
+
+ #[inline]
+ fn gt(&self, other: &Level) -> bool {
+ *self as usize > *other as usize
+ }
+
+ #[inline]
+ fn ge(&self, other: &Level) -> bool {
+ *self as usize >= *other as usize
+ }
+}
+
+impl PartialOrd<LevelFilter> for Level {
+ #[inline]
+ fn partial_cmp(&self, other: &LevelFilter) -> Option<cmp::Ordering> {
+ Some((*self as usize).cmp(&(*other as usize)))
+ }
+
+ #[inline]
+ fn lt(&self, other: &LevelFilter) -> bool {
+ (*self as usize) < *other as usize
+ }
+
+ #[inline]
+ fn le(&self, other: &LevelFilter) -> bool {
+ *self as usize <= *other as usize
+ }
+
+ #[inline]
+ fn gt(&self, other: &LevelFilter) -> bool {
+ *self as usize > *other as usize
+ }
+
+ #[inline]
+ fn ge(&self, other: &LevelFilter) -> bool {
+ *self as usize >= *other as usize
+ }
+}
+
+impl Ord for Level {
+ #[inline]
+ fn cmp(&self, other: &Level) -> cmp::Ordering {
+ (*self as usize).cmp(&(*other as usize))
+ }
+}
+
+fn ok_or<T, E>(t: Option<T>, e: E) -> Result<T, E> {
+ match t {
+ Some(t) => Ok(t),
+ None => Err(e),
+ }
+}
+
+// Reimplemented here because std::ascii is not available in libcore
+fn eq_ignore_ascii_case(a: &str, b: &str) -> bool {
+ fn to_ascii_uppercase(c: u8) -> u8 {
+ if c >= b'a' && c <= b'z' {
+ c - b'a' + b'A'
+ } else {
+ c
+ }
+ }
+
+ if a.len() == b.len() {
+ a.bytes()
+ .zip(b.bytes())
+ .all(|(a, b)| to_ascii_uppercase(a) == to_ascii_uppercase(b))
+ } else {
+ false
+ }
+}
+
+impl FromStr for Level {
+ type Err = ParseLevelError;
+ fn from_str(level: &str) -> Result<Level, Self::Err> {
+ ok_or(
+ LOG_LEVEL_NAMES
+ .iter()
+ .position(|&name| eq_ignore_ascii_case(name, level))
+ .into_iter()
+ .filter(|&idx| idx != 0)
+ .map(|idx| Level::from_usize(idx).unwrap())
+ .next(),
+ ParseLevelError(()),
+ )
+ }
+}
+
+impl fmt::Display for Level {
+ fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+ fmt.pad(LOG_LEVEL_NAMES[*self as usize])
+ }
+}
+
+impl Level {
+ fn from_usize(u: usize) -> Option<Level> {
+ match u {
+ 1 => Some(Level::Error),
+ 2 => Some(Level::Warn),
+ 3 => Some(Level::Info),
+ 4 => Some(Level::Debug),
+ 5 => Some(Level::Trace),
+ _ => None,
+ }
+ }
+
+ /// Returns the most verbose logging level.
+ #[inline]
+ pub fn max() -> Level {
+ Level::Trace
+ }
+
+ /// Converts the `Level` to the equivalent `LevelFilter`.
+ #[inline]
+ pub fn to_level_filter(&self) -> LevelFilter {
+ LevelFilter::from_usize(*self as usize).unwrap()
+ }
+}
+
+/// An enum representing the available verbosity level filters of the logger.
+///
+/// A `LevelFilter` may be compared directly to a [`Level`]. Use this type
+/// to get and set the maximum log level with [`max_level()`] and [`set_max_level`].
+///
+/// [`Level`]: enum.Level.html
+/// [`max_level()`]: fn.max_level.html
+/// [`set_max_level`]: fn.set_max_level.html
+#[repr(usize)]
+#[derive(Copy, Eq, Debug, Hash)]
+pub enum LevelFilter {
+ /// A level lower than all log levels.
+ Off,
+ /// Corresponds to the `Error` log level.
+ Error,
+ /// Corresponds to the `Warn` log level.
+ Warn,
+ /// Corresponds to the `Info` log level.
+ Info,
+ /// Corresponds to the `Debug` log level.
+ Debug,
+ /// Corresponds to the `Trace` log level.
+ Trace,
+}
+
+// Deriving generates terrible impls of these traits
+
+impl Clone for LevelFilter {
+ #[inline]
+ fn clone(&self) -> LevelFilter {
+ *self
+ }
+}
+
+impl PartialEq for LevelFilter {
+ #[inline]
+ fn eq(&self, other: &LevelFilter) -> bool {
+ *self as usize == *other as usize
+ }
+}
+
+impl PartialEq<Level> for LevelFilter {
+ #[inline]
+ fn eq(&self, other: &Level) -> bool {
+ other.eq(self)
+ }
+}
+
+impl PartialOrd for LevelFilter {
+ #[inline]
+ fn partial_cmp(&self, other: &LevelFilter) -> Option<cmp::Ordering> {
+ Some(self.cmp(other))
+ }
+
+ #[inline]
+ fn lt(&self, other: &LevelFilter) -> bool {
+ (*self as usize) < *other as usize
+ }
+
+ #[inline]
+ fn le(&self, other: &LevelFilter) -> bool {
+ *self as usize <= *other as usize
+ }
+
+ #[inline]
+ fn gt(&self, other: &LevelFilter) -> bool {
+ *self as usize > *other as usize
+ }
+
+ #[inline]
+ fn ge(&self, other: &LevelFilter) -> bool {
+ *self as usize >= *other as usize
+ }
+}
+
+impl PartialOrd<Level> for LevelFilter {
+ #[inline]
+ fn partial_cmp(&self, other: &Level) -> Option<cmp::Ordering> {
+ Some((*self as usize).cmp(&(*other as usize)))
+ }
+
+ #[inline]
+ fn lt(&self, other: &Level) -> bool {
+ (*self as usize) < *other as usize
+ }
+
+ #[inline]
+ fn le(&self, other: &Level) -> bool {
+ *self as usize <= *other as usize
+ }
+
+ #[inline]
+ fn gt(&self, other: &Level) -> bool {
+ *self as usize > *other as usize
+ }
+
+ #[inline]
+ fn ge(&self, other: &Level) -> bool {
+ *self as usize >= *other as usize
+ }
+}
+
+impl Ord for LevelFilter {
+ #[inline]
+ fn cmp(&self, other: &LevelFilter) -> cmp::Ordering {
+ (*self as usize).cmp(&(*other as usize))
+ }
+}
+
+impl FromStr for LevelFilter {
+ type Err = ParseLevelError;
+ fn from_str(level: &str) -> Result<LevelFilter, Self::Err> {
+ ok_or(
+ LOG_LEVEL_NAMES
+ .iter()
+ .position(|&name| eq_ignore_ascii_case(name, level))
+ .map(|p| LevelFilter::from_usize(p).unwrap()),
+ ParseLevelError(()),
+ )
+ }
+}
+
+impl fmt::Display for LevelFilter {
+ fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+ fmt.pad(LOG_LEVEL_NAMES[*self as usize])
+ }
+}
+
+impl LevelFilter {
+ fn from_usize(u: usize) -> Option<LevelFilter> {
+ match u {
+ 0 => Some(LevelFilter::Off),
+ 1 => Some(LevelFilter::Error),
+ 2 => Some(LevelFilter::Warn),
+ 3 => Some(LevelFilter::Info),
+ 4 => Some(LevelFilter::Debug),
+ 5 => Some(LevelFilter::Trace),
+ _ => None,
+ }
+ }
+ /// Returns the most verbose logging level filter.
+ #[inline]
+ pub fn max() -> LevelFilter {
+ LevelFilter::Trace
+ }
+
+ /// Converts `self` to the equivalent `Level`.
+ ///
+ /// Returns `None` if `self` is `LevelFilter::Off`.
+ #[inline]
+ pub fn to_level(&self) -> Option<Level> {
+ Level::from_usize(*self as usize)
+ }
+}
+
+#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug)]
+enum MaybeStaticStr<'a> {
+ Static(&'static str),
+ Borrowed(&'a str),
+}
+
+impl<'a> MaybeStaticStr<'a> {
+ #[inline]
+ fn get(&self) -> &'a str {
+ match *self {
+ MaybeStaticStr::Static(s) => s,
+ MaybeStaticStr::Borrowed(s) => s,
+ }
+ }
+}
+
+/// The "payload" of a log message.
+///
+/// # Use
+///
+/// `Record` structures are passed as parameters to the [`log`][method.log]
+/// method of the [`Log`] trait. Logger implementors manipulate these
+/// structures in order to display log messages. `Record`s are automatically
+/// created by the [`log!`] macro and so are not seen by log users.
+///
+/// Note that the [`level()`] and [`target()`] accessors are equivalent to
+/// `self.metadata().level()` and `self.metadata().target()` respectively.
+/// These methods are provided as a convenience for users of this structure.
+///
+/// # Example
+///
+/// The following example shows a simple logger that displays the level,
+/// module path, and message of any `Record` that is passed to it.
+///
+/// ```edition2018
+/// struct SimpleLogger;
+///
+/// impl log::Log for SimpleLogger {
+/// fn enabled(&self, metadata: &log::Metadata) -> bool {
+/// true
+/// }
+///
+/// fn log(&self, record: &log::Record) {
+/// if !self.enabled(record.metadata()) {
+/// return;
+/// }
+///
+/// println!("{}:{} -- {}",
+/// record.level(),
+/// record.target(),
+/// record.args());
+/// }
+/// fn flush(&self) {}
+/// }
+/// ```
+///
+/// [method.log]: trait.Log.html#tymethod.log
+/// [`Log`]: trait.Log.html
+/// [`log!`]: macro.log.html
+/// [`level()`]: struct.Record.html#method.level
+/// [`target()`]: struct.Record.html#method.target
+#[derive(Clone, Debug)]
+pub struct Record<'a> {
+ metadata: Metadata<'a>,
+ args: fmt::Arguments<'a>,
+ module_path: Option<MaybeStaticStr<'a>>,
+ file: Option<MaybeStaticStr<'a>>,
+ line: Option<u32>,
+ #[cfg(feature = "kv_unstable")]
+ key_values: KeyValues<'a>,
+}
+
+// This wrapper type is only needed so we can
+// `#[derive(Debug)]` on `Record`. It also
+// provides a useful `Debug` implementation for
+// the underlying `Source`.
+#[cfg(feature = "kv_unstable")]
+#[derive(Clone)]
+struct KeyValues<'a>(&'a dyn kv::Source);
+
+#[cfg(feature = "kv_unstable")]
+impl<'a> fmt::Debug for KeyValues<'a> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ let mut visitor = f.debug_map();
+ self.0.visit(&mut visitor).map_err(|_| fmt::Error)?;
+ visitor.finish()
+ }
+}
+
+impl<'a> Record<'a> {
+ /// Returns a new builder.
+ #[inline]
+ pub fn builder() -> RecordBuilder<'a> {
+ RecordBuilder::new()
+ }
+
+ /// The message body.
+ #[inline]
+ pub fn args(&self) -> &fmt::Arguments<'a> {
+ &self.args
+ }
+
+ /// Metadata about the log directive.
+ #[inline]
+ pub fn metadata(&self) -> &Metadata<'a> {
+ &self.metadata
+ }
+
+ /// The verbosity level of the message.
+ #[inline]
+ pub fn level(&self) -> Level {
+ self.metadata.level()
+ }
+
+ /// The name of the target of the directive.
+ #[inline]
+ pub fn target(&self) -> &'a str {
+ self.metadata.target()
+ }
+
+ /// The module path of the message.
+ #[inline]
+ pub fn module_path(&self) -> Option<&'a str> {
+ self.module_path.map(|s| s.get())
+ }
+
+ /// The module path of the message, if it is a `'static` string.
+ #[inline]
+ pub fn module_path_static(&self) -> Option<&'static str> {
+ match self.module_path {
+ Some(MaybeStaticStr::Static(s)) => Some(s),
+ _ => None,
+ }
+ }
+
+ /// The source file containing the message.
+ #[inline]
+ pub fn file(&self) -> Option<&'a str> {
+ self.file.map(|s| s.get())
+ }
+
+ /// The module path of the message, if it is a `'static` string.
+ #[inline]
+ pub fn file_static(&self) -> Option<&'static str> {
+ match self.file {
+ Some(MaybeStaticStr::Static(s)) => Some(s),
+ _ => None,
+ }
+ }
+
+ /// The line containing the message.
+ #[inline]
+ pub fn line(&self) -> Option<u32> {
+ self.line
+ }
+
+ /// The structued key-value pairs associated with the message.
+ #[cfg(feature = "kv_unstable")]
+ #[inline]
+ pub fn key_values(&self) -> &dyn kv::Source {
+ self.key_values.0
+ }
+
+ /// Create a new [`RecordBuilder`](struct.RecordBuilder.html) based on this record.
+ #[cfg(feature = "kv_unstable")]
+ #[inline]
+ pub fn to_builder(&self) -> RecordBuilder {
+ RecordBuilder {
+ record: Record {
+ metadata: Metadata {
+ level: self.metadata.level,
+ target: self.metadata.target,
+ },
+ args: self.args,
+ module_path: self.module_path,
+ file: self.file,
+ line: self.line,
+ key_values: self.key_values.clone(),
+ },
+ }
+ }
+}
+
+/// Builder for [`Record`](struct.Record.html).
+///
+/// Typically should only be used by log library creators or for testing and "shim loggers".
+/// The `RecordBuilder` can set the different parameters of `Record` object, and returns
+/// the created object when `build` is called.
+///
+/// # Examples
+///
+///
+/// ```edition2018
+/// use log::{Level, Record};
+///
+/// let record = Record::builder()
+/// .args(format_args!("Error!"))
+/// .level(Level::Error)
+/// .target("myApp")
+/// .file(Some("server.rs"))
+/// .line(Some(144))
+/// .module_path(Some("server"))
+/// .build();
+/// ```
+///
+/// Alternatively, use [`MetadataBuilder`](struct.MetadataBuilder.html):
+///
+/// ```edition2018
+/// use log::{Record, Level, MetadataBuilder};
+///
+/// let error_metadata = MetadataBuilder::new()
+/// .target("myApp")
+/// .level(Level::Error)
+/// .build();
+///
+/// let record = Record::builder()
+/// .metadata(error_metadata)
+/// .args(format_args!("Error!"))
+/// .line(Some(433))
+/// .file(Some("app.rs"))
+/// .module_path(Some("server"))
+/// .build();
+/// ```
+#[derive(Debug)]
+pub struct RecordBuilder<'a> {
+ record: Record<'a>,
+}
+
+impl<'a> RecordBuilder<'a> {
+ /// Construct new `RecordBuilder`.
+ ///
+ /// The default options are:
+ ///
+ /// - `args`: [`format_args!("")`]
+ /// - `metadata`: [`Metadata::builder().build()`]
+ /// - `module_path`: `None`
+ /// - `file`: `None`
+ /// - `line`: `None`
+ ///
+ /// [`format_args!("")`]: https://doc.rust-lang.org/std/macro.format_args.html
+ /// [`Metadata::builder().build()`]: struct.MetadataBuilder.html#method.build
+ #[inline]
+ pub fn new() -> RecordBuilder<'a> {
+ RecordBuilder {
+ record: Record {
+ args: format_args!(""),
+ metadata: Metadata::builder().build(),
+ module_path: None,
+ file: None,
+ line: None,
+ #[cfg(feature = "kv_unstable")]
+ key_values: KeyValues(&Option::None::<(kv::Key, kv::Value)>),
+ },
+ }
+ }
+
+ /// Set [`args`](struct.Record.html#method.args).
+ #[inline]
+ pub fn args(&mut self, args: fmt::Arguments<'a>) -> &mut RecordBuilder<'a> {
+ self.record.args = args;
+ self
+ }
+
+ /// Set [`metadata`](struct.Record.html#method.metadata). Construct a `Metadata` object with [`MetadataBuilder`](struct.MetadataBuilder.html).
+ #[inline]
+ pub fn metadata(&mut self, metadata: Metadata<'a>) -> &mut RecordBuilder<'a> {
+ self.record.metadata = metadata;
+ self
+ }
+
+ /// Set [`Metadata::level`](struct.Metadata.html#method.level).
+ #[inline]
+ pub fn level(&mut self, level: Level) -> &mut RecordBuilder<'a> {
+ self.record.metadata.level = level;
+ self
+ }
+
+ /// Set [`Metadata::target`](struct.Metadata.html#method.target)
+ #[inline]
+ pub fn target(&mut self, target: &'a str) -> &mut RecordBuilder<'a> {
+ self.record.metadata.target = target;
+ self
+ }
+
+ /// Set [`module_path`](struct.Record.html#method.module_path)
+ #[inline]
+ pub fn module_path(&mut self, path: Option<&'a str>) -> &mut RecordBuilder<'a> {
+ self.record.module_path = path.map(MaybeStaticStr::Borrowed);
+ self
+ }
+
+ /// Set [`module_path`](struct.Record.html#method.module_path) to a `'static` string
+ #[inline]
+ pub fn module_path_static(&mut self, path: Option<&'static str>) -> &mut RecordBuilder<'a> {
+ self.record.module_path = path.map(MaybeStaticStr::Static);
+ self
+ }
+
+ /// Set [`file`](struct.Record.html#method.file)
+ #[inline]
+ pub fn file(&mut self, file: Option<&'a str>) -> &mut RecordBuilder<'a> {
+ self.record.file = file.map(MaybeStaticStr::Borrowed);
+ self
+ }
+
+ /// Set [`file`](struct.Record.html#method.file) to a `'static` string.
+ #[inline]
+ pub fn file_static(&mut self, file: Option<&'static str>) -> &mut RecordBuilder<'a> {
+ self.record.file = file.map(MaybeStaticStr::Static);
+ self
+ }
+
+ /// Set [`line`](struct.Record.html#method.line)
+ #[inline]
+ pub fn line(&mut self, line: Option<u32>) -> &mut RecordBuilder<'a> {
+ self.record.line = line;
+ self
+ }
+
+ /// Set [`key_values`](struct.Record.html#method.key_values)
+ #[cfg(feature = "kv_unstable")]
+ #[inline]
+ pub fn key_values(&mut self, kvs: &'a dyn kv::Source) -> &mut RecordBuilder<'a> {
+ self.record.key_values = KeyValues(kvs);
+ self
+ }
+
+ /// Invoke the builder and return a `Record`
+ #[inline]
+ pub fn build(&self) -> Record<'a> {
+ self.record.clone()
+ }
+}
+
+/// Metadata about a log message.
+///
+/// # Use
+///
+/// `Metadata` structs are created when users of the library use
+/// logging macros.
+///
+/// They are consumed by implementations of the `Log` trait in the
+/// `enabled` method.
+///
+/// `Record`s use `Metadata` to determine the log message's severity
+/// and target.
+///
+/// Users should use the `log_enabled!` macro in their code to avoid
+/// constructing expensive log messages.
+///
+/// # Examples
+///
+/// ```edition2018
+/// use log::{Record, Level, Metadata};
+///
+/// struct MyLogger;
+///
+/// impl log::Log for MyLogger {
+/// fn enabled(&self, metadata: &Metadata) -> bool {
+/// metadata.level() <= Level::Info
+/// }
+///
+/// fn log(&self, record: &Record) {
+/// if self.enabled(record.metadata()) {
+/// println!("{} - {}", record.level(), record.args());
+/// }
+/// }
+/// fn flush(&self) {}
+/// }
+///
+/// # fn main(){}
+/// ```
+#[derive(Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug)]
+pub struct Metadata<'a> {
+ level: Level,
+ target: &'a str,
+}
+
+impl<'a> Metadata<'a> {
+ /// Returns a new builder.
+ #[inline]
+ pub fn builder() -> MetadataBuilder<'a> {
+ MetadataBuilder::new()
+ }
+
+ /// The verbosity level of the message.
+ #[inline]
+ pub fn level(&self) -> Level {
+ self.level
+ }
+
+ /// The name of the target of the directive.
+ #[inline]
+ pub fn target(&self) -> &'a str {
+ self.target
+ }
+}
+
+/// Builder for [`Metadata`](struct.Metadata.html).
+///
+/// Typically should only be used by log library creators or for testing and "shim loggers".
+/// The `MetadataBuilder` can set the different parameters of a `Metadata` object, and returns
+/// the created object when `build` is called.
+///
+/// # Example
+///
+/// ```edition2018
+/// let target = "myApp";
+/// use log::{Level, MetadataBuilder};
+/// let metadata = MetadataBuilder::new()
+/// .level(Level::Debug)
+/// .target(target)
+/// .build();
+/// ```
+#[derive(Eq, PartialEq, Ord, PartialOrd, Hash, Debug)]
+pub struct MetadataBuilder<'a> {
+ metadata: Metadata<'a>,
+}
+
+impl<'a> MetadataBuilder<'a> {
+ /// Construct a new `MetadataBuilder`.
+ ///
+ /// The default options are:
+ ///
+ /// - `level`: `Level::Info`
+ /// - `target`: `""`
+ #[inline]
+ pub fn new() -> MetadataBuilder<'a> {
+ MetadataBuilder {
+ metadata: Metadata {
+ level: Level::Info,
+ target: "",
+ },
+ }
+ }
+
+ /// Setter for [`level`](struct.Metadata.html#method.level).
+ #[inline]
+ pub fn level(&mut self, arg: Level) -> &mut MetadataBuilder<'a> {
+ self.metadata.level = arg;
+ self
+ }
+
+ /// Setter for [`target`](struct.Metadata.html#method.target).
+ #[inline]
+ pub fn target(&mut self, target: &'a str) -> &mut MetadataBuilder<'a> {
+ self.metadata.target = target;
+ self
+ }
+
+ /// Returns a `Metadata` object.
+ #[inline]
+ pub fn build(&self) -> Metadata<'a> {
+ self.metadata.clone()
+ }
+}
+
+/// A trait encapsulating the operations required of a logger.
+pub trait Log: Sync + Send {
+ /// Determines if a log message with the specified metadata would be
+ /// logged.
+ ///
+ /// This is used by the `log_enabled!` macro to allow callers to avoid
+ /// expensive computation of log message arguments if the message would be
+ /// discarded anyway.
+ fn enabled(&self, metadata: &Metadata) -> bool;
+
+ /// Logs the `Record`.
+ ///
+ /// Note that `enabled` is *not* necessarily called before this method.
+ /// Implementations of `log` should perform all necessary filtering
+ /// internally.
+ fn log(&self, record: &Record);
+
+ /// Flushes any buffered records.
+ fn flush(&self);
+}
+
+// Just used as a dummy initial value for LOGGER
+struct NopLogger;
+
+impl Log for NopLogger {
+ fn enabled(&self, _: &Metadata) -> bool {
+ false
+ }
+
+ fn log(&self, _: &Record) {}
+ fn flush(&self) {}
+}
+
+/// Sets the global maximum log level.
+///
+/// Generally, this should only be called by the active logging implementation.
+#[inline]
+pub fn set_max_level(level: LevelFilter) {
+ MAX_LOG_LEVEL_FILTER.store(level as usize, Ordering::SeqCst)
+}
+
+/// Returns the current maximum log level.
+///
+/// The [`log!`], [`error!`], [`warn!`], [`info!`], [`debug!`], and [`trace!`] macros check
+/// this value and discard any message logged at a higher level. The maximum
+/// 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
+/// [`set_max_level`]: fn.set_max_level.html
+#[inline(always)]
+pub fn max_level() -> LevelFilter {
+ // Since `LevelFilter` is `repr(usize)`,
+ // this transmute is sound if and only if `MAX_LOG_LEVEL_FILTER`
+ // is set to a usize that is a valid discriminant for `LevelFilter`.
+ // Since `MAX_LOG_LEVEL_FILTER` is private, the only time it's set
+ // is by `set_max_level` above, i.e. by casting a `LevelFilter` to `usize`.
+ // So any usize stored in `MAX_LOG_LEVEL_FILTER` is a valid discriminant.
+ unsafe { mem::transmute(MAX_LOG_LEVEL_FILTER.load(Ordering::Relaxed)) }
+}
+
+/// Sets the global logger to a `Box<Log>`.
+///
+/// This is a simple convenience wrapper over `set_logger`, which takes a
+/// `Box<Log>` rather than a `&'static Log`. See the documentation for
+/// [`set_logger`] for more details.
+///
+/// Requires the `std` feature.
+///
+/// # Errors
+///
+/// An error is returned if a logger has already been set.
+///
+/// [`set_logger`]: fn.set_logger.html
+#[cfg(all(feature = "std", atomic_cas))]
+pub fn set_boxed_logger(logger: Box<dyn Log>) -> Result<(), SetLoggerError> {
+ set_logger_inner(|| Box::leak(logger))
+}
+
+/// Sets the global logger to a `&'static Log`.
+///
+/// This function may only be called once in the lifetime of a program. Any log
+/// events that occur before the call to `set_logger` completes will be ignored.
+///
+/// This function does not typically need to be called manually. Logger
+/// implementations should provide an initialization method that installs the
+/// logger internally.
+///
+/// # Availability
+///
+/// This method is available even when the `std` feature is disabled. However,
+/// it is currently unavailable on `thumbv6` targets, which lack support for
+/// some atomic operations which are used by this function. Even on those
+/// targets, [`set_logger_racy`] will be available.
+///
+/// # Errors
+///
+/// An error is returned if a logger has already been set.
+///
+/// # Examples
+///
+/// ```edition2018
+/// use log::{error, info, warn, Record, Level, Metadata, LevelFilter};
+///
+/// static MY_LOGGER: MyLogger = MyLogger;
+///
+/// struct MyLogger;
+///
+/// impl log::Log for MyLogger {
+/// fn enabled(&self, metadata: &Metadata) -> bool {
+/// metadata.level() <= Level::Info
+/// }
+///
+/// fn log(&self, record: &Record) {
+/// if self.enabled(record.metadata()) {
+/// println!("{} - {}", record.level(), record.args());
+/// }
+/// }
+/// fn flush(&self) {}
+/// }
+///
+/// # fn main(){
+/// log::set_logger(&MY_LOGGER).unwrap();
+/// log::set_max_level(LevelFilter::Info);
+///
+/// info!("hello log");
+/// warn!("warning");
+/// error!("oops");
+/// # }
+/// ```
+///
+/// [`set_logger_racy`]: fn.set_logger_racy.html
+#[cfg(atomic_cas)]
+pub fn set_logger(logger: &'static dyn Log) -> Result<(), SetLoggerError> {
+ set_logger_inner(|| logger)
+}
+
+#[cfg(atomic_cas)]
+fn set_logger_inner<F>(make_logger: F) -> Result<(), SetLoggerError>
+where
+ F: FnOnce() -> &'static dyn Log,
+{
+ match STATE.compare_and_swap(UNINITIALIZED, INITIALIZING, Ordering::SeqCst) {
+ UNINITIALIZED => {
+ unsafe {
+ LOGGER = make_logger();
+ }
+ STATE.store(INITIALIZED, Ordering::SeqCst);
+ Ok(())
+ }
+ INITIALIZING => {
+ while STATE.load(Ordering::SeqCst) == INITIALIZING {
+ std::sync::atomic::spin_loop_hint();
+ }
+ Err(SetLoggerError(()))
+ }
+ _ => Err(SetLoggerError(())),
+ }
+}
+
+/// A thread-unsafe version of [`set_logger`].
+///
+/// This function is available on all platforms, even those that do not have
+/// support for atomics that is needed by [`set_logger`].
+///
+/// In almost all cases, [`set_logger`] should be preferred.
+///
+/// # Safety
+///
+/// This function is only safe to call when no other logger initialization
+/// function is called while this function still executes.
+///
+/// This can be upheld by (for example) making sure that **there are no other
+/// threads**, and (on embedded) that **interrupts are disabled**.
+///
+/// It is safe to use other logging functions while this function runs
+/// (including all logging macros).
+///
+/// [`set_logger`]: fn.set_logger.html
+pub unsafe fn set_logger_racy(logger: &'static dyn Log) -> Result<(), SetLoggerError> {
+ match STATE.load(Ordering::SeqCst) {
+ UNINITIALIZED => {
+ LOGGER = logger;
+ STATE.store(INITIALIZED, Ordering::SeqCst);
+ Ok(())
+ }
+ INITIALIZING => {
+ // This is just plain UB, since we were racing another initialization function
+ unreachable!("set_logger_racy must not be used with other initialization functions")
+ }
+ _ => Err(SetLoggerError(())),
+ }
+}
+
+/// The type returned by [`set_logger`] if [`set_logger`] has already been called.
+///
+/// [`set_logger`]: fn.set_logger.html
+#[allow(missing_copy_implementations)]
+#[derive(Debug)]
+pub struct SetLoggerError(());
+
+impl fmt::Display for SetLoggerError {
+ fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+ fmt.write_str(SET_LOGGER_ERROR)
+ }
+}
+
+// The Error trait is not available in libcore
+#[cfg(feature = "std")]
+impl error::Error for SetLoggerError {}
+
+/// The type returned by [`from_str`] when the string doesn't match any of the log levels.
+///
+/// [`from_str`]: https://doc.rust-lang.org/std/str/trait.FromStr.html#tymethod.from_str
+#[allow(missing_copy_implementations)]
+#[derive(Debug, PartialEq)]
+pub struct ParseLevelError(());
+
+impl fmt::Display for ParseLevelError {
+ fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+ fmt.write_str(LEVEL_PARSE_ERROR)
+ }
+}
+
+// The Error trait is not available in libcore
+#[cfg(feature = "std")]
+impl error::Error for ParseLevelError {}
+
+/// Returns a reference to the logger.
+///
+/// If a logger has not been set, a no-op implementation is returned.
+pub fn logger() -> &'static dyn Log {
+ if STATE.load(Ordering::SeqCst) != INITIALIZED {
+ static NOP: NopLogger = NopLogger;
+ &NOP
+ } else {
+ unsafe { LOGGER }
+ }
+}
+
+// WARNING: this is not part of the crate's public API and is subject to change at any time
+#[doc(hidden)]
+pub fn __private_api_log(
+ args: fmt::Arguments,
+ level: Level,
+ &(target, module_path, file, line): &(&str, &'static str, &'static str, u32),
+) {
+ logger().log(
+ &Record::builder()
+ .args(args)
+ .level(level)
+ .target(target)
+ .module_path_static(Some(module_path))
+ .file_static(Some(file))
+ .line(Some(line))
+ .build(),
+ );
+}
+
+// WARNING: this is not part of the crate's public API and is subject to change at any time
+#[doc(hidden)]
+pub fn __private_api_log_lit(
+ message: &str,
+ level: Level,
+ &(target, module_path, file, line): &(&str, &'static str, &'static str, u32),
+) {
+ logger().log(
+ &Record::builder()
+ .args(format_args!("{}", message))
+ .level(level)
+ .target(target)
+ .module_path_static(Some(module_path))
+ .file_static(Some(file))
+ .line(Some(line))
+ .build(),
+ );
+}
+
+// WARNING: this is not part of the crate's public API and is subject to change at any time
+#[doc(hidden)]
+pub fn __private_api_enabled(level: Level, target: &str) -> bool {
+ logger().enabled(&Metadata::builder().level(level).target(target).build())
+}
+
+/// The statically resolved maximum log level.
+///
+/// See the crate level documentation for information on how to configure this.
+///
+/// This value is checked by the log macros, but not by the `Log`ger returned by
+/// the [`logger`] function. Code that manually calls functions on that value
+/// should compare the level against this value.
+///
+/// [`logger`]: fn.logger.html
+pub const STATIC_MAX_LEVEL: LevelFilter = MAX_LEVEL_INNER;
+
+cfg_if! {
+ if #[cfg(all(not(debug_assertions), feature = "release_max_level_off"))] {
+ const MAX_LEVEL_INNER: LevelFilter = LevelFilter::Off;
+ } else if #[cfg(all(not(debug_assertions), feature = "release_max_level_error"))] {
+ const MAX_LEVEL_INNER: LevelFilter = LevelFilter::Error;
+ } else if #[cfg(all(not(debug_assertions), feature = "release_max_level_warn"))] {
+ const MAX_LEVEL_INNER: LevelFilter = LevelFilter::Warn;
+ } else if #[cfg(all(not(debug_assertions), feature = "release_max_level_info"))] {
+ const MAX_LEVEL_INNER: LevelFilter = LevelFilter::Info;
+ } else if #[cfg(all(not(debug_assertions), feature = "release_max_level_debug"))] {
+ const MAX_LEVEL_INNER: LevelFilter = LevelFilter::Debug;
+ } else if #[cfg(all(not(debug_assertions), feature = "release_max_level_trace"))] {
+ const MAX_LEVEL_INNER: LevelFilter = LevelFilter::Trace;
+ } else if #[cfg(feature = "max_level_off")] {
+ const MAX_LEVEL_INNER: LevelFilter = LevelFilter::Off;
+ } else if #[cfg(feature = "max_level_error")] {
+ const MAX_LEVEL_INNER: LevelFilter = LevelFilter::Error;
+ } else if #[cfg(feature = "max_level_warn")] {
+ const MAX_LEVEL_INNER: LevelFilter = LevelFilter::Warn;
+ } else if #[cfg(feature = "max_level_info")] {
+ const MAX_LEVEL_INNER: LevelFilter = LevelFilter::Info;
+ } else if #[cfg(feature = "max_level_debug")] {
+ const MAX_LEVEL_INNER: LevelFilter = LevelFilter::Debug;
+ } else {
+ const MAX_LEVEL_INNER: LevelFilter = LevelFilter::Trace;
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ extern crate std;
+ use super::{Level, LevelFilter, ParseLevelError};
+ use tests::std::string::ToString;
+
+ #[test]
+ fn test_levelfilter_from_str() {
+ let tests = [
+ ("off", Ok(LevelFilter::Off)),
+ ("error", Ok(LevelFilter::Error)),
+ ("warn", Ok(LevelFilter::Warn)),
+ ("info", Ok(LevelFilter::Info)),
+ ("debug", Ok(LevelFilter::Debug)),
+ ("trace", Ok(LevelFilter::Trace)),
+ ("OFF", Ok(LevelFilter::Off)),
+ ("ERROR", Ok(LevelFilter::Error)),
+ ("WARN", Ok(LevelFilter::Warn)),
+ ("INFO", Ok(LevelFilter::Info)),
+ ("DEBUG", Ok(LevelFilter::Debug)),
+ ("TRACE", Ok(LevelFilter::Trace)),
+ ("asdf", Err(ParseLevelError(()))),
+ ];
+ for &(s, ref expected) in &tests {
+ assert_eq!(expected, &s.parse());
+ }
+ }
+
+ #[test]
+ fn test_level_from_str() {
+ let tests = [
+ ("OFF", Err(ParseLevelError(()))),
+ ("error", Ok(Level::Error)),
+ ("warn", Ok(Level::Warn)),
+ ("info", Ok(Level::Info)),
+ ("debug", Ok(Level::Debug)),
+ ("trace", Ok(Level::Trace)),
+ ("ERROR", Ok(Level::Error)),
+ ("WARN", Ok(Level::Warn)),
+ ("INFO", Ok(Level::Info)),
+ ("DEBUG", Ok(Level::Debug)),
+ ("TRACE", Ok(Level::Trace)),
+ ("asdf", Err(ParseLevelError(()))),
+ ];
+ for &(s, ref expected) in &tests {
+ assert_eq!(expected, &s.parse());
+ }
+ }
+
+ #[test]
+ fn test_level_show() {
+ assert_eq!("INFO", Level::Info.to_string());
+ assert_eq!("ERROR", Level::Error.to_string());
+ }
+
+ #[test]
+ fn test_levelfilter_show() {
+ assert_eq!("OFF", LevelFilter::Off.to_string());
+ assert_eq!("ERROR", LevelFilter::Error.to_string());
+ }
+
+ #[test]
+ fn test_cross_cmp() {
+ assert!(Level::Debug > LevelFilter::Error);
+ assert!(LevelFilter::Warn < Level::Trace);
+ assert!(LevelFilter::Off < Level::Error);
+ }
+
+ #[test]
+ fn test_cross_eq() {
+ assert!(Level::Error == LevelFilter::Error);
+ assert!(LevelFilter::Off != Level::Error);
+ assert!(Level::Trace == LevelFilter::Trace);
+ }
+
+ #[test]
+ fn test_to_level() {
+ assert_eq!(Some(Level::Error), LevelFilter::Error.to_level());
+ assert_eq!(None, LevelFilter::Off.to_level());
+ assert_eq!(Some(Level::Debug), LevelFilter::Debug.to_level());
+ }
+
+ #[test]
+ fn test_to_level_filter() {
+ assert_eq!(LevelFilter::Error, Level::Error.to_level_filter());
+ assert_eq!(LevelFilter::Trace, Level::Trace.to_level_filter());
+ }
+
+ #[test]
+ #[cfg(feature = "std")]
+ fn test_error_trait() {
+ use super::SetLoggerError;
+ let e = SetLoggerError(());
+ assert_eq!(
+ &e.to_string(),
+ "attempted to set a logger after the logging system \
+ was already initialized"
+ );
+ }
+
+ #[test]
+ fn test_metadata_builder() {
+ use super::MetadataBuilder;
+ let target = "myApp";
+ let metadata_test = MetadataBuilder::new()
+ .level(Level::Debug)
+ .target(target)
+ .build();
+ assert_eq!(metadata_test.level(), Level::Debug);
+ assert_eq!(metadata_test.target(), "myApp");
+ }
+
+ #[test]
+ fn test_metadata_convenience_builder() {
+ use super::Metadata;
+ let target = "myApp";
+ let metadata_test = Metadata::builder()
+ .level(Level::Debug)
+ .target(target)
+ .build();
+ assert_eq!(metadata_test.level(), Level::Debug);
+ assert_eq!(metadata_test.target(), "myApp");
+ }
+
+ #[test]
+ fn test_record_builder() {
+ use super::{MetadataBuilder, RecordBuilder};
+ let target = "myApp";
+ let metadata = MetadataBuilder::new().target(target).build();
+ let fmt_args = format_args!("hello");
+ let record_test = RecordBuilder::new()
+ .args(fmt_args)
+ .metadata(metadata)
+ .module_path(Some("foo"))
+ .file(Some("bar"))
+ .line(Some(30))
+ .build();
+ assert_eq!(record_test.metadata().target(), "myApp");
+ assert_eq!(record_test.module_path(), Some("foo"));
+ assert_eq!(record_test.file(), Some("bar"));
+ assert_eq!(record_test.line(), Some(30));
+ }
+
+ #[test]
+ fn test_record_convenience_builder() {
+ use super::{Metadata, Record};
+ let target = "myApp";
+ let metadata = Metadata::builder().target(target).build();
+ let fmt_args = format_args!("hello");
+ let record_test = Record::builder()
+ .args(fmt_args)
+ .metadata(metadata)
+ .module_path(Some("foo"))
+ .file(Some("bar"))
+ .line(Some(30))
+ .build();
+ assert_eq!(record_test.target(), "myApp");
+ assert_eq!(record_test.module_path(), Some("foo"));
+ assert_eq!(record_test.file(), Some("bar"));
+ assert_eq!(record_test.line(), Some(30));
+ }
+
+ #[test]
+ fn test_record_complete_builder() {
+ use super::{Level, Record};
+ let target = "myApp";
+ let record_test = Record::builder()
+ .module_path(Some("foo"))
+ .file(Some("bar"))
+ .line(Some(30))
+ .target(target)
+ .level(Level::Error)
+ .build();
+ assert_eq!(record_test.target(), "myApp");
+ assert_eq!(record_test.level(), Level::Error);
+ assert_eq!(record_test.module_path(), Some("foo"));
+ assert_eq!(record_test.file(), Some("bar"));
+ assert_eq!(record_test.line(), Some(30));
+ }
+
+ #[test]
+ #[cfg(feature = "kv_unstable")]
+ fn test_record_key_values_builder() {
+ use super::Record;
+ use kv::{self, Visitor};
+
+ struct TestVisitor {
+ seen_pairs: usize,
+ }
+
+ impl<'kvs> Visitor<'kvs> for TestVisitor {
+ fn visit_pair(
+ &mut self,
+ _: kv::Key<'kvs>,
+ _: kv::Value<'kvs>,
+ ) -> Result<(), kv::Error> {
+ self.seen_pairs += 1;
+ Ok(())
+ }
+ }
+
+ let kvs: &[(&str, i32)] = &[("a", 1), ("b", 2)];
+ let record_test = Record::builder().key_values(&kvs).build();
+
+ let mut visitor = TestVisitor { seen_pairs: 0 };
+
+ record_test.key_values().visit(&mut visitor).unwrap();
+
+ assert_eq!(2, visitor.seen_pairs);
+ }
+
+ #[test]
+ #[cfg(feature = "kv_unstable")]
+ fn test_record_key_values_get_coerce() {
+ use super::Record;
+
+ let kvs: &[(&str, &str)] = &[("a", "1"), ("b", "2")];
+ let record = Record::builder().key_values(&kvs).build();
+
+ assert_eq!(
+ "2",
+ record
+ .key_values()
+ .get("b".into())
+ .expect("missing key")
+ .to_borrowed_str()
+ .expect("invalid value")
+ );
+ }
+}
diff --git a/src/macros.rs b/src/macros.rs
index bb40b71..48de437 100644
--- a/src/macros.rs
+++ b/src/macros.rs
@@ -1,250 +1,262 @@
-// Copyright 2014-2015 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-/// The standard logging macro.
-///
-/// This macro will generically log with the specified `Level` and `format!`
-/// based argument list.
-///
-/// # Examples
-///
-/// ```edition2018
-/// use log::{log, Level};
-///
-/// # fn main() {
-/// let data = (42, "Forty-two");
-/// let private_data = "private";
-///
-/// log!(Level::Error, "Received errors: {}, {}", data.0, data.1);
-/// log!(target: "app_events", Level::Warn, "App warning: {}, {}, {}",
-/// data.0, data.1, private_data);
-/// # }
-/// ```
-#[macro_export(local_inner_macros)]
-macro_rules! log {
- (target: $target:expr, $lvl:expr, $($arg:tt)+) => ({
- let lvl = $lvl;
- if lvl <= $crate::STATIC_MAX_LEVEL && lvl <= $crate::max_level() {
- $crate::__private_api_log(
- __log_format_args!($($arg)+),
- lvl,
- &($target, __log_module_path!(), __log_file!(), __log_line!()),
- );
- }
- });
- ($lvl:expr, $($arg:tt)+) => (log!(target: __log_module_path!(), $lvl, $($arg)+))
-}
-
-/// Logs a message at the error level.
-///
-/// # Examples
-///
-/// ```edition2018
-/// use log::error;
-///
-/// # fn main() {
-/// let (err_info, port) = ("No connection", 22);
-///
-/// error!("Error: {} on port {}", err_info, port);
-/// error!(target: "app_events", "App Error: {}, Port: {}", err_info, 22);
-/// # }
-/// ```
-#[macro_export(local_inner_macros)]
-macro_rules! error {
- (target: $target:expr, $($arg:tt)+) => (
- log!(target: $target, $crate::Level::Error, $($arg)+);
- );
- ($($arg:tt)+) => (
- log!($crate::Level::Error, $($arg)+);
- )
-}
-
-/// Logs a message at the warn level.
-///
-/// # Examples
-///
-/// ```edition2018
-/// use log::warn;
-///
-/// # fn main() {
-/// let warn_description = "Invalid Input";
-///
-/// warn!("Warning! {}!", warn_description);
-/// warn!(target: "input_events", "App received warning: {}", warn_description);
-/// # }
-/// ```
-#[macro_export(local_inner_macros)]
-macro_rules! warn {
- (target: $target:expr, $($arg:tt)+) => (
- log!(target: $target, $crate::Level::Warn, $($arg)+);
- );
- ($($arg:tt)+) => (
- log!($crate::Level::Warn, $($arg)+);
- )
-}
-
-/// Logs a message at the info level.
-///
-/// # Examples
-///
-/// ```edition2018
-/// use log::info;
-///
-/// # fn main() {
-/// # struct Connection { port: u32, speed: f32 }
-/// let conn_info = Connection { port: 40, speed: 3.20 };
-///
-/// info!("Connected to port {} at {} Mb/s", conn_info.port, conn_info.speed);
-/// info!(target: "connection_events", "Successfull connection, port: {}, speed: {}",
-/// conn_info.port, conn_info.speed);
-/// # }
-/// ```
-#[macro_export(local_inner_macros)]
-macro_rules! info {
- (target: $target:expr, $($arg:tt)+) => (
- log!(target: $target, $crate::Level::Info, $($arg)+);
- );
- ($($arg:tt)+) => (
- log!($crate::Level::Info, $($arg)+);
- )
-}
-
-/// Logs a message at the debug level.
-///
-/// # Examples
-///
-/// ```edition2018
-/// use log::debug;
-///
-/// # fn main() {
-/// # struct Position { x: f32, y: f32 }
-/// let pos = Position { x: 3.234, y: -1.223 };
-///
-/// debug!("New position: x: {}, y: {}", pos.x, pos.y);
-/// debug!(target: "app_events", "New position: x: {}, y: {}", pos.x, pos.y);
-/// # }
-/// ```
-#[macro_export(local_inner_macros)]
-macro_rules! debug {
- (target: $target:expr, $($arg:tt)+) => (
- log!(target: $target, $crate::Level::Debug, $($arg)+);
- );
- ($($arg:tt)+) => (
- log!($crate::Level::Debug, $($arg)+);
- )
-}
-
-/// Logs a message at the trace level.
-///
-/// # Examples
-///
-/// ```edition2018
-/// use log::trace;
-///
-/// # fn main() {
-/// # struct Position { x: f32, y: f32 }
-/// let pos = Position { x: 3.234, y: -1.223 };
-///
-/// trace!("Position is: x: {}, y: {}", pos.x, pos.y);
-/// trace!(target: "app_events", "x is {} and y is {}",
-/// if pos.x >= 0.0 { "positive" } else { "negative" },
-/// if pos.y >= 0.0 { "positive" } else { "negative" });
-/// # }
-/// ```
-#[macro_export(local_inner_macros)]
-macro_rules! trace {
- (target: $target:expr, $($arg:tt)+) => (
- log!(target: $target, $crate::Level::Trace, $($arg)+);
- );
- ($($arg:tt)+) => (
- log!($crate::Level::Trace, $($arg)+);
- )
-}
-
-/// Determines if a message logged at the specified level in that module will
-/// be logged.
-///
-/// This can be used to avoid expensive computation of log message arguments if
-/// the message would be ignored anyway.
-///
-/// # Examples
-///
-/// ```edition2018
-/// use log::Level::Debug;
-/// use log::{debug, log_enabled};
-///
-/// # fn foo() {
-/// if log_enabled!(Debug) {
-/// let data = expensive_call();
-/// debug!("expensive debug data: {} {}", data.x, data.y);
-/// }
-/// if log_enabled!(target: "Global", Debug) {
-/// let data = expensive_call();
-/// debug!(target: "Global", "expensive debug data: {} {}", data.x, data.y);
-/// }
-/// # }
-/// # struct Data { x: u32, y: u32 }
-/// # fn expensive_call() -> Data { Data { x: 0, y: 0 } }
-/// # fn main() {}
-/// ```
-#[macro_export(local_inner_macros)]
-macro_rules! log_enabled {
- (target: $target:expr, $lvl:expr) => {{
- let lvl = $lvl;
- lvl <= $crate::STATIC_MAX_LEVEL
- && lvl <= $crate::max_level()
- && $crate::__private_api_enabled(lvl, $target)
- }};
- ($lvl:expr) => {
- log_enabled!(target: __log_module_path!(), $lvl)
- };
-}
-
-// The log macro above cannot invoke format_args directly because it uses
-// local_inner_macros. A format_args invocation there would resolve to
-// $crate::format_args which does not exist. Instead invoke format_args here
-// outside of local_inner_macros so that it resolves (probably) to
-// core::format_args or std::format_args. Same for the several macros that
-// follow.
-//
-// This is a workaround until we drop support for pre-1.30 compilers. At that
-// point we can remove use of local_inner_macros, use $crate:: when invoking
-// local macros, and invoke format_args directly.
-#[doc(hidden)]
-#[macro_export]
-macro_rules! __log_format_args {
- ($($args:tt)*) => {
- format_args!($($args)*)
- };
-}
-
-#[doc(hidden)]
-#[macro_export]
-macro_rules! __log_module_path {
- () => {
- module_path!()
- };
-}
-
-#[doc(hidden)]
-#[macro_export]
-macro_rules! __log_file {
- () => {
- file!()
- };
-}
-
-#[doc(hidden)]
-#[macro_export]
-macro_rules! __log_line {
- () => {
- line!()
- };
-}
+// Copyright 2014-2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+/// The standard logging macro.
+///
+/// This macro will generically log with the specified `Level` and `format!`
+/// based argument list.
+///
+/// # Examples
+///
+/// ```edition2018
+/// use log::{log, Level};
+///
+/// # fn main() {
+/// let data = (42, "Forty-two");
+/// let private_data = "private";
+///
+/// log!(Level::Error, "Received errors: {}, {}", data.0, data.1);
+/// log!(target: "app_events", Level::Warn, "App warning: {}, {}, {}",
+/// data.0, data.1, private_data);
+/// # }
+/// ```
+#[macro_export(local_inner_macros)]
+macro_rules! log {
+ (target: $target:expr, $lvl:expr, $message:expr) => ({
+ let lvl = $lvl;
+ if lvl <= $crate::STATIC_MAX_LEVEL && lvl <= $crate::max_level() {
+ // ensure that $message is a valid format string literal
+ let _ = __log_format_args!($message);
+ $crate::__private_api_log_lit(
+ $message,
+ lvl,
+ &($target, __log_module_path!(), __log_file!(), __log_line!()),
+ );
+ }
+ });
+ (target: $target:expr, $lvl:expr, $($arg:tt)+) => ({
+ let lvl = $lvl;
+ if lvl <= $crate::STATIC_MAX_LEVEL && lvl <= $crate::max_level() {
+ $crate::__private_api_log(
+ __log_format_args!($($arg)+),
+ lvl,
+ &($target, __log_module_path!(), __log_file!(), __log_line!()),
+ );
+ }
+ });
+ ($lvl:expr, $($arg:tt)+) => (log!(target: __log_module_path!(), $lvl, $($arg)+))
+}
+
+/// Logs a message at the error level.
+///
+/// # Examples
+///
+/// ```edition2018
+/// use log::error;
+///
+/// # fn main() {
+/// let (err_info, port) = ("No connection", 22);
+///
+/// error!("Error: {} on port {}", err_info, port);
+/// error!(target: "app_events", "App Error: {}, Port: {}", err_info, 22);
+/// # }
+/// ```
+#[macro_export(local_inner_macros)]
+macro_rules! error {
+ (target: $target:expr, $($arg:tt)+) => (
+ log!(target: $target, $crate::Level::Error, $($arg)+);
+ );
+ ($($arg:tt)+) => (
+ log!($crate::Level::Error, $($arg)+);
+ )
+}
+
+/// Logs a message at the warn level.
+///
+/// # Examples
+///
+/// ```edition2018
+/// use log::warn;
+///
+/// # fn main() {
+/// let warn_description = "Invalid Input";
+///
+/// warn!("Warning! {}!", warn_description);
+/// warn!(target: "input_events", "App received warning: {}", warn_description);
+/// # }
+/// ```
+#[macro_export(local_inner_macros)]
+macro_rules! warn {
+ (target: $target:expr, $($arg:tt)+) => (
+ log!(target: $target, $crate::Level::Warn, $($arg)+);
+ );
+ ($($arg:tt)+) => (
+ log!($crate::Level::Warn, $($arg)+);
+ )
+}
+
+/// Logs a message at the info level.
+///
+/// # Examples
+///
+/// ```edition2018
+/// use log::info;
+///
+/// # fn main() {
+/// # struct Connection { port: u32, speed: f32 }
+/// let conn_info = Connection { port: 40, speed: 3.20 };
+///
+/// info!("Connected to port {} at {} Mb/s", conn_info.port, conn_info.speed);
+/// info!(target: "connection_events", "Successfull connection, port: {}, speed: {}",
+/// conn_info.port, conn_info.speed);
+/// # }
+/// ```
+#[macro_export(local_inner_macros)]
+macro_rules! info {
+ (target: $target:expr, $($arg:tt)+) => (
+ log!(target: $target, $crate::Level::Info, $($arg)+);
+ );
+ ($($arg:tt)+) => (
+ log!($crate::Level::Info, $($arg)+);
+ )
+}
+
+/// Logs a message at the debug level.
+///
+/// # Examples
+///
+/// ```edition2018
+/// use log::debug;
+///
+/// # fn main() {
+/// # struct Position { x: f32, y: f32 }
+/// let pos = Position { x: 3.234, y: -1.223 };
+///
+/// debug!("New position: x: {}, y: {}", pos.x, pos.y);
+/// debug!(target: "app_events", "New position: x: {}, y: {}", pos.x, pos.y);
+/// # }
+/// ```
+#[macro_export(local_inner_macros)]
+macro_rules! debug {
+ (target: $target:expr, $($arg:tt)+) => (
+ log!(target: $target, $crate::Level::Debug, $($arg)+);
+ );
+ ($($arg:tt)+) => (
+ log!($crate::Level::Debug, $($arg)+);
+ )
+}
+
+/// Logs a message at the trace level.
+///
+/// # Examples
+///
+/// ```edition2018
+/// use log::trace;
+///
+/// # fn main() {
+/// # struct Position { x: f32, y: f32 }
+/// let pos = Position { x: 3.234, y: -1.223 };
+///
+/// trace!("Position is: x: {}, y: {}", pos.x, pos.y);
+/// trace!(target: "app_events", "x is {} and y is {}",
+/// if pos.x >= 0.0 { "positive" } else { "negative" },
+/// if pos.y >= 0.0 { "positive" } else { "negative" });
+/// # }
+/// ```
+#[macro_export(local_inner_macros)]
+macro_rules! trace {
+ (target: $target:expr, $($arg:tt)+) => (
+ log!(target: $target, $crate::Level::Trace, $($arg)+);
+ );
+ ($($arg:tt)+) => (
+ log!($crate::Level::Trace, $($arg)+);
+ )
+}
+
+/// Determines if a message logged at the specified level in that module will
+/// be logged.
+///
+/// This can be used to avoid expensive computation of log message arguments if
+/// the message would be ignored anyway.
+///
+/// # Examples
+///
+/// ```edition2018
+/// use log::Level::Debug;
+/// use log::{debug, log_enabled};
+///
+/// # fn foo() {
+/// if log_enabled!(Debug) {
+/// let data = expensive_call();
+/// debug!("expensive debug data: {} {}", data.x, data.y);
+/// }
+/// if log_enabled!(target: "Global", Debug) {
+/// let data = expensive_call();
+/// debug!(target: "Global", "expensive debug data: {} {}", data.x, data.y);
+/// }
+/// # }
+/// # struct Data { x: u32, y: u32 }
+/// # fn expensive_call() -> Data { Data { x: 0, y: 0 } }
+/// # fn main() {}
+/// ```
+#[macro_export(local_inner_macros)]
+macro_rules! log_enabled {
+ (target: $target:expr, $lvl:expr) => {{
+ let lvl = $lvl;
+ lvl <= $crate::STATIC_MAX_LEVEL
+ && lvl <= $crate::max_level()
+ && $crate::__private_api_enabled(lvl, $target)
+ }};
+ ($lvl:expr) => {
+ log_enabled!(target: __log_module_path!(), $lvl)
+ };
+}
+
+// The log macro above cannot invoke format_args directly because it uses
+// local_inner_macros. A format_args invocation there would resolve to
+// $crate::format_args which does not exist. Instead invoke format_args here
+// outside of local_inner_macros so that it resolves (probably) to
+// core::format_args or std::format_args. Same for the several macros that
+// follow.
+//
+// This is a workaround until we drop support for pre-1.30 compilers. At that
+// point we can remove use of local_inner_macros, use $crate:: when invoking
+// local macros, and invoke format_args directly.
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __log_format_args {
+ ($($args:tt)*) => {
+ format_args!($($args)*)
+ };
+}
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __log_module_path {
+ () => {
+ module_path!()
+ };
+}
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __log_file {
+ () => {
+ file!()
+ };
+}
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __log_line {
+ () => {
+ line!()
+ };
+}
diff --git a/src/serde.rs b/src/serde.rs
index efc9f14..8320ce1 100644
--- a/src/serde.rs
+++ b/src/serde.rs
@@ -1,329 +1,329 @@
-#![cfg(feature = "serde")]
-
-extern crate serde;
-use self::serde::de::{
- Deserialize, DeserializeSeed, Deserializer, EnumAccess, Error, Unexpected, VariantAccess,
- Visitor,
-};
-use self::serde::ser::{Serialize, Serializer};
-
-use {Level, LevelFilter, LOG_LEVEL_NAMES};
-
-use std::fmt;
-use std::str::{self, FromStr};
-
-// The Deserialize impls are handwritten to be case insensitive using FromStr.
-
-impl Serialize for Level {
- fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
- where
- S: Serializer,
- {
- match *self {
- Level::Error => serializer.serialize_unit_variant("Level", 0, "ERROR"),
- Level::Warn => serializer.serialize_unit_variant("Level", 1, "WARN"),
- Level::Info => serializer.serialize_unit_variant("Level", 2, "INFO"),
- Level::Debug => serializer.serialize_unit_variant("Level", 3, "DEBUG"),
- Level::Trace => serializer.serialize_unit_variant("Level", 4, "TRACE"),
- }
- }
-}
-
-impl<'de> Deserialize<'de> for Level {
- fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
- where
- D: Deserializer<'de>,
- {
- struct LevelIdentifier;
-
- impl<'de> Visitor<'de> for LevelIdentifier {
- type Value = Level;
-
- fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
- formatter.write_str("log level")
- }
-
- fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
- where
- E: Error,
- {
- // Case insensitive.
- FromStr::from_str(s).map_err(|_| Error::unknown_variant(s, &LOG_LEVEL_NAMES[1..]))
- }
-
- fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
- where
- E: Error,
- {
- let variant = str::from_utf8(value)
- .map_err(|_| Error::invalid_value(Unexpected::Bytes(value), &self))?;
-
- self.visit_str(variant)
- }
- }
-
- impl<'de> DeserializeSeed<'de> for LevelIdentifier {
- type Value = Level;
-
- fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
- where
- D: Deserializer<'de>,
- {
- deserializer.deserialize_identifier(LevelIdentifier)
- }
- }
-
- struct LevelEnum;
-
- impl<'de> Visitor<'de> for LevelEnum {
- type Value = Level;
-
- fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
- formatter.write_str("log level")
- }
-
- fn visit_enum<A>(self, value: A) -> Result<Self::Value, A::Error>
- where
- A: EnumAccess<'de>,
- {
- let (level, variant) = value.variant_seed(LevelIdentifier)?;
- // Every variant is a unit variant.
- variant.unit_variant()?;
- Ok(level)
- }
- }
-
- deserializer.deserialize_enum("Level", &LOG_LEVEL_NAMES[1..], LevelEnum)
- }
-}
-
-impl Serialize for LevelFilter {
- fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
- where
- S: Serializer,
- {
- match *self {
- LevelFilter::Off => serializer.serialize_unit_variant("LevelFilter", 0, "OFF"),
- LevelFilter::Error => serializer.serialize_unit_variant("LevelFilter", 1, "ERROR"),
- LevelFilter::Warn => serializer.serialize_unit_variant("LevelFilter", 2, "WARN"),
- LevelFilter::Info => serializer.serialize_unit_variant("LevelFilter", 3, "INFO"),
- LevelFilter::Debug => serializer.serialize_unit_variant("LevelFilter", 4, "DEBUG"),
- LevelFilter::Trace => serializer.serialize_unit_variant("LevelFilter", 5, "TRACE"),
- }
- }
-}
-
-impl<'de> Deserialize<'de> for LevelFilter {
- fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
- where
- D: Deserializer<'de>,
- {
- struct LevelFilterIdentifier;
-
- impl<'de> Visitor<'de> for LevelFilterIdentifier {
- type Value = LevelFilter;
-
- fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
- formatter.write_str("log level filter")
- }
-
- fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
- where
- E: Error,
- {
- // Case insensitive.
- FromStr::from_str(s).map_err(|_| Error::unknown_variant(s, &LOG_LEVEL_NAMES))
- }
-
- fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
- where
- E: Error,
- {
- let variant = str::from_utf8(value)
- .map_err(|_| Error::invalid_value(Unexpected::Bytes(value), &self))?;
-
- self.visit_str(variant)
- }
- }
-
- impl<'de> DeserializeSeed<'de> for LevelFilterIdentifier {
- type Value = LevelFilter;
-
- fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
- where
- D: Deserializer<'de>,
- {
- deserializer.deserialize_identifier(LevelFilterIdentifier)
- }
- }
-
- struct LevelFilterEnum;
-
- impl<'de> Visitor<'de> for LevelFilterEnum {
- type Value = LevelFilter;
-
- fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
- formatter.write_str("log level filter")
- }
-
- fn visit_enum<A>(self, value: A) -> Result<Self::Value, A::Error>
- where
- A: EnumAccess<'de>,
- {
- let (level_filter, variant) = value.variant_seed(LevelFilterIdentifier)?;
- // Every variant is a unit variant.
- variant.unit_variant()?;
- Ok(level_filter)
- }
- }
-
- deserializer.deserialize_enum("LevelFilter", &LOG_LEVEL_NAMES, LevelFilterEnum)
- }
-}
-
-#[cfg(test)]
-mod tests {
- extern crate serde_test;
- use self::serde_test::{assert_de_tokens, assert_de_tokens_error, assert_tokens, Token};
-
- use {Level, LevelFilter};
-
- fn level_token(variant: &'static str) -> Token {
- Token::UnitVariant {
- name: "Level",
- variant: variant,
- }
- }
-
- fn level_bytes_tokens(variant: &'static [u8]) -> [Token; 3] {
- [
- Token::Enum { name: "Level" },
- Token::Bytes(variant),
- Token::Unit,
- ]
- }
-
- fn level_filter_token(variant: &'static str) -> Token {
- Token::UnitVariant {
- name: "LevelFilter",
- variant: variant,
- }
- }
-
- fn level_filter_bytes_tokens(variant: &'static [u8]) -> [Token; 3] {
- [
- Token::Enum {
- name: "LevelFilter",
- },
- Token::Bytes(variant),
- Token::Unit,
- ]
- }
-
- #[test]
- fn test_level_ser_de() {
- let cases = [
- (Level::Error, [level_token("ERROR")]),
- (Level::Warn, [level_token("WARN")]),
- (Level::Info, [level_token("INFO")]),
- (Level::Debug, [level_token("DEBUG")]),
- (Level::Trace, [level_token("TRACE")]),
- ];
-
- for &(s, expected) in &cases {
- assert_tokens(&s, &expected);
- }
- }
-
- #[test]
- fn test_level_case_insensitive() {
- let cases = [
- (Level::Error, [level_token("error")]),
- (Level::Warn, [level_token("warn")]),
- (Level::Info, [level_token("info")]),
- (Level::Debug, [level_token("debug")]),
- (Level::Trace, [level_token("trace")]),
- ];
-
- for &(s, expected) in &cases {
- assert_de_tokens(&s, &expected);
- }
- }
-
- #[test]
- fn test_level_de_bytes() {
- let cases = [
- (Level::Error, level_bytes_tokens(b"ERROR")),
- (Level::Warn, level_bytes_tokens(b"WARN")),
- (Level::Info, level_bytes_tokens(b"INFO")),
- (Level::Debug, level_bytes_tokens(b"DEBUG")),
- (Level::Trace, level_bytes_tokens(b"TRACE")),
- ];
-
- for &(value, tokens) in &cases {
- assert_de_tokens(&value, &tokens);
- }
- }
-
- #[test]
- fn test_level_de_error() {
- let msg = "unknown variant `errorx`, expected one of \
- `ERROR`, `WARN`, `INFO`, `DEBUG`, `TRACE`";
- assert_de_tokens_error::<Level>(&[level_token("errorx")], msg);
- }
-
- #[test]
- fn test_level_filter_ser_de() {
- let cases = [
- (LevelFilter::Off, [level_filter_token("OFF")]),
- (LevelFilter::Error, [level_filter_token("ERROR")]),
- (LevelFilter::Warn, [level_filter_token("WARN")]),
- (LevelFilter::Info, [level_filter_token("INFO")]),
- (LevelFilter::Debug, [level_filter_token("DEBUG")]),
- (LevelFilter::Trace, [level_filter_token("TRACE")]),
- ];
-
- for &(s, expected) in &cases {
- assert_tokens(&s, &expected);
- }
- }
-
- #[test]
- fn test_level_filter_case_insensitive() {
- let cases = [
- (LevelFilter::Off, [level_filter_token("off")]),
- (LevelFilter::Error, [level_filter_token("error")]),
- (LevelFilter::Warn, [level_filter_token("warn")]),
- (LevelFilter::Info, [level_filter_token("info")]),
- (LevelFilter::Debug, [level_filter_token("debug")]),
- (LevelFilter::Trace, [level_filter_token("trace")]),
- ];
-
- for &(s, expected) in &cases {
- assert_de_tokens(&s, &expected);
- }
- }
-
- #[test]
- fn test_level_filter_de_bytes() {
- let cases = [
- (LevelFilter::Off, level_filter_bytes_tokens(b"OFF")),
- (LevelFilter::Error, level_filter_bytes_tokens(b"ERROR")),
- (LevelFilter::Warn, level_filter_bytes_tokens(b"WARN")),
- (LevelFilter::Info, level_filter_bytes_tokens(b"INFO")),
- (LevelFilter::Debug, level_filter_bytes_tokens(b"DEBUG")),
- (LevelFilter::Trace, level_filter_bytes_tokens(b"TRACE")),
- ];
-
- for &(value, tokens) in &cases {
- assert_de_tokens(&value, &tokens);
- }
- }
-
- #[test]
- fn test_level_filter_de_error() {
- let msg = "unknown variant `errorx`, expected one of \
- `OFF`, `ERROR`, `WARN`, `INFO`, `DEBUG`, `TRACE`";
- assert_de_tokens_error::<LevelFilter>(&[level_filter_token("errorx")], msg);
- }
-}
+#![cfg(feature = "serde")]
+
+extern crate serde;
+use self::serde::de::{
+ Deserialize, DeserializeSeed, Deserializer, EnumAccess, Error, Unexpected, VariantAccess,
+ Visitor,
+};
+use self::serde::ser::{Serialize, Serializer};
+
+use {Level, LevelFilter, LOG_LEVEL_NAMES};
+
+use std::fmt;
+use std::str::{self, FromStr};
+
+// The Deserialize impls are handwritten to be case insensitive using FromStr.
+
+impl Serialize for Level {
+ fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ match *self {
+ Level::Error => serializer.serialize_unit_variant("Level", 0, "ERROR"),
+ Level::Warn => serializer.serialize_unit_variant("Level", 1, "WARN"),
+ Level::Info => serializer.serialize_unit_variant("Level", 2, "INFO"),
+ Level::Debug => serializer.serialize_unit_variant("Level", 3, "DEBUG"),
+ Level::Trace => serializer.serialize_unit_variant("Level", 4, "TRACE"),
+ }
+ }
+}
+
+impl<'de> Deserialize<'de> for Level {
+ fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ struct LevelIdentifier;
+
+ impl<'de> Visitor<'de> for LevelIdentifier {
+ type Value = Level;
+
+ fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ formatter.write_str("log level")
+ }
+
+ fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ // Case insensitive.
+ FromStr::from_str(s).map_err(|_| Error::unknown_variant(s, &LOG_LEVEL_NAMES[1..]))
+ }
+
+ fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ let variant = str::from_utf8(value)
+ .map_err(|_| Error::invalid_value(Unexpected::Bytes(value), &self))?;
+
+ self.visit_str(variant)
+ }
+ }
+
+ impl<'de> DeserializeSeed<'de> for LevelIdentifier {
+ type Value = Level;
+
+ fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ deserializer.deserialize_identifier(LevelIdentifier)
+ }
+ }
+
+ struct LevelEnum;
+
+ impl<'de> Visitor<'de> for LevelEnum {
+ type Value = Level;
+
+ fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ formatter.write_str("log level")
+ }
+
+ fn visit_enum<A>(self, value: A) -> Result<Self::Value, A::Error>
+ where
+ A: EnumAccess<'de>,
+ {
+ let (level, variant) = value.variant_seed(LevelIdentifier)?;
+ // Every variant is a unit variant.
+ variant.unit_variant()?;
+ Ok(level)
+ }
+ }
+
+ deserializer.deserialize_enum("Level", &LOG_LEVEL_NAMES[1..], LevelEnum)
+ }
+}
+
+impl Serialize for LevelFilter {
+ fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ match *self {
+ LevelFilter::Off => serializer.serialize_unit_variant("LevelFilter", 0, "OFF"),
+ LevelFilter::Error => serializer.serialize_unit_variant("LevelFilter", 1, "ERROR"),
+ LevelFilter::Warn => serializer.serialize_unit_variant("LevelFilter", 2, "WARN"),
+ LevelFilter::Info => serializer.serialize_unit_variant("LevelFilter", 3, "INFO"),
+ LevelFilter::Debug => serializer.serialize_unit_variant("LevelFilter", 4, "DEBUG"),
+ LevelFilter::Trace => serializer.serialize_unit_variant("LevelFilter", 5, "TRACE"),
+ }
+ }
+}
+
+impl<'de> Deserialize<'de> for LevelFilter {
+ fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ struct LevelFilterIdentifier;
+
+ impl<'de> Visitor<'de> for LevelFilterIdentifier {
+ type Value = LevelFilter;
+
+ fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ formatter.write_str("log level filter")
+ }
+
+ fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ // Case insensitive.
+ FromStr::from_str(s).map_err(|_| Error::unknown_variant(s, &LOG_LEVEL_NAMES))
+ }
+
+ fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
+ where
+ E: Error,
+ {
+ let variant = str::from_utf8(value)
+ .map_err(|_| Error::invalid_value(Unexpected::Bytes(value), &self))?;
+
+ self.visit_str(variant)
+ }
+ }
+
+ impl<'de> DeserializeSeed<'de> for LevelFilterIdentifier {
+ type Value = LevelFilter;
+
+ fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ deserializer.deserialize_identifier(LevelFilterIdentifier)
+ }
+ }
+
+ struct LevelFilterEnum;
+
+ impl<'de> Visitor<'de> for LevelFilterEnum {
+ type Value = LevelFilter;
+
+ fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ formatter.write_str("log level filter")
+ }
+
+ fn visit_enum<A>(self, value: A) -> Result<Self::Value, A::Error>
+ where
+ A: EnumAccess<'de>,
+ {
+ let (level_filter, variant) = value.variant_seed(LevelFilterIdentifier)?;
+ // Every variant is a unit variant.
+ variant.unit_variant()?;
+ Ok(level_filter)
+ }
+ }
+
+ deserializer.deserialize_enum("LevelFilter", &LOG_LEVEL_NAMES, LevelFilterEnum)
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ extern crate serde_test;
+ use self::serde_test::{assert_de_tokens, assert_de_tokens_error, assert_tokens, Token};
+
+ use {Level, LevelFilter};
+
+ fn level_token(variant: &'static str) -> Token {
+ Token::UnitVariant {
+ name: "Level",
+ variant: variant,
+ }
+ }
+
+ fn level_bytes_tokens(variant: &'static [u8]) -> [Token; 3] {
+ [
+ Token::Enum { name: "Level" },
+ Token::Bytes(variant),
+ Token::Unit,
+ ]
+ }
+
+ fn level_filter_token(variant: &'static str) -> Token {
+ Token::UnitVariant {
+ name: "LevelFilter",
+ variant: variant,
+ }
+ }
+
+ fn level_filter_bytes_tokens(variant: &'static [u8]) -> [Token; 3] {
+ [
+ Token::Enum {
+ name: "LevelFilter",
+ },
+ Token::Bytes(variant),
+ Token::Unit,
+ ]
+ }
+
+ #[test]
+ fn test_level_ser_de() {
+ let cases = [
+ (Level::Error, [level_token("ERROR")]),
+ (Level::Warn, [level_token("WARN")]),
+ (Level::Info, [level_token("INFO")]),
+ (Level::Debug, [level_token("DEBUG")]),
+ (Level::Trace, [level_token("TRACE")]),
+ ];
+
+ for &(s, expected) in &cases {
+ assert_tokens(&s, &expected);
+ }
+ }
+
+ #[test]
+ fn test_level_case_insensitive() {
+ let cases = [
+ (Level::Error, [level_token("error")]),
+ (Level::Warn, [level_token("warn")]),
+ (Level::Info, [level_token("info")]),
+ (Level::Debug, [level_token("debug")]),
+ (Level::Trace, [level_token("trace")]),
+ ];
+
+ for &(s, expected) in &cases {
+ assert_de_tokens(&s, &expected);
+ }
+ }
+
+ #[test]
+ fn test_level_de_bytes() {
+ let cases = [
+ (Level::Error, level_bytes_tokens(b"ERROR")),
+ (Level::Warn, level_bytes_tokens(b"WARN")),
+ (Level::Info, level_bytes_tokens(b"INFO")),
+ (Level::Debug, level_bytes_tokens(b"DEBUG")),
+ (Level::Trace, level_bytes_tokens(b"TRACE")),
+ ];
+
+ for &(value, tokens) in &cases {
+ assert_de_tokens(&value, &tokens);
+ }
+ }
+
+ #[test]
+ fn test_level_de_error() {
+ let msg = "unknown variant `errorx`, expected one of \
+ `ERROR`, `WARN`, `INFO`, `DEBUG`, `TRACE`";
+ assert_de_tokens_error::<Level>(&[level_token("errorx")], msg);
+ }
+
+ #[test]
+ fn test_level_filter_ser_de() {
+ let cases = [
+ (LevelFilter::Off, [level_filter_token("OFF")]),
+ (LevelFilter::Error, [level_filter_token("ERROR")]),
+ (LevelFilter::Warn, [level_filter_token("WARN")]),
+ (LevelFilter::Info, [level_filter_token("INFO")]),
+ (LevelFilter::Debug, [level_filter_token("DEBUG")]),
+ (LevelFilter::Trace, [level_filter_token("TRACE")]),
+ ];
+
+ for &(s, expected) in &cases {
+ assert_tokens(&s, &expected);
+ }
+ }
+
+ #[test]
+ fn test_level_filter_case_insensitive() {
+ let cases = [
+ (LevelFilter::Off, [level_filter_token("off")]),
+ (LevelFilter::Error, [level_filter_token("error")]),
+ (LevelFilter::Warn, [level_filter_token("warn")]),
+ (LevelFilter::Info, [level_filter_token("info")]),
+ (LevelFilter::Debug, [level_filter_token("debug")]),
+ (LevelFilter::Trace, [level_filter_token("trace")]),
+ ];
+
+ for &(s, expected) in &cases {
+ assert_de_tokens(&s, &expected);
+ }
+ }
+
+ #[test]
+ fn test_level_filter_de_bytes() {
+ let cases = [
+ (LevelFilter::Off, level_filter_bytes_tokens(b"OFF")),
+ (LevelFilter::Error, level_filter_bytes_tokens(b"ERROR")),
+ (LevelFilter::Warn, level_filter_bytes_tokens(b"WARN")),
+ (LevelFilter::Info, level_filter_bytes_tokens(b"INFO")),
+ (LevelFilter::Debug, level_filter_bytes_tokens(b"DEBUG")),
+ (LevelFilter::Trace, level_filter_bytes_tokens(b"TRACE")),
+ ];
+
+ for &(value, tokens) in &cases {
+ assert_de_tokens(&value, &tokens);
+ }
+ }
+
+ #[test]
+ fn test_level_filter_de_error() {
+ let msg = "unknown variant `errorx`, expected one of \
+ `OFF`, `ERROR`, `WARN`, `INFO`, `DEBUG`, `TRACE`";
+ assert_de_tokens_error::<LevelFilter>(&[level_filter_token("errorx")], msg);
+ }
+}
