Struct DateTime

pub struct DateTime {
    pub date: Date,
    pub time: Time,
}

Represents a combination of date and time.

Fields

date: Date

time: Time

Implementations

impl DateTime

pub fn now() -> Self

Returns a DateTime instance representing the current date and time.

Examples

use dev_utils::datetime::DateTime;

let now = DateTime::now();
println!("Current date and time: {}", now);

Examples found in repository

examples/dlog.rs (line 130)

fn showcase_log_formatting() {
    println!(
        "\n{}",
        "Enhanced Log Formatting Features:"
            .style(Style::Bold)
            .style(Style::Italic)
    );

    info!("Standard log message");

    // Multi-line log for a simulated data structure
    let user_data = vec![
        ("UserID", "12345"),
        ("Username", "johndoe"),
        ("Email", "johndoe@example.com"),
        ("Role", "Admin"),
    ];

    debug!(
        "Logging multi-line structured data:\n{}",
        user_data
            .iter()
            .map(|(key, value)| format!("\t{}: {}", key, value))
            .collect::<Vec<_>>()
            .join("\n")
    );

    // Log a long message split across multiple lines
    info!(
        "This is a long log message that spans multiple lines for better readability. \
        It demonstrates how long strings or messages can be split into readable chunks \
        without breaking the content flow."
    );

    // Log with colored and styled text
    let formatted_text = "Formatted".style(Style::Bold).color(GREEN);
    info!(
        "Logs can include {} and {} text",
        formatted_text,
        "styled".style(Style::Italic).color(MAGENTA)
    );

    // Log the current timestamp
    let now = DateTime::now();
    info!("Current timestamp: {}", now);

    // todo: Add full compatibility with thie multiline log
    let err_dt = vec![
        ("Code", "404"),
        ("Message", "Resource not found"),
        ("File", file!()),
    ];
    // iter over all the data on err_dt and apply the dim style to all the values
    let err_dt = err_dt
        .iter()
        .map(|(key, value)| (key, value.style(Style::Dim)))
        .collect::<Vec<_>>();

    // Multi-line error simulation
    error!(
        "Error on line: {}\n{}",
        line!(),
        err_dt
            .iter()
            .map(|(key, value)| format!("\t{}: {}", key, value))
            .collect::<Vec<_>>()
            .join("\n")
    );

    // todo: FIX THE ERRORS OCURRED WHEN HANDLING THE MULTILINE LOG...
    // todo: IT ALSO HAVE SOME ERROR IN WHICH THE STYLE IS APPLIED TO THE WHOLE STRING...
    // ^ In this case, the "Some new data:" is being styled as a whole string,
    // ^ not just the "Code: 200" and "Message: You got some successulf penchs"...
    // same as above but using the str in plain text
    info!(
        "Some new data:\n{}{}{}", // Added {} for the file part
        format!("\tCode: {}\n", "200".style(Style::Underline)), // Style only "200"
        format!("\tMessage: {}\n\t", "You got some successulf penchs".style(Style::Underline)), // Style only the message
        file!().style(Style::Bold)
    );
}

// = Time to log 10000 messages: 352.6482ms
// = Average time per log: 35.264µs
fn showcase_log_performance() {
    println!(
        "\n{}",
        "Log Performance:".style(Style::Bold).style(Style::Italic)
    );

    let iterations = 10000;
    let start = std::time::Instant::now();

    (0..iterations).for_each(|i| trace!("Performance test log {}", i));

    let duration = start.elapsed();
    println!("Time to log {} messages: {:?}", iterations, duration);
    println!("Average time per log: {:?}", duration / iterations as u32);
}

fn showcase_log_use_cases() {
    println!(
        "\n{}",
        "Practical Use Cases:"
            .style(Style::Bold)
            .style(Style::Italic)
    );

    // Simulating an application startup
    info!("Application starting up...");
    debug!("Initializing modules...");
    __delay_ms(500);
    info!("Database connection established");
    __delay_ms(300);
    // warn!("Config file not found, using default settings");
    __delay_ms(200);
    error!("Failed to load user preferences");
    info!("Application startup complete");

    // Simulating a function call
    debug!("Entering function process_data()");
    __delay_ms(100);
    trace!("Processing item 1 of 3");
    __delay_ms(50);
    trace!("Processing item 2 of 3");
    __delay_ms(50);
    trace!("Processing item 3 of 3");
    __delay_ms(100);
    debug!("Exiting function process_data()");

    info!("Data processing completed successfully");

    // same as above but now use a tuple to store the macro type, message, and delay, then iterate over it

    // logs.iter().for_each(|(log, msg, delay)| {
    //     log!("{}", msg);
    //     __delay_ms(*delay);
    // });
}

fn showcase_datetime_features() {
    println!(
        "\n{}",
        "DateTime Features:".style(Style::Bold).style(Style::Italic)
    );

    // Creating a DateTime instance
    let now = DateTime::now();
    info!("Current date and time: {}", now);

    // Creating a custom DateTime
    let custom_date = Date::new(2023, 12, 31).unwrap();
    let custom_time = Time::new(23, 59, 59).unwrap();
    let custom_datetime = DateTime {
        date: custom_date,
        time: custom_time,
    };
    info!("Custom DateTime: {}", custom_datetime);

    // Parsing a DateTime from a string
    let parsed_datetime: DateTime = "2023-05-01 12:34:56".parse().unwrap();
    info!("Parsed DateTime: {}", parsed_datetime);

    // DateTime from timestamp
    let from_timestamp = DateTime::from_timestamp(1682899200).unwrap();
    info!("DateTime from timestamp: {}", from_timestamp);

    // Demonstrating error handling
    match Date::new(2023, 2, 29) {
        // 29th Feb 2023 (not a leap year)
        Ok(date) => info!("Valid date: {:?}", date),
        Err(e) => println!("Invalid date: {}", e),
        // Err(e) => warn!("Invalid date: {}", e),
    }

    // Comparing DateTimes
    info!(
        "Comparing DateTimes: {} is earlier than {}",
        "2023-05-01 12:00:00".parse::<DateTime>().unwrap(),
        "2023-05-01 13:00:00".parse::<DateTime>().unwrap(),
    );

    // Demonstrating leap year
    let leap_year = 2024;
    info!(
        "Is {} a leap year? {}",
        leap_year,
        Date::is_leap_year(leap_year)
    );
}

pub fn from_timestamp(timestamp: i64) -> Result<Self, DateTimeError>

Creates a DateTime instance from a Unix timestamp.

Arguments

• timestamp - The Unix timestamp (seconds since 1970-01-01 00:00:00 UTC)

Returns

A Result containing either the valid DateTime or a DateTimeError.

Examples

use dev_utils::datetime::DateTime;

let dt = DateTime::from_timestamp(1682899200).unwrap();
assert_eq!(dt.to_string(), "2023-05-02 00:00:00");

Examples found in repository

examples/dlog.rs (line 251)

fn showcase_datetime_features() {
    println!(
        "\n{}",
        "DateTime Features:".style(Style::Bold).style(Style::Italic)
    );

    // Creating a DateTime instance
    let now = DateTime::now();
    info!("Current date and time: {}", now);

    // Creating a custom DateTime
    let custom_date = Date::new(2023, 12, 31).unwrap();
    let custom_time = Time::new(23, 59, 59).unwrap();
    let custom_datetime = DateTime {
        date: custom_date,
        time: custom_time,
    };
    info!("Custom DateTime: {}", custom_datetime);

    // Parsing a DateTime from a string
    let parsed_datetime: DateTime = "2023-05-01 12:34:56".parse().unwrap();
    info!("Parsed DateTime: {}", parsed_datetime);

    // DateTime from timestamp
    let from_timestamp = DateTime::from_timestamp(1682899200).unwrap();
    info!("DateTime from timestamp: {}", from_timestamp);

    // Demonstrating error handling
    match Date::new(2023, 2, 29) {
        // 29th Feb 2023 (not a leap year)
        Ok(date) => info!("Valid date: {:?}", date),
        Err(e) => println!("Invalid date: {}", e),
        // Err(e) => warn!("Invalid date: {}", e),
    }

    // Comparing DateTimes
    info!(
        "Comparing DateTimes: {} is earlier than {}",
        "2023-05-01 12:00:00".parse::<DateTime>().unwrap(),
        "2023-05-01 13:00:00".parse::<DateTime>().unwrap(),
    );

    // Demonstrating leap year
    let leap_year = 2024;
    info!(
        "Is {} a leap year? {}",
        leap_year,
        Date::is_leap_year(leap_year)
    );
}

Trait Implementations

impl Clone for DateTime

fn clone(&self) -> DateTime

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for DateTime

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

Formats the value using the given formatter.

impl Display for DateTime

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

Formats the value using the given formatter.

impl FromStr for DateTime

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string into a DateTime instance.

The expected format is “YYYY-MM-DD HH:MM:SS”.

Arguments

• s - The string to parse

Returns

A Result containing either the parsed DateTime or a DateTimeError.

Examples

use dev_utils::datetime::DateTime;
use std::str::FromStr;

let dt = DateTime::from_str("2023-05-01 12:34:56").unwrap();
assert_eq!(dt.to_string(), "2023-05-01 12:34:56");

type Err = DateTimeError

The associated error which can be returned from parsing.

impl Ord for DateTime

fn cmp(&self, other: &DateTime) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for DateTime

fn eq(&self, other: &DateTime) -> 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.

impl PartialOrd for DateTime

fn partial_cmp(&self, other: &DateTime) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Copy for DateTime

impl Eq for DateTime

impl StructuralPartialEq for DateTime