Remove AsMap and AsList type

These types are more related to serde and sval than they are to log.
Because of that is falls out of scope for the log crate.

Author: Thomasdezeeuw

src/kv/source.rs

@@ -402,319 +402,6 @@ mod std_support {
     }
 }
 
-/// The result of calling `Source::as_map`.
-pub struct AsMap<S>(S);
-
-/// Visit this source as a map.
-pub fn as_map<S>(source: S) -> AsMap<S>
-where
-    S: Source,
-{
-    AsMap(source)
-}
-
-impl<S> Source for AsMap<S>
-where
-    S: Source,
-{
-    fn visit<'kvs>(&'kvs self, visitor: &mut dyn Visitor<'kvs>) -> Result<(), Error> {
-        self.0.visit(visitor)
-    }
-
-    fn get(&self, key: Key) -> Option<Value<'_>> {
-        self.0.get(key)
-    }
-
-    fn count(&self) -> usize {
-        self.0.count()
-    }
-}
-
-impl<S> fmt::Debug for AsMap<S>
-where
-    S: Source,
-{
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let mut f = f.debug_map();
-        self.0.visit(&mut f).map_err(|_| fmt::Error)?;
-        f.finish()
-    }
-}
-
-/// The result of calling `Source::as_list`
-pub struct AsList<S>(S);
-
-/// Visit this source as a list.
-pub fn as_list<S>(source: S) -> AsList<S>
-where
-    S: Source,
-{
-    AsList(source)
-}
-
-impl<S> Source for AsList<S>
-where
-    S: Source,
-{
-    fn visit<'kvs>(&'kvs self, visitor: &mut dyn Visitor<'kvs>) -> Result<(), Error> {
-        self.0.visit(visitor)
-    }
-
-    fn get(&self, key: Key) -> Option<Value<'_>> {
-        self.0.get(key)
-    }
-
-    fn count(&self) -> usize {
-        self.0.count()
-    }
-}
-
-impl<S> fmt::Debug for AsList<S>
-where
-    S: Source,
-{
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let mut f = f.debug_list();
-        self.0.visit(&mut f).map_err(|_| fmt::Error)?;
-        f.finish()
-    }
-}
-
-#[cfg(feature = "kv_unstable_sval")]
-mod sval_support {
-    use super::*;
-
-    impl<S> sval::Value for AsMap<S>
-    where
-        S: Source,
-    {
-        fn stream<'sval, SV: sval::Stream<'sval> + ?Sized>(
-            &'sval self,
-            stream: &mut SV,
-        ) -> sval::Result {
-            struct StreamVisitor<'a, V: ?Sized>(&'a mut V);
-
-            impl<'a, 'kvs, V: sval::Stream<'kvs> + ?Sized> Visitor<'kvs> for StreamVisitor<'a, V> {
-                fn visit_pair(&mut self, key: Key<'kvs>, value: Value<'kvs>) -> Result<(), Error> {
-                    self.0
-                        .map_key_begin()
-                        .map_err(|_| Error::msg("failed to stream map key"))?;
-                    sval_ref::stream_ref(self.0, key)
-                        .map_err(|_| Error::msg("failed to stream map key"))?;
-                    self.0
-                        .map_key_end()
-                        .map_err(|_| Error::msg("failed to stream map key"))?;
-
-                    self.0
-                        .map_value_begin()
-                        .map_err(|_| Error::msg("failed to stream map value"))?;
-                    sval_ref::stream_ref(self.0, value)
-                        .map_err(|_| Error::msg("failed to stream map value"))?;
-                    self.0
-                        .map_value_end()
-                        .map_err(|_| Error::msg("failed to stream map value"))?;
-
-                    Ok(())
-                }
-            }
-
-            stream
-                .map_begin(Some(self.count()))
-                .map_err(|_| sval::Error::new())?;
-
-            self.visit(&mut StreamVisitor(stream))
-                .map_err(|_| sval::Error::new())?;
-
-            stream.map_end().map_err(|_| sval::Error::new())
-        }
-    }
-
-    impl<S> sval::Value for AsList<S>
-    where
-        S: Source,
-    {
-        fn stream<'sval, SV: sval::Stream<'sval> + ?Sized>(
-            &'sval self,
-            stream: &mut SV,
-        ) -> sval::Result {
-            struct StreamVisitor<'a, V: ?Sized>(&'a mut V);
-
-            impl<'a, 'kvs, V: sval::Stream<'kvs> + ?Sized> Visitor<'kvs> for StreamVisitor<'a, V> {
-                fn visit_pair(&mut self, key: Key<'kvs>, value: Value<'kvs>) -> Result<(), Error> {
-                    self.0
-                        .seq_value_begin()
-                        .map_err(|_| Error::msg("failed to stream seq value"))?;
-                    sval_ref::stream_ref(self.0, (key, value))
-                        .map_err(|_| Error::msg("failed to stream seq value"))?;
-                    self.0
-                        .seq_value_end()
-                        .map_err(|_| Error::msg("failed to stream seq value"))?;
-
-                    Ok(())
-                }
-            }
-
-            stream
-                .seq_begin(Some(self.count()))
-                .map_err(|_| sval::Error::new())?;
-
-            self.visit(&mut StreamVisitor(stream))
-                .map_err(|_| sval::Error::new())?;
-
-            stream.seq_end().map_err(|_| sval::Error::new())
-        }
-    }
-
-    #[cfg(test)]
-    mod tests {
-        use super::*;
-        use sval_derive::Value;
-
-        #[test]
-        fn derive_stream() {
-            #[derive(Value)]
-            pub struct MyRecordAsMap<'a> {
-                msg: &'a str,
-                kvs: AsMap<&'a dyn Source>,
-            }
-
-            #[derive(Value)]
-            pub struct MyRecordAsList<'a> {
-                msg: &'a str,
-                kvs: AsList<&'a dyn Source>,
-            }
-        }
-    }
-}
-
-#[cfg(feature = "kv_unstable_serde")]
-pub mod as_map {
-    //! `serde` adapters for serializing a `Source` as a map.
-
-    use super::*;
-    use serde::{Serialize, Serializer};
-
-    /// Serialize a `Source` as a map.
-    pub fn serialize<T, S>(source: &T, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        T: Source,
-        S: Serializer,
-    {
-        as_map(source).serialize(serializer)
-    }
-}
-
-#[cfg(feature = "kv_unstable_serde")]
-pub mod as_list {
-    //! `serde` adapters for serializing a `Source` as a list.
-
-    use super::*;
-    use serde::{Serialize, Serializer};
-
-    /// Serialize a `Source` as a list.
-    pub fn serialize<T, S>(source: &T, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        T: Source,
-        S: Serializer,
-    {
-        as_list(source).serialize(serializer)
-    }
-}
-
-#[cfg(feature = "kv_unstable_serde")]
-mod serde_support {
-    use super::*;
-    use serde::ser::{Error as SerError, Serialize, SerializeMap, SerializeSeq, Serializer};
-
-    impl<T> Serialize for AsMap<T>
-    where
-        T: Source,
-    {
-        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-        where
-            S: Serializer,
-        {
-            struct SerializerVisitor<'a, S>(&'a mut S);
-
-            impl<'a, 'kvs, S> Visitor<'kvs> for SerializerVisitor<'a, S>
-            where
-                S: SerializeMap,
-            {
-                fn visit_pair(&mut self, key: Key<'kvs>, value: Value<'kvs>) -> Result<(), Error> {
-                    self.0
-                        .serialize_entry(&key, &value)
-                        .map_err(|_| Error::msg("failed to serialize map entry"))?;
-                    Ok(())
-                }
-            }
-
-            let mut map = serializer.serialize_map(Some(self.count()))?;
-
-            self.visit(&mut SerializerVisitor(&mut map))
-                .map_err(|_| S::Error::custom("failed to visit key-values"))?;
-
-            map.end()
-        }
-    }
-
-    impl<T> Serialize for AsList<T>
-    where
-        T: Source,
-    {
-        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-        where
-            S: Serializer,
-        {
-            struct SerializerVisitor<'a, S>(&'a mut S);
-
-            impl<'a, 'kvs, S> Visitor<'kvs> for SerializerVisitor<'a, S>
-            where
-                S: SerializeSeq,
-            {
-                fn visit_pair(&mut self, key: Key<'kvs>, value: Value<'kvs>) -> Result<(), Error> {
-                    self.0
-                        .serialize_element(&(key, value))
-                        .map_err(|_| Error::msg("failed to serialize seq entry"))?;
-                    Ok(())
-                }
-            }
-
-            let mut seq = serializer.serialize_seq(Some(self.count()))?;
-
-            self.visit(&mut SerializerVisitor(&mut seq))
-                .map_err(|_| S::Error::custom("failed to visit seq"))?;
-
-            seq.end()
-        }
-    }
-
-    #[cfg(test)]
-    mod tests {
-        use super::*;
-        use crate::kv::source;
-        use serde::Serialize;
-
-        #[test]
-        fn derive_serialize() {
-            #[derive(Serialize)]
-            pub struct MyRecordAsMap<'a> {
-                msg: &'a str,
-                #[serde(flatten)]
-                #[serde(with = "source::as_map")]
-                kvs: &'a dyn Source,
-            }
-
-            #[derive(Serialize)]
-            pub struct MyRecordAsList<'a> {
-                msg: &'a str,
-                #[serde(flatten)]
-                #[serde(with = "source::as_list")]
-                kvs: &'a dyn Source,
-            }
-        }
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use crate::kv::value::tests::Token;
@@ -766,16 +453,4 @@ mod tests {
         let source = None::<(&str, i32)>;
         assert!(Source::get(&source, Key::from_str("a")).is_none());
     }
-
-    #[test]
-    fn as_map() {
-        let _ = crate::kv::source::as_map(("a", 1));
-        let _ = crate::kv::source::as_map(&("a", 1) as &dyn Source);
-    }
-
-    #[test]
-    fn as_list() {
-        let _ = crate::kv::source::as_list(("a", 1));
-        let _ = crate::kv::source::as_list(&("a", 1) as &dyn Source);
-    }
 }