Trait slog::ser::Serialize

pub trait Serialize {
    fn serialize(
        &self, 
        record: &Record, 
        key: &'static str, 
        serializer: &mut Serializer
    ) -> Result<(), Error>;
}

Value that can be serialized

Loggers require values in key-value pairs to implement this trait.

Required Methods

fn serialize(
    &self,
    record: &Record,
    key: &'static str,
    serializer: &mut Serializer
) -> Result<(), Error>

Serialize self into Serializer

Structs implementing this trait should generally only call respective methods of serializer.

Implementations on Foreign Types

impl Serialize for usize

fn serialize(
    &self,
    _record: &Record,
    key: &'static str,
    serializer: &mut Serializer
) -> Result<(), Error>

impl Serialize for isize

fn serialize(
    &self,
    _record: &Record,
    key: &'static str,
    serializer: &mut Serializer
) -> Result<(), Error>

impl Serialize for bool

fn serialize(
    &self,
    _record: &Record,
    key: &'static str,
    serializer: &mut Serializer
) -> Result<(), Error>

impl Serialize for char

fn serialize(
    &self,
    _record: &Record,
    key: &'static str,
    serializer: &mut Serializer
) -> Result<(), Error>

impl Serialize for u8

fn serialize(
    &self,
    _record: &Record,
    key: &'static str,
    serializer: &mut Serializer
) -> Result<(), Error>

impl Serialize for i8

fn serialize(
    &self,
    _record: &Record,
    key: &'static str,
    serializer: &mut Serializer
) -> Result<(), Error>

impl Serialize for u16

fn serialize(
    &self,
    _record: &Record,
    key: &'static str,
    serializer: &mut Serializer
) -> Result<(), Error>

impl Serialize for i16

fn serialize(
    &self,
    _record: &Record,
    key: &'static str,
    serializer: &mut Serializer
) -> Result<(), Error>

impl Serialize for u32

fn serialize(
    &self,
    _record: &Record,
    key: &'static str,
    serializer: &mut Serializer
) -> Result<(), Error>

impl Serialize for i32

fn serialize(
    &self,
    _record: &Record,
    key: &'static str,
    serializer: &mut Serializer
) -> Result<(), Error>

impl Serialize for f32

fn serialize(
    &self,
    _record: &Record,
    key: &'static str,
    serializer: &mut Serializer
) -> Result<(), Error>

impl Serialize for u64

fn serialize(
    &self,
    _record: &Record,
    key: &'static str,
    serializer: &mut Serializer
) -> Result<(), Error>

impl Serialize for i64

fn serialize(
    &self,
    _record: &Record,
    key: &'static str,
    serializer: &mut Serializer
) -> Result<(), Error>

impl Serialize for f64

fn serialize(
    &self,
    _record: &Record,
    key: &'static str,
    serializer: &mut Serializer
) -> Result<(), Error>

impl Serialize for ()

fn serialize(
    &self,
    _record: &Record,
    key: &'static str,
    serializer: &mut Serializer
) -> Result<(), Error>

impl Serialize for str

fn serialize(
    &self,
    _record: &Record,
    key: &'static str,
    serializer: &mut Serializer
) -> Result<(), Error>

impl<'a> Serialize for &'a str

fn serialize(
    &self,
    _record: &Record,
    key: &'static str,
    serializer: &mut Serializer
) -> Result<(), Error>

impl<'a> Serialize for Arguments<'a>

fn serialize(
    &self,
    _record: &Record,
    key: &'static str,
    serializer: &mut Serializer
) -> Result<(), Error>

impl Serialize for String

fn serialize(
    &self,
    _record: &Record,
    key: &'static str,
    serializer: &mut Serializer
) -> Result<(), Error>

impl<T: Serialize> Serialize for Option<T>

fn serialize(
    &self,
    record: &Record,
    key: &'static str,
    serializer: &mut Serializer
) -> Result<(), Error>

impl Serialize for Box<Serialize + Send + 'static>

fn serialize(
    &self,
    record: &Record,
    key: &'static str,
    serializer: &mut Serializer
) -> Result<(), Error>

impl<T> Serialize for Arc<T> where
    T: Serialize, 

fn serialize(
    &self,
    record: &Record,
    key: &'static str,
    serializer: &mut Serializer
) -> Result<(), Error>

impl<T> Serialize for Rc<T> where
    T: Serialize, 

fn serialize(
    &self,
    record: &Record,
    key: &'static str,
    serializer: &mut Serializer
) -> Result<(), Error>

impl<T> Serialize for Wrapping<T> where
    T: Serialize, 

fn serialize(
    &self,
    record: &Record,
    key: &'static str,
    serializer: &mut Serializer
) -> Result<(), Error>

Implementors

• impl<S: 'static + Serialize, F> Serialize for F where
    F: 'static + for<'c, 'd> Fn(&'c Record<'d>) -> S, 
• impl<F> Serialize for PushLazy<F> where
    F: 'static + for<'c, 'd> Fn(&'c Record<'d>, ValueSerializer<'c>) -> Result<(), Error>,