use std::collections::HashMap;
use super::error::Error;
pub struct OutboundTopicAliases {
map: HashMap<String, u16>,
max: u16,
next: u16,
}
impl OutboundTopicAliases {
pub fn new(max: u16) -> Self {
Self {
max,
next: 1, map: HashMap::with_capacity(max as usize),
}
}
pub fn resolve(&mut self, topic: &str) -> Option<(u16, bool)> {
if self.max == 0 {
return None;
}
if let Some(&alias) = self.map.get(topic) {
return Some((alias, true)); }
if self.next <= self.max {
let alias = self.next;
self.next += 1;
self.map.insert(topic.to_string(), alias);
Some((alias, false)) } else {
None }
}
pub fn reset(&mut self, new_max: u16) {
self.map.clear();
self.max = new_max;
self.next = 1;
}
}
pub struct InboundTopicAliases {
table: Vec<Option<String>>,
}
impl InboundTopicAliases {
pub fn new(max: u16) -> Self {
Self {
table: vec![None; max as usize],
}
}
pub fn resolve(&mut self, topic: &str, alias: Option<u16>) -> Result<String, Error> {
let Some(alias) = alias else {
return Ok(topic.to_string());
};
if alias == 0 || alias as usize > self.table.len() {
return Err(Error::TopicAliasInvalid(alias));
}
let idx = (alias - 1) as usize;
if !topic.is_empty() {
self.table[idx] = Some(topic.to_string());
Ok(topic.to_string())
} else {
self.table[idx].clone().ok_or(Error::TopicAliasInvalid(alias))
}
}
pub fn reset(&mut self, new_max: u16) {
self.table.clear();
self.table.resize(new_max as usize, None);
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn outbound_disabled_when_max_zero() {
let mut aliases = OutboundTopicAliases::new(0);
assert_eq!(aliases.resolve("foo/bar"), None);
}
#[test]
fn outbound_register_and_reuse() {
let mut aliases = OutboundTopicAliases::new(10);
let result = aliases.resolve("sensor/temp");
assert_eq!(result, Some((1, false)));
let result = aliases.resolve("sensor/temp");
assert_eq!(result, Some((1, true)));
}
#[test]
fn outbound_multiple_topics() {
let mut aliases = OutboundTopicAliases::new(10);
assert_eq!(aliases.resolve("a"), Some((1, false)));
assert_eq!(aliases.resolve("b"), Some((2, false)));
assert_eq!(aliases.resolve("a"), Some((1, true)));
assert_eq!(aliases.resolve("b"), Some((2, true)));
}
#[test]
fn outbound_full_returns_none() {
let mut aliases = OutboundTopicAliases::new(2);
assert_eq!(aliases.resolve("a"), Some((1, false)));
assert_eq!(aliases.resolve("b"), Some((2, false)));
assert_eq!(aliases.resolve("c"), None);
assert_eq!(aliases.resolve("a"), Some((1, true)));
}
#[test]
fn outbound_reset() {
let mut aliases = OutboundTopicAliases::new(2);
aliases.resolve("a");
aliases.reset(3);
assert_eq!(aliases.resolve("a"), Some((1, false)));
}
#[test]
fn inbound_no_alias_passes_through() {
let mut aliases = InboundTopicAliases::new(10);
assert_eq!(aliases.resolve("foo/bar", None).unwrap(), "foo/bar");
}
#[test]
fn inbound_register_and_lookup() {
let mut aliases = InboundTopicAliases::new(10);
assert_eq!(aliases.resolve("sensor/temp", Some(1)).unwrap(), "sensor/temp");
assert_eq!(aliases.resolve("", Some(1)).unwrap(), "sensor/temp");
}
#[test]
fn inbound_alias_zero_is_error() {
let mut aliases = InboundTopicAliases::new(10);
assert!(aliases.resolve("foo", Some(0)).is_err());
}
#[test]
fn inbound_alias_exceeds_max_is_error() {
let mut aliases = InboundTopicAliases::new(5);
assert!(aliases.resolve("foo", Some(6)).is_err());
}
#[test]
fn inbound_unregistered_alias_lookup_is_error() {
let mut aliases = InboundTopicAliases::new(10);
assert!(aliases.resolve("", Some(3)).is_err());
}
#[test]
fn inbound_reset() {
let mut aliases = InboundTopicAliases::new(5);
aliases.resolve("foo", Some(1)).unwrap();
aliases.reset(3);
assert!(aliases.resolve("", Some(1)).is_err());
}
}