Struct FormattedEvent 

pub struct FormattedEvent {
    pub id: i32,
    pub start: String,
    pub end: String,
    pub duration: String,
}

Represents a formatted time-based event for display purposes.

Examples

use kasl::libs::formatter::FormattedEvent;

// Work interval representation
let interval = FormattedEvent {
    id: 1,
    start: "09:00".to_string(),
    end: "12:00".to_string(),
    duration: "03:00".to_string(),
};

// Pause representation
let pause = FormattedEvent {
    id: 2,
    start: "12:00".to_string(),
    end: "12:30".to_string(),
    duration: "00:30".to_string(),
};

Fields

id: i32

The sequential identifier of the event.

Used for ordering events chronologically and providing reference numbers in display tables. Typically starts from 1 and increments for each event in a sequence.

start: String

The formatted start time (e.g., “09:00”, “14:30”).

Represents when the event began, typically formatted as “HH:MM” in 24-hour format. For work intervals, this is when work started. For pauses, this is when the break began.

end: String

The formatted end time (e.g., “17:00”, “15:15”).

Represents when the event ended, typically formatted as “HH:MM” in 24-hour format. May be “-” or empty if the event is ongoing or has no defined end time.

duration: String

The formatted duration (e.g., “08:00”, “00:45”).

Represents the total length of the event, formatted as “HH:MM”. This is calculated from the difference between start and end times. May be “–:–” if the duration cannot be determined.

Trait Implementations

impl Clone for FormattedEvent

fn clone(&self) -> FormattedEvent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FormattedEvent

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for FormattedEvent

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for FormattedEvent

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.