Struct FileSize 

pub struct FileSize { /* private fields */ }

File Size wrapper for easier declaration Store bits size. Inner data stored as Bits value.

Implementations

impl FileSize

pub fn from_bytes(bytes: usize) -> Self

pub fn from_kilobytes(kilobytes: usize) -> Self

Examples found in repository

examples/demo.rs (line 18)

fn main() {
    let formatter = MessageFormatter::new(
        "::",
        "{timestamp:-6:30:right}{splitter}{modules:_:_:left}{splitter}{message}",
        "%Y-%m-%d %H:%M:%S.%f",
    );

    let output = OutputChannel::file(
        "./logs".into(),
        10,
        FileSize::from_kilobytes(1),
        "new_logger".into(),
        "log".into(),
    );

    let settings = Settings::new(true, 5, output, formatter);

    let logger = Logger::new(settings);
    let joiner = logger.run_async();

    let logger_logger_01 = logger.clone();
    let logger_logger_02 = logger.clone();
    let _ = thread::spawn(move || {
        logger_logger_01.log(&vec!["THREAD1".into(), "MAIN".into()], "Starting...");

        let mut counter = 0;
        loop {
            logger_logger_01.log(
                &vec!["THREAD1".into(), "WORKER".into()],
                format!("Processing Job: {counter}").as_str(),
            );
            counter += 1;
            sleep(Duration::from_secs(1));
        }
    });

    let _ = thread::spawn(move || {
        logger_logger_02.log(&vec!["THREAD2".into(), "MAIN".into()], "Starting...");

        let mut counter = 0;
        loop {
            logger_logger_02.log(
                &vec!["THREAD2".into(), "WORKER".into()],
                format!("Processing Job: {counter}").as_str(),
            );
            counter += 2;
            sleep(Duration::from_millis(400));
        }
    });

    let _ = thread::spawn(move || {
        log!("Starting...");

        let mut counter = 0;
        loop {
            log!(format!("Try Process Job: {counter}").as_str());

            // Log as text
            log!(
                ["THREAD3", "MODULE1"],
                format!("Try Process Job: {counter}").as_str()
            );
            let module_str = "RAW_MODULE";
            let thread3_str = "THREAD3";

            // Log from vars
            log!(
                [thread3_str, module_str],
                format!("Try Process Job: {counter}").as_str()
            );

            // Log as ident
            log!((RAW_MODULE, RAW_MODULE2, RAW_MODULE3), "some");
            counter += 2;
            sleep(Duration::from_millis(400));
        }
    });

    match joiner {
        Some(j) => {
            let _ = j.join();
        }
        None => {}
    };
}

pub fn from_megabytes(megabytes: usize) -> Self

pub fn from_gigabytes(gigabytes: usize) -> Self

Trait Implementations

impl Clone for FileSize

fn clone(&self) -> FileSize

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for FileSize

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

Formats the value using the given formatter.

impl Default for FileSize

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq<u64> for FileSize

fn eq(&self, other: &u64) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.