use core::fmt;
use core::str::FromStr;
use oxicode::{Decode, Encode};
use serde::{Deserialize, Serialize};
use crate::error::{IdError, IdKind};
use crate::frame::FrameKind;
#[derive(
Debug,
Clone,
Copy,
Default,
PartialEq,
Eq,
PartialOrd,
Ord,
Hash,
Serialize,
Deserialize,
Encode,
Decode,
)]
#[serde(rename_all = "snake_case")]
#[non_exhaustive]
pub enum Role {
#[default]
#[oxicode(variant = 0)]
Cli,
#[oxicode(variant = 1)]
Daemon,
#[oxicode(variant = 2)]
Node,
#[oxicode(variant = 3)]
Peer,
}
impl Role {
pub const ALL: &'static [Self] = &[Self::Cli, Self::Daemon, Self::Node, Self::Peer];
#[must_use]
pub const fn as_str(self) -> &'static str {
match self {
Self::Cli => "cli",
Self::Daemon => "daemon",
Self::Node => "node",
Self::Peer => "peer",
}
}
#[must_use]
pub const fn request_kind(self) -> FrameKind {
match self {
Self::Cli => FrameKind::Control,
Self::Daemon => FrameKind::DaemonEvent,
Self::Node => FrameKind::NodeRequest,
Self::Peer => FrameKind::PeerEvent,
}
}
#[must_use]
pub const fn event_kind(self) -> FrameKind {
match self {
Self::Cli => FrameKind::ControlReply,
Self::Daemon => FrameKind::CoordinatorEvent,
Self::Node => FrameKind::NodeEvent,
Self::Peer => FrameKind::PeerEvent,
}
}
#[must_use]
pub const fn targets_coordinator(self) -> bool {
matches!(self, Self::Cli | Self::Daemon)
}
#[must_use]
pub const fn carries_payload(self) -> bool {
matches!(self, Self::Node | Self::Peer)
}
}
impl fmt::Display for Role {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(self.as_str())
}
}
impl FromStr for Role {
type Err = IdError;
fn from_str(text: &str) -> Result<Self, Self::Err> {
match text {
"cli" => Ok(Self::Cli),
"daemon" => Ok(Self::Daemon),
"node" => Ok(Self::Node),
"peer" => Ok(Self::Peer),
other => Err(IdError::Malformed {
kind: IdKind::Name,
value: crate::error::preview(other),
reason: "expected one of cli, daemon, node, peer",
}),
}
}
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct RoleSet(u8);
impl RoleSet {
pub const EMPTY: Self = Self(0);
pub const ALL: Self = Self(0b1111);
pub const COORDINATOR: Self = Self::EMPTY.with(Role::Cli).with(Role::Daemon);
pub const NODES: Self = Self::EMPTY.with(Role::Node);
pub const PEERS: Self = Self::EMPTY.with(Role::Peer);
#[must_use]
pub const fn only(role: Role) -> Self {
Self::EMPTY.with(role)
}
#[must_use]
pub const fn with(self, role: Role) -> Self {
Self(self.0 | (1 << role as u8))
}
#[must_use]
pub const fn without(self, role: Role) -> Self {
Self(self.0 & !(1 << role as u8))
}
#[must_use]
pub const fn contains(self, role: Role) -> bool {
self.0 & (1 << role as u8) != 0
}
#[must_use]
pub const fn is_empty(self) -> bool {
self.0 == 0
}
#[must_use]
pub const fn len(self) -> u32 {
self.0.count_ones()
}
#[must_use]
pub fn roles(self) -> Vec<Role> {
Role::ALL
.iter()
.copied()
.filter(|role| self.contains(*role))
.collect()
}
}
impl fmt::Display for RoleSet {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
if self.is_empty() {
return f.write_str("none");
}
let mut first = true;
for role in self.roles() {
if !first {
f.write_str("|")?;
}
f.write_str(role.as_str())?;
first = false;
}
Ok(())
}
}
impl FromIterator<Role> for RoleSet {
fn from_iter<I: IntoIterator<Item = Role>>(roles: I) -> Self {
roles.into_iter().fold(Self::EMPTY, Self::with)
}
}
#[cfg(test)]
mod tests {
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
use super::*;
use crate::codec::{WireDecode, WireEncode};
#[test]
fn indices_are_frozen() {
for (index, role) in Role::ALL.iter().enumerate() {
let bytes = role.encode_to_vec().unwrap();
assert_eq!(usize::from(bytes[0]), index, "{role} moved");
assert_eq!(Role::decode_exact(&bytes).unwrap(), *role);
}
assert_eq!(Role::ALL.len(), 4);
assert_eq!(Role::default(), Role::Cli);
}
#[test]
fn names_round_trip_through_text() {
for &role in Role::ALL {
assert_eq!(role.to_string().parse::<Role>().unwrap(), role);
}
assert!("coordinator".parse::<Role>().is_err());
}
#[test]
fn each_role_names_a_distinct_request_family() {
let mut kinds: Vec<FrameKind> = Role::ALL.iter().map(|role| role.request_kind()).collect();
kinds.sort_unstable();
kinds.dedup();
assert_eq!(kinds.len(), Role::ALL.len());
}
#[test]
fn request_and_event_kinds_pair_up_per_leg() {
assert_eq!(Role::Cli.event_kind(), FrameKind::ControlReply);
assert_eq!(Role::Daemon.event_kind(), FrameKind::CoordinatorEvent);
assert_eq!(Role::Node.event_kind(), FrameKind::NodeEvent);
assert_eq!(Role::Peer.event_kind(), Role::Peer.request_kind());
}
#[test]
fn role_predicates_partition_the_set_as_documented() {
assert!(Role::Cli.targets_coordinator());
assert!(Role::Daemon.targets_coordinator());
assert!(!Role::Node.targets_coordinator());
assert!(!Role::Peer.targets_coordinator());
assert!(Role::Node.carries_payload());
assert!(Role::Peer.carries_payload());
assert!(!Role::Cli.carries_payload());
}
#[test]
fn serde_uses_snake_case_names() {
for &role in Role::ALL {
let json = serde_json::to_string(&role).unwrap();
assert_eq!(json, format!("\"{}\"", role.as_str()));
assert_eq!(serde_json::from_str::<Role>(&json).unwrap(), role);
}
}
#[test]
fn role_sets_hold_exactly_what_was_put_in_them() {
assert!(RoleSet::EMPTY.is_empty());
assert_eq!(RoleSet::ALL.len(), u32::try_from(Role::ALL.len()).unwrap());
for &role in Role::ALL {
assert!(RoleSet::ALL.contains(role));
assert!(RoleSet::only(role).contains(role));
assert_eq!(RoleSet::only(role).len(), 1);
assert!(!RoleSet::EMPTY.contains(role));
assert!(!RoleSet::ALL.without(role).contains(role));
}
}
#[test]
fn the_named_sets_match_their_documentation() {
assert_eq!(RoleSet::COORDINATOR.roles(), vec![Role::Cli, Role::Daemon]);
assert_eq!(RoleSet::NODES.roles(), vec![Role::Node]);
assert_eq!(RoleSet::PEERS.roles(), vec![Role::Peer]);
assert_eq!(RoleSet::ALL.roles(), Role::ALL.to_vec());
}
#[test]
fn role_sets_collect_and_display() {
let set: RoleSet = [Role::Peer, Role::Cli].into_iter().collect();
assert_eq!(set.to_string(), "cli|peer");
assert_eq!(RoleSet::EMPTY.to_string(), "none");
assert_eq!(set.roles(), vec![Role::Cli, Role::Peer]);
}
}