Struct `RecordBuilder`

pub struct RecordBuilder<'a> { /* private fields */ }

Builder for Record.

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

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:

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();

Implementations

`impl<'a> RecordBuilder<'a>`

fn new() -> RecordBuilder<'a>

Construct new RecordBuilder.

The default options are:

args: format_args!("")
metadata: Metadata::builder().build()
module_path: None
file: None
line: None

fn args(&mut self, args: Arguments<'a>) -> &mut RecordBuilder<'a>

Set args.

fn metadata(&mut self, metadata: Metadata<'a>) -> &mut RecordBuilder<'a>

Set metadata. Construct a Metadata object with MetadataBuilder.

fn level(&mut self, level: Level) -> &mut RecordBuilder<'a>

Set Metadata::level.

fn target(&mut self, target: &'a str) -> &mut RecordBuilder<'a>

Set Metadata::target

fn module_path(&mut self, path: Option<&'a str>) -> &mut RecordBuilder<'a>

Set module_path

fn module_path_static(&mut self, path: Option<&'static str>) -> &mut RecordBuilder<'a>

Set module_path to a 'static string

fn file(&mut self, file: Option<&'a str>) -> &mut RecordBuilder<'a>

Set file

fn file_static(&mut self, file: Option<&'static str>) -> &mut RecordBuilder<'a>

Set file to a 'static string.

fn line(&mut self, line: Option<u32>) -> &mut RecordBuilder<'a>

Set line

fn build(&self) -> Record<'a>

Invoke the builder and return a Record

Trait Implementations

`impl Default for RecordBuilder<'_>`

fn default() -> Self

`impl<'a> Debug for RecordBuilder<'a>`

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Auto Trait Implementations

`impl<'a> !Send for RecordBuilder<'a>`

`impl<'a> !Sync for RecordBuilder<'a>`

`impl<'a> Freeze for RecordBuilder<'a>`

`impl<'a> RefUnwindSafe for RecordBuilder<'a>`

`impl<'a> Unpin for RecordBuilder<'a>`

`impl<'a> UnsafeUnpin for RecordBuilder<'a>`

`impl<'a> UnwindSafe for RecordBuilder<'a>`

Blanket Implementations

`impl<T> Any for RecordBuilder<'a> where T: 'static + ?Sized,`

fn type_id(&self) -> TypeId

`impl<T> Borrow<T> for RecordBuilder<'a> where T: ?Sized,`

fn borrow(&self) -> &T

`impl<T> BorrowMut<T> for RecordBuilder<'a> where T: ?Sized,`

fn borrow_mut(&mut self) -> &mut T

`impl<T> From<T> for RecordBuilder<'a>`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T, U> Into for RecordBuilder<'a> where U: From<T>,`

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom for RecordBuilder<'a> where U: Into<T>,`

type Error = never;
fn try_from(value: U) -> Result<T, never>

`impl<T, U> TryInto for RecordBuilder<'a> where U: TryFrom<T>,`

type Error = >::Error;
fn try_into(self) -> Result<U, >::Error>