Kinesin Data Technologies Incorporated
89 lines
2.4 KiB
Rust
89 lines
2.4 KiB
Rust
use super::*;
|
|
use std::ops::{Deref, DerefMut};
|
|
|
|
#[derive(Clone, Debug, Serialize, Deserialize, Default, PartialEq)]
|
|
pub struct VarMap(HashMap<String, String>);
|
|
|
|
impl Deref for VarMap {
|
|
type Target = HashMap<String, String>;
|
|
fn deref(&self) -> &Self::Target {
|
|
&self.0
|
|
}
|
|
}
|
|
|
|
impl DerefMut for VarMap {
|
|
fn deref_mut(&mut self) -> &mut Self::Target {
|
|
&mut self.0
|
|
}
|
|
}
|
|
|
|
impl VarMap {
|
|
pub fn new() -> Self {
|
|
VarMap(HashMap::new())
|
|
}
|
|
|
|
// Derive variables from a given interval
|
|
pub fn from_interval(int: &Interval, tz: Tz) -> Self {
|
|
let start = int.start.with_timezone(&tz);
|
|
let end = int.end.with_timezone(&tz);
|
|
|
|
VarMap(HashMap::from([
|
|
("PERIOD_START".to_owned(), format!("{}", start)),
|
|
("PERIOD_END".to_owned(), format!("{}", end)),
|
|
("yyyy".to_owned(), format!("{}", end.year())),
|
|
("mm".to_owned(), format!("{}", end.month())),
|
|
("dd".to_owned(), format!("{}", end.day())),
|
|
(
|
|
"yyyymmdd".to_owned(),
|
|
format!("{}{}{}", end.year(), end.month(), end.day()),
|
|
),
|
|
(
|
|
"hhmmss".to_owned(),
|
|
format!("{}{}{}", end.hour(), end.minute(), end.second()),
|
|
),
|
|
]))
|
|
}
|
|
|
|
/// Interpolate values into a string, assuming string has variables
|
|
/// as ${varname}
|
|
pub fn apply_to(&self, s: &str) -> String {
|
|
let mut expanded = s.to_string();
|
|
for (key, value) in self.0.iter() {
|
|
expanded = expanded.replace(&format!("${{{}}}", key), value);
|
|
}
|
|
expanded
|
|
}
|
|
}
|
|
|
|
impl From<HashMap<String, String>> for VarMap {
|
|
fn from(data: HashMap<String, String>) -> Self {
|
|
VarMap(data)
|
|
}
|
|
}
|
|
|
|
impl<'a> FromIterator<(&'a String, &'a String)> for VarMap {
|
|
fn from_iter<I: IntoIterator<Item = (&'a String, &'a String)>>(iter: I) -> Self {
|
|
let mut data = HashMap::new();
|
|
for (k, v) in iter {
|
|
data.insert(k.clone(), v.clone());
|
|
}
|
|
VarMap(data)
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn check_simple_apply() {
|
|
let s = "This is a ${test} of home and ${test} of away ${beep}";
|
|
let vm = VarMap(HashMap::from([("test".to_owned(), "alpha".to_owned())]));
|
|
|
|
assert_eq!(
|
|
&vm.apply_to(s),
|
|
"This is a alpha of home and alpha of away ${beep}"
|
|
);
|
|
}
|
|
}
|