use crate::{Moment, Next, Span, Turn};
use super::HostConfig;
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum HostAction {
Continue,
Wait(Span),
Stop,
}
impl HostAction {
pub const fn for_turn(turn: Turn, now: Moment, config: HostConfig) -> Self {
Self::for_next(turn.next(), now, config)
}
pub const fn for_next(next: Next, now: Moment, config: HostConfig) -> Self {
match next {
Next::Now => Self::Continue,
Next::Wake => Self::from_wait(config.wait_ceiling()),
Next::WakeOr(deadline) => {
let wait = deadline.remaining_at(now).min(config.wait_ceiling());
Self::from_wait(wait)
}
Next::Stop => Self::Stop,
}
}
pub const fn wait_span(self) -> Option<Span> {
match self {
Self::Wait(wait) => Some(wait),
Self::Continue | Self::Stop => None,
}
}
const fn from_wait(wait: Span) -> Self {
if wait.as_nanos() == 0 {
Self::Continue
} else {
Self::Wait(wait)
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct HostStep {
started_at: Moment,
completed_at: Moment,
turn: Turn,
action: HostAction,
}
impl HostStep {
pub(super) const fn new(
started_at: Moment,
completed_at: Moment,
turn: Turn,
action: HostAction,
) -> Self {
Self {
started_at,
completed_at,
turn,
action,
}
}
pub const fn started_at(self) -> Moment {
self.started_at
}
pub const fn completed_at(self) -> Moment {
self.completed_at
}
pub const fn turn(self) -> Turn {
self.turn
}
pub const fn action(self) -> HostAction {
self.action
}
}