Struct log::RecordBuilder

source ·
pub struct RecordBuilder<'a> {
    pub(crate) record: Record<'a>,
}
Expand description

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

Fields§

§record: Record<'a>

Implementations§

source§

impl<'a> RecordBuilder<'a>

source

pub fn new() -> RecordBuilder<'a>

Construct new RecordBuilder.

The default options are:

source

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

Set args.

source

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

Set metadata. Construct a Metadata object with MetadataBuilder.

source

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

source

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

source

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

source

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

Set module_path to a 'static string

source

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

Set file

source

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

Set file to a 'static string.

source

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

Set line

source

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

Invoke the builder and return a Record

Trait Implementations§

source§

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

source§

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

Formats the value using the given formatter. Read more
source§

impl<'a> Default for RecordBuilder<'a>

source§

fn default() -> Self

Returns the “default value” for a type. Read more

Auto Trait Implementations§

§

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

§

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

§

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

§

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

§

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

§

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

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

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

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

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

source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.