#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum Privilege {
ProxyView,
View,
Operate,
Manage,
Administer,
}
impl Privilege {
#[must_use]
pub const fn grants(self, required: Self) -> bool {
match (self, required) {
(Self::ProxyView, Self::ProxyView) => true,
(Self::ProxyView, _) | (_, Self::ProxyView) => false,
_ => (self as u8) >= (required as u8),
}
}
}
bitflags::bitflags! {
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
pub struct AccessQualities: u8 {
const FABRIC_SCOPED = 1 << 0;
const FABRIC_SENSITIVE = 1 << 1;
const TIMED = 1 << 2;
const LARGE = 1 << 3;
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct Access {
pub read: Option<Privilege>,
pub write: Option<Privilege>,
pub invoke: Option<Privilege>,
pub qualities: AccessQualities,
}
impl Default for Access {
fn default() -> Self {
Self::read_only(Privilege::View)
}
}
impl Access {
#[must_use]
pub const fn read_only(privilege: Privilege) -> Self {
Self {
read: Some(privilege),
write: None,
invoke: None,
qualities: AccessQualities::empty(),
}
}
#[must_use]
pub const fn read_write() -> Self {
Self {
read: Some(Privilege::View),
write: Some(Privilege::Operate),
invoke: None,
qualities: AccessQualities::empty(),
}
}
#[must_use]
pub const fn read_write_with(read: Privilege, write: Privilege) -> Self {
Self {
read: Some(read),
write: Some(write),
invoke: None,
qualities: AccessQualities::empty(),
}
}
#[must_use]
pub const fn write_only(privilege: Privilege) -> Self {
Self {
read: None,
write: Some(privilege),
invoke: None,
qualities: AccessQualities::empty(),
}
}
#[must_use]
pub const fn invoke(privilege: Privilege) -> Self {
Self {
read: None,
write: None,
invoke: Some(privilege),
qualities: AccessQualities::empty(),
}
}
#[must_use]
pub const fn with_qualities(mut self, qualities: AccessQualities) -> Self {
self.qualities = qualities;
self
}
#[must_use]
pub const fn is_readable(&self) -> bool {
self.read.is_some()
}
#[must_use]
pub const fn is_writable(&self) -> bool {
self.write.is_some()
}
#[must_use]
pub const fn needs_timed(&self) -> bool {
self.qualities.contains(AccessQualities::TIMED)
}
#[must_use]
pub const fn is_fabric_scoped(&self) -> bool {
self.qualities.contains(AccessQualities::FABRIC_SCOPED)
}
#[must_use]
pub const fn is_fabric_sensitive(&self) -> bool {
self.qualities.contains(AccessQualities::FABRIC_SENSITIVE)
}
#[must_use]
pub const fn needs_large_messages(&self) -> bool {
self.qualities.contains(AccessQualities::LARGE)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_higher_privilege_grants_every_lower_one() {
let chain = [
Privilege::View,
Privilege::Operate,
Privilege::Manage,
Privilege::Administer,
];
for (i, held) in chain.iter().enumerate() {
for (j, required) in chain.iter().enumerate() {
assert_eq!(
held.grants(*required),
i >= j,
"{held:?} granting {required:?}"
);
}
}
}
#[test]
fn proxy_view_is_outside_the_chain_in_both_directions() {
for other in [
Privilege::View,
Privilege::Operate,
Privilege::Manage,
Privilege::Administer,
] {
assert!(!other.grants(Privilege::ProxyView), "{other:?} → ProxyView");
assert!(!Privilege::ProxyView.grants(other), "ProxyView → {other:?}");
}
assert!(Privilege::ProxyView.grants(Privilege::ProxyView));
}
#[test]
fn administer_grants_a_view_level_read() {
assert!(Privilege::Administer.grants(Privilege::View));
assert!(!Privilege::View.grants(Privilege::Administer));
}
#[test]
fn the_defaults_are_the_ones_7_6_states() {
assert_eq!(Access::default().read, Some(Privilege::View));
assert_eq!(Access::default().write, None, "a default is not writable");
let rw = Access::read_write();
assert_eq!(rw.read, Some(Privilege::View));
assert_eq!(rw.write, Some(Privilege::Operate));
}
#[test]
fn a_write_only_attribute_is_not_readable() {
let access = Access::write_only(Privilege::Manage);
assert!(!access.is_readable());
assert!(access.is_writable());
}
#[test]
fn the_large_message_quality_is_its_own_thing() {
let access = Access::invoke(Privilege::Administer).with_qualities(AccessQualities::LARGE);
assert!(access.needs_large_messages());
assert!(!access.needs_timed());
assert_eq!(access.invoke, Some(Privilege::Administer));
}
#[test]
fn qualities_are_independent_of_privileges() {
let access = Access::read_write()
.with_qualities(AccessQualities::FABRIC_SCOPED | AccessQualities::TIMED);
assert!(access.is_fabric_scoped());
assert!(access.needs_timed());
assert!(!access.is_fabric_sensitive());
assert_eq!(access.read, Some(Privilege::View), "unchanged");
}
}