aopt_core/
value.rs

1pub(crate) mod accessor;
2pub(crate) mod initializer;
3pub(crate) mod parser;
4pub(crate) mod storer;
5pub(crate) mod validator;
6
7use std::any::type_name;
8use std::ffi::OsStr;
9use std::ffi::OsString;
10use std::fmt::Debug;
11
12use crate::ctx::Ctx;
13use crate::error;
14use crate::map::AnyMap;
15use crate::map::Entry;
16use crate::map::ErasedTy;
17use crate::opt::Action;
18use crate::Error;
19
20pub use self::accessor::ValAccessor;
21pub use self::initializer::InitHandler;
22pub use self::initializer::InitializeValue;
23pub use self::initializer::ValInitializer;
24pub use self::parser::raw2str;
25pub use self::parser::RawValParser;
26pub use self::storer::StoreHandler;
27pub use self::storer::ValStorer;
28pub use self::validator::ValValidator;
29pub use self::validator::ValidatorHandler;
30
31pub trait ErasedValue {
32    fn initialize(&mut self) -> Result<(), Error>;
33
34    fn store(&mut self, raw: Option<&OsStr>, ctx: &Ctx, act: &Action) -> Result<(), Error>;
35
36    fn store_act<U: ErasedTy>(&mut self, val: U, ctx: &Ctx, act: &Action) -> Result<(), Error>;
37
38    fn val<U: ErasedTy>(&self) -> Result<&U, Error>;
39
40    fn val_mut<U: ErasedTy>(&mut self) -> Result<&mut U, Error>;
41
42    fn vals<U: ErasedTy>(&self) -> Result<&Vec<U>, Error>;
43
44    fn vals_mut<U: ErasedTy>(&mut self) -> Result<&mut Vec<U>, Error>;
45
46    fn take_val<U: ErasedTy>(&mut self) -> Result<U, Error>;
47
48    fn take_vals<U: ErasedTy>(&mut self) -> Result<Vec<U>, Error>;
49
50    fn rawval(&self) -> Result<&OsString, Error>;
51
52    fn rawval_mut(&mut self) -> Result<&mut OsString, Error>;
53
54    fn rawvals(&self) -> Result<&Vec<OsString>, Error>;
55
56    fn rawvals_mut(&mut self) -> Result<&mut Vec<OsString>, Error>;
57
58    fn take_rawval<U: ErasedTy>(&mut self) -> Result<OsString, Error>;
59
60    fn take_rawvals<U: ErasedTy>(&mut self) -> Result<Vec<OsString>, Error>;
61}
62
63/// [`AnyValue`] can save values of any type. In internal it save the value into a vector of type T.
64///
65/// # Example
66///
67/// ```rust
68/// # use aopt_core::value::AnyValue;
69/// # use aopt_core::Error;
70/// # use std::ops::SubAssign;
71/// #
72/// # fn main() -> Result<(), Error> {
73/// let mut value = AnyValue::new();
74///
75/// assert_eq!(value.contain_type::<i32>(), false);
76/// assert_eq!(value.set(vec![42]), None);
77/// assert_eq!(value.contain_type::<i32>(), true);
78///
79/// assert_eq!(value.val::<i32>()?, &42);
80/// assert_eq!(value.push(256).val::<i32>()?, &256);
81/// value.val_mut::<i32>()?.sub_assign(128);
82/// assert_eq!(value.val::<i32>()?, &128);
83///
84/// assert_eq!(value.vals::<i32>()?, &vec![42, 128]);
85/// assert_eq!(value.pop::<i32>(), Some(128));
86/// assert_eq!(value.vals::<i32>()?, &vec![42]);
87///
88/// value.entry::<u64>().or_insert(vec![9, 0, 2, 5]);
89/// assert_eq!(value.entry::<u64>().or_default().pop(), Some(5));
90///
91/// value.vals_mut::<i32>()?.pop();
92/// assert_eq!(value.vals::<i32>()?.len(), 0);
93///
94/// assert_eq!(value.remove::<u64>(), Some(vec![9, 0, 2]));
95/// assert_eq!(value.contain_type::<u64>(), false);
96/// #
97/// # Ok(())
98/// # }
99/// ```
100#[derive(Default)]
101pub struct AnyValue(AnyMap);
102
103impl Debug for AnyValue {
104    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
105        f.debug_struct("AnyValue").field("inner", &self.0).finish()
106    }
107}
108
109impl AnyValue {
110    pub fn new() -> Self {
111        Self::default()
112    }
113
114    pub fn clear(&mut self) {
115        self.0.clear()
116    }
117
118    pub fn contain_type<T: ErasedTy>(&self) -> bool {
119        self.0.contain::<Vec<T>>()
120    }
121
122    fn inner<T: ErasedTy>(&self) -> Option<&Vec<T>> {
123        self.0.value::<Vec<T>>()
124    }
125
126    fn inner_mut<T: ErasedTy>(&mut self) -> Option<&mut Vec<T>> {
127        self.0.value_mut::<Vec<T>>()
128    }
129
130    pub fn pop<T: ErasedTy>(&mut self) -> Option<T> {
131        self.inner_mut().and_then(|v| v.pop())
132    }
133
134    pub fn entry<T: ErasedTy>(&mut self) -> Entry<'_, Vec<T>> {
135        self.0.entry::<Vec<T>>()
136    }
137
138    /// Push a value to the values of type T.
139    pub fn push<T: ErasedTy>(&mut self, val: T) -> &mut Self {
140        self.entry::<T>().or_default().push(val);
141        self
142    }
143
144    /// Set the values of type T.
145    pub fn set<T: ErasedTy>(&mut self, vals: Vec<T>) -> Option<Vec<T>> {
146        let ret = self.remove();
147        self.entry().or_insert(vals);
148        ret
149    }
150
151    /// Remove the values of type T.
152    pub fn remove<T: ErasedTy>(&mut self) -> Option<Vec<T>> {
153        self.0.remove::<Vec<T>>()
154    }
155
156    /// Get the last value reference of type T.
157    pub fn val<T: ErasedTy>(&self) -> Result<&T, Error> {
158        self.inner().and_then(|v| v.last()).ok_or_else(|| {
159            error!(
160                "can not find value for type `{:?}` in ErasedVal(val)",
161                type_name::<T>()
162            )
163        })
164    }
165
166    /// Get the last value mutable reference of type T.
167    pub fn val_mut<T: ErasedTy>(&mut self) -> Result<&mut T, Error> {
168        self.inner_mut().and_then(|v| v.last_mut()).ok_or_else(|| {
169            error!(
170                "can not find value for type `{:?}` in ErasedVal(val_mut)",
171                type_name::<T>()
172            )
173        })
174    }
175
176    /// Get the values of type T.
177    pub fn vals<T: ErasedTy>(&self) -> Result<&Vec<T>, Error> {
178        self.inner().ok_or_else(|| {
179            error!(
180                "can not find value for type `{:?}` in ErasedVal(vals)",
181                type_name::<T>()
182            )
183        })
184    }
185
186    /// Get the values of type T.
187    pub fn vals_mut<T: ErasedTy>(&mut self) -> Result<&mut Vec<T>, Error> {
188        self.inner_mut().ok_or_else(|| {
189            error!(
190                "can not find value for type `{:?}` in ErasedVal(vals_mut)",
191                type_name::<T>()
192            )
193        })
194    }
195}
aopt_core/value.rs

aopt_core/
value.rs
