use indexmap::IndexMap;
use indexmap::map::Entry;
#[cfg(feature = "serialization")]
use serde::{Deserialize, Serialize};
const SEP_ESC: char = '\x1b';
const MULTI_SEP: char = '\r';
const SEP_COMMA: char = ',';
const INSTANCE_PREFIX: &str = "instance:";
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serialization", derive(Serialize, Deserialize))]
pub struct Connection {
pub output: String,
pub target: String,
pub input: String,
pub params: String,
pub delay: f32,
pub fire_limit: i32,
}
impl Connection {
pub fn parse(output: String, value: &str) -> Self {
let sep = if value.contains(SEP_ESC) {
SEP_ESC
} else {
SEP_COMMA
};
let mut head = value.splitn(3, sep);
let target = head.next().unwrap_or("");
let input = head.next().unwrap_or("");
let rest = head.next().unwrap_or("");
let mut tail = rest.rsplitn(3, sep);
let last = tail.next().unwrap_or("");
let mid = tail.next().unwrap_or("");
let (params, delay, fire_limit) = match tail.next() {
Some(params) => (params, mid, last),
None => (rest, "", ""),
};
Connection {
output,
target: target.to_string(),
input: input.to_string(),
params: params.to_string(),
delay: delay.parse().unwrap_or(0.0),
fire_limit: fire_limit.parse().unwrap_or(-1),
}
}
pub fn to_value_string(&self) -> String {
format!(
"{}{sep}{}{sep}{}{sep}{}{sep}{}",
self.target,
self.input,
self.params,
self.delay,
self.fire_limit,
sep = SEP_ESC
)
}
pub fn target_kind(&self) -> Target<'_> {
Target::parse(&self.target)
}
pub fn instance_input(&self) -> Option<InstanceIo<'_>> {
InstanceIo::parse(&self.input)
}
pub fn instance_output(&self) -> Option<InstanceIo<'_>> {
InstanceIo::parse(&self.output)
}
pub fn set_instance_input(&mut self, proxy: &str, io: &str) {
self.input = format!("{INSTANCE_PREFIX}{proxy};{io}");
}
pub fn set_instance_output(&mut self, proxy: &str, io: &str) {
self.output = format!("{INSTANCE_PREFIX}{proxy};{io}");
}
pub fn from_key_values(map: &IndexMap<String, String>) -> Option<Vec<Self>> {
if map.is_empty() {
return None;
}
let mut result = Vec::with_capacity(map.len() * 2);
for (key, value) in map {
for part in value.split(MULTI_SEP) {
result.push(Connection::parse(key.clone(), part));
}
}
Some(result)
}
pub fn to_key_values(connections: &[Self]) -> IndexMap<String, String> {
let mut map = IndexMap::with_capacity(connections.len());
for conn in connections {
match map.entry(conn.output.clone()) {
Entry::Occupied(mut slot) => {
let joined: &mut String = slot.get_mut();
joined.push(MULTI_SEP);
joined.push_str(&conn.to_value_string());
}
Entry::Vacant(slot) => {
slot.insert(conn.to_value_string());
}
}
}
map
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Special<'a> {
SelfEnt,
Activator,
Caller,
Player,
PvsPlayer,
Picker,
Other(&'a str),
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Target<'a> {
Name(&'a str),
Wildcard(&'a str),
Special(Special<'a>),
}
impl<'a> Target<'a> {
pub fn parse(target: &'a str) -> Self {
if let Some(tag) = target.strip_prefix('!') {
let special = if tag.eq_ignore_ascii_case("self") {
Special::SelfEnt
} else if tag.eq_ignore_ascii_case("activator") {
Special::Activator
} else if tag.eq_ignore_ascii_case("caller") {
Special::Caller
} else if tag.eq_ignore_ascii_case("player") {
Special::Player
} else if tag.eq_ignore_ascii_case("pvsplayer") {
Special::PvsPlayer
} else if tag.eq_ignore_ascii_case("picker") {
Special::Picker
} else {
Special::Other(tag)
};
return Target::Special(special);
}
match target.strip_suffix('*') {
Some(prefix) => Target::Wildcard(prefix),
None => Target::Name(target),
}
}
pub fn name(&self) -> Option<&'a str> {
match self {
Target::Name(name) => Some(name),
_ => None,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct InstanceIo<'a> {
pub proxy: &'a str,
pub io: &'a str,
}
impl<'a> InstanceIo<'a> {
pub fn parse(value: &'a str) -> Option<Self> {
let head = value.get(..INSTANCE_PREFIX.len())?;
if !head.eq_ignore_ascii_case(INSTANCE_PREFIX) {
return None;
}
let (proxy, io) = value[INSTANCE_PREFIX.len()..].split_once(';')?;
Some(InstanceIo { proxy, io })
}
}
impl std::fmt::Display for InstanceIo<'_> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{INSTANCE_PREFIX}{};{}", self.proxy, self.io)
}
}