alfred_workflow_rs/
automatic_cache.rs1use serde::ser::SerializeMap;
2use serde::{Deserialize, Serialize};
3
4use crate::{Error, Result};
5
6#[derive(Clone, Debug, Eq, PartialEq)]
8pub struct AutomaticCache {
9 seconds: u64,
10 loose_reload: Option<bool>,
11}
12
13impl Serialize for AutomaticCache {
14 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15 where
16 S: serde::Serializer,
17 {
18 let mut map =
19 serializer.serialize_map(Some(1 + usize::from(self.loose_reload.is_some())))?;
20 map.serialize_entry("seconds", &self.seconds)?;
21 if let Some(loose_reload) = self.loose_reload {
22 map.serialize_entry("loosereload", &loose_reload)?;
23 }
24 map.end()
25 }
26}
27
28impl AutomaticCache {
29 pub const MIN_SECONDS: u64 = 5;
31 pub const MAX_SECONDS: u64 = 86_400;
33
34 pub fn try_new(seconds: u64) -> Result<Self> {
36 Self::try_with_loose_reload(seconds, None)
37 }
38
39 pub fn try_with_loose_reload(seconds: u64, loose_reload: Option<bool>) -> Result<Self> {
41 if !(Self::MIN_SECONDS..=Self::MAX_SECONDS).contains(&seconds) {
42 return Err(Error::InvalidAutomaticCacheSeconds {
43 seconds,
44 min: Self::MIN_SECONDS,
45 max: Self::MAX_SECONDS,
46 });
47 }
48
49 Ok(Self {
50 seconds,
51 loose_reload,
52 })
53 }
54
55 pub fn seconds(&self) -> u64 {
57 self.seconds
58 }
59
60 pub fn loose_reload(&self) -> Option<bool> {
62 self.loose_reload
63 }
64}
65
66impl<'de> Deserialize<'de> for AutomaticCache {
67 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
68 where
69 D: serde::Deserializer<'de>,
70 {
71 #[derive(Deserialize)]
72 struct Wire {
73 seconds: u64,
74 #[serde(rename = "loosereload", default)]
75 loose_reload: Option<bool>,
76 }
77
78 let wire = Wire::deserialize(deserializer)?;
79 Self::try_with_loose_reload(wire.seconds, wire.loose_reload)
80 .map_err(serde::de::Error::custom)
81 }
82}