use crate::message::MessageKind;
use crate::types::common::{ControlType, EnergyManagementRole};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Allowance {
Yes,
WrongState,
WrongRole,
}
impl Allowance {
#[must_use]
pub const fn is_allowed(self) -> bool {
matches!(self, Allowance::Yes)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum Phase {
Negotiating,
#[default]
Connected,
Activated(ControlType),
}
impl Phase {
#[must_use]
pub fn selected(control_type: ControlType) -> Self {
if control_type.is_controllable() {
Phase::Activated(control_type)
} else {
Phase::Connected
}
}
#[must_use]
pub const fn active_control_type(self) -> Option<ControlType> {
match self {
Phase::Activated(c) => Some(c),
Phase::Negotiating | Phase::Connected => None,
}
}
#[must_use]
pub fn label(self) -> &'static str {
match self {
Phase::Negotiating => "negotiating",
Phase::Connected => "WebSocketConnected",
Phase::Activated(c) => c.abbreviation().unwrap_or("WebSocketConnected"),
}
}
}
#[must_use]
pub fn allowed(phase: Phase, sender: EnergyManagementRole, kind: MessageKind) -> Allowance {
use MessageKind as K;
if let Some(expected) = kind.sender()
&& expected != sender
{
return Allowance::WrongRole;
}
let active = phase.active_control_type();
#[allow(clippy::match_same_arms)]
match kind {
K::ReceptionStatus | K::SessionRequest => Allowance::Yes,
K::Handshake | K::HandshakeResponse => match phase {
Phase::Negotiating | Phase::Connected => Allowance::Yes,
Phase::Activated(_) => Allowance::WrongState,
},
_ if phase == Phase::Negotiating => Allowance::WrongState,
K::ResourceManagerDetails
| K::PowerMeasurement
| K::PowerForecast
| K::SelectControlType => Allowance::Yes,
K::InstructionStatusUpdate | K::RevokeObject => {
if active.is_some() {
Allowance::Yes
} else {
Allowance::WrongState
}
}
_ => match (kind.control_type(), active) {
(Some(needed), Some(current)) if needed == current => Allowance::Yes,
_ => Allowance::WrongState,
},
}
}
#[must_use]
pub fn allowed_kinds(phase: Phase, sender: EnergyManagementRole) -> alloc::vec::Vec<MessageKind> {
MessageKind::ALL
.iter()
.copied()
.filter(|k| allowed(phase, sender, *k).is_allowed())
.collect()
}
#[cfg(test)]
mod tests {
use super::*;
use EnergyManagementRole::{Cem, Rm};
use alloc::vec::Vec;
fn names(phase: Phase, sender: EnergyManagementRole) -> Vec<&'static str> {
let mut v: Vec<_> = allowed_kinds(phase, sender)
.into_iter()
.map(crate::message::MessageKind::as_str)
.collect();
v.sort_unstable();
v
}
#[test]
fn the_websocket_connected_row_is_the_standards_own() {
assert_eq!(
names(Phase::Connected, Cem),
alloc::vec![
"Handshake",
"HandshakeResponse",
"ReceptionStatus",
"SelectControlType",
"SessionRequest",
]
);
assert_eq!(
names(Phase::Connected, Rm),
alloc::vec![
"Handshake",
"PowerForecast",
"PowerMeasurement",
"ReceptionStatus",
"ResourceManagerDetails",
"SessionRequest",
]
);
}
#[test]
fn nothing_but_the_handshake_crosses_while_the_version_is_still_being_agreed() {
assert_eq!(
names(Phase::Negotiating, Rm),
alloc::vec!["Handshake", "ReceptionStatus", "SessionRequest"]
);
assert_eq!(
names(Phase::Negotiating, Cem),
alloc::vec![
"Handshake",
"HandshakeResponse",
"ReceptionStatus",
"SessionRequest",
]
);
assert_eq!(
allowed(Phase::Negotiating, Rm, MessageKind::PowerMeasurement),
Allowance::WrongState
);
assert_eq!(
allowed(Phase::Negotiating, Rm, MessageKind::ResourceManagerDetails),
Allowance::WrongState
);
assert_eq!(
allowed(Phase::Negotiating, Cem, MessageKind::SelectControlType),
Allowance::WrongState
);
}
#[test]
fn the_handshake_is_over_once_a_control_type_is_active() {
assert_eq!(
allowed(
Phase::Activated(ControlType::FillRateBasedControl),
Rm,
MessageKind::Handshake
),
Allowance::WrongState
);
}
#[test]
fn the_frbc_row_is_the_standards_own() {
let frbc = Phase::Activated(ControlType::FillRateBasedControl);
assert_eq!(
names(frbc, Cem),
alloc::vec![
"FRBC.Instruction",
"ReceptionStatus",
"RevokeObject",
"SelectControlType",
"SessionRequest",
]
);
assert_eq!(
names(frbc, Rm),
alloc::vec![
"FRBC.ActuatorStatus",
"FRBC.FillLevelTargetProfile",
"FRBC.LeakageBehaviour",
"FRBC.StorageStatus",
"FRBC.SystemDescription",
"FRBC.TimerStatus",
"FRBC.UsageForecast",
"InstructionStatusUpdate",
"PowerForecast",
"PowerMeasurement",
"ReceptionStatus",
"ResourceManagerDetails",
"RevokeObject",
"SessionRequest",
]
);
}
#[test]
fn the_pebc_row_is_the_standards_own() {
let pebc = Phase::Activated(ControlType::PowerEnvelopeBasedControl);
assert_eq!(
names(pebc, Cem),
alloc::vec![
"PEBC.Instruction",
"ReceptionStatus",
"RevokeObject",
"SelectControlType",
"SessionRequest",
]
);
assert_eq!(
names(pebc, Rm),
alloc::vec![
"InstructionStatusUpdate",
"PEBC.EnergyConstraint",
"PEBC.PowerConstraints",
"PowerForecast",
"PowerMeasurement",
"ReceptionStatus",
"ResourceManagerDetails",
"RevokeObject",
"SessionRequest",
]
);
}
#[test]
fn selecting_not_controlable_leaves_the_session_where_it_was() {
assert_eq!(
Phase::selected(ControlType::NotControllable),
Phase::Connected
);
assert_eq!(Phase::selected(ControlType::NoSelection), Phase::Connected);
assert_eq!(
Phase::selected(ControlType::FillRateBasedControl),
Phase::Activated(ControlType::FillRateBasedControl)
);
}
#[test]
fn a_control_type_message_in_the_wrong_control_type_is_a_state_error() {
assert_eq!(
allowed(
Phase::Activated(ControlType::PowerEnvelopeBasedControl),
Cem,
MessageKind::FrbcInstruction
),
Allowance::WrongState
);
assert_eq!(
allowed(Phase::Connected, Cem, MessageKind::FrbcInstruction),
Allowance::WrongState
);
}
#[test]
fn a_message_from_the_wrong_role_is_a_role_error() {
assert_eq!(
allowed(
Phase::Activated(ControlType::FillRateBasedControl),
Rm,
MessageKind::FrbcInstruction
),
Allowance::WrongRole
);
assert_eq!(
allowed(Phase::Connected, Cem, MessageKind::ResourceManagerDetails),
Allowance::WrongRole
);
assert_eq!(
allowed(Phase::Connected, Rm, MessageKind::SelectControlType),
Allowance::WrongRole
);
assert_eq!(
allowed(Phase::Negotiating, Cem, MessageKind::ResourceManagerDetails),
Allowance::WrongRole
);
}
#[test]
fn revocation_is_accepted_from_both_roles() {
for role in [Cem, Rm] {
assert_eq!(
allowed(
Phase::Activated(ControlType::FillRateBasedControl),
role,
MessageKind::RevokeObject
),
Allowance::Yes
);
}
}
#[test]
fn instruction_statuses_need_something_to_be_about() {
assert_eq!(
allowed(Phase::Connected, Rm, MessageKind::InstructionStatusUpdate),
Allowance::WrongState
);
assert_eq!(
allowed(
Phase::Activated(ControlType::OperationModeBasedControl),
Rm,
MessageKind::InstructionStatusUpdate
),
Allowance::Yes
);
}
#[test]
fn every_message_is_allowed_somewhere() {
for kind in MessageKind::ALL {
let reachable = [
Phase::Negotiating,
Phase::Connected,
Phase::Activated(ControlType::PowerEnvelopeBasedControl),
Phase::Activated(ControlType::PowerProfileBasedControl),
Phase::Activated(ControlType::OperationModeBasedControl),
Phase::Activated(ControlType::FillRateBasedControl),
Phase::Activated(ControlType::DemandDrivenBasedControl),
]
.into_iter()
.any(|phase| {
[Cem, Rm]
.into_iter()
.any(|role| allowed(phase, role, *kind).is_allowed())
});
assert!(reachable, "{kind} can never be sent");
}
}
}