aopt_core/value/
accessor.rs

1use std::any::type_name;
2use std::ffi::{OsStr, OsString};
3use std::ops::{Deref, DerefMut};
4
5use super::AnyValue;
6use super::ErasedValue;
7use super::RawValParser;
8use super::ValInitializer;
9use super::ValStorer;
10use super::ValValidator;
11
12use crate::ctx::Ctx;
13use crate::error;
14use crate::map::ErasedTy;
15use crate::opt::Action;
16use crate::Error;
17
18/// [`ValAccessor`] manage the option value and raw value.
19///
20/// # Example
21/// ```rust
22/// # use aopt_core::ctx::*;
23/// # use aopt_core::opt::Action;
24/// # use aopt_core::value::*;
25/// # use aopt_core::Error;
26/// #
27/// # use std::ffi::OsStr;
28/// #
29/// # fn main() -> Result<(), Error> {
30/// let ctx = Ctx::default().with_inner_ctx(InnerCtx::default());
31/// {
32///     let mut value = ValAccessor::fallback::<i32>();
33///     let raw_value = OsStr::new("123");
34///
35///     value.initialize()?;
36///     value.set(vec![1, 4]);
37///     value.store_all(Some(&raw_value), &ctx, &Action::App)?;
38///     assert_eq!(value.pop::<i32>(), Some(123));
39///     assert_eq!(value.rawval()?, &raw_value);
40/// }
41/// {
42///     let mut value =
43///         ValAccessor::new(ValStorer::fallback::<i32>(), ValInitializer::new_values(vec![7]));
44///     let raw_value = OsStr::new("42");
45///
46///     value.initialize()?;
47///     value.store_all(Some(&raw_value), &ctx, &Action::Set)?;
48///     assert_eq!(value.pop::<i32>(), Some(42));
49///     assert_eq!(value.rawval()?, &raw_value);
50/// }
51/// {
52///     let validator = ValValidator::range_from(-32i32);
53///     let mut value = ValAccessor::new_validator(validator, ValInitializer::fallback());
54///     let raw_value1 = OsStr::new("8");
55///
56///     value.initialize()?;
57///     value.set(vec![1, 4]);
58///     assert_eq!(
59///         value.store_all(Some(&raw_value1), &ctx, &Action::App)?,
60///         true
61///     );
62///     assert_eq!(value.pop::<i32>(), Some(8));
63///     assert_eq!(value.rawval()?, &raw_value1);
64///
65///     let raw_value2 = OsStr::new("-66");
66///
67///     assert!(value.store_all(Some(&raw_value2), &ctx, &Action::App).is_err());
68///     assert_eq!(value.pop::<i32>(), Some(4));
69///     assert_eq!(value.rawval()?, &raw_value1);
70/// }
71/// {
72///     let validator = ValValidator::range_to(-42);
73///     let mut value =
74///         ValAccessor::new_validator(validator, ValInitializer::new_values(vec![-88, 1]));
75///     let raw_value1 = OsStr::new("-68");
76///
77///     value.initialize()?;
78///     assert_eq!(
79///         value.store_all(Some(&raw_value1), &ctx, &Action::Set)?,
80///         true
81///     );
82///     assert_eq!(value.pop::<i32>(), Some(-68));
83///     assert_eq!(value.rawval()?, &raw_value1);
84///
85///     let raw_value2 = OsStr::new("-20");
86///
87///     assert!(value.store_all(Some(&raw_value2), &ctx, &Action::App).is_err());
88///     assert_eq!(value.pop::<i32>(), None);
89///     assert_eq!(value.rawval()?, &raw_value1);
90/// }
91/// # Ok(())
92/// # }
93/// ```
94#[derive(Debug)]
95pub struct ValAccessor {
96    any_value: AnyValue,
97
98    rawval: Vec<OsString>,
99
100    storer: ValStorer,
101
102    initializer: ValInitializer,
103}
104
105impl Default for ValAccessor {
106    fn default() -> Self {
107        Self::fallback::<String>()
108    }
109}
110
111impl ValAccessor {
112    pub fn new(storer: ValStorer, initializer: ValInitializer) -> Self {
113        Self {
114            any_value: AnyValue::default(),
115            rawval: vec![],
116            storer,
117            initializer,
118        }
119    }
120
121    pub fn new_validator<U: ErasedTy + RawValParser>(
122        validator: ValValidator<U>,
123        initializer: ValInitializer,
124    ) -> Self {
125        Self {
126            any_value: AnyValue::default(),
127            rawval: vec![],
128            storer: ValStorer::new_validator(validator),
129            initializer,
130        }
131    }
132
133    pub fn fallback<U: ErasedTy + RawValParser>() -> Self {
134        Self {
135            any_value: AnyValue::default(),
136            rawval: vec![],
137            storer: ValStorer::fallback::<U>(),
138            initializer: ValInitializer::fallback(),
139        }
140    }
141
142    pub fn with_storer(mut self, storer: ValStorer) -> Self {
143        self.storer = storer;
144        self
145    }
146
147    pub fn with_initializer(mut self, initializer: ValInitializer) -> Self {
148        self.initializer = initializer;
149        self
150    }
151
152    pub fn set_storer(&mut self, storer: ValStorer) -> &mut Self {
153        self.storer = storer;
154        self
155    }
156
157    pub fn set_initializer(&mut self, initializer: ValInitializer) -> &mut Self {
158        self.initializer = initializer;
159        self
160    }
161
162    pub fn storer(&self) -> &ValStorer {
163        &self.storer
164    }
165
166    pub fn initializer(&self) -> &ValInitializer {
167        &self.initializer
168    }
169
170    pub fn storer_mut(&mut self) -> &mut ValStorer {
171        &mut self.storer
172    }
173
174    pub fn initializer_mut(&mut self) -> &mut ValInitializer {
175        &mut self.initializer
176    }
177
178    pub fn handlers(&mut self) -> (&mut Vec<OsString>, &mut AnyValue) {
179        (&mut self.rawval, &mut self.any_value)
180    }
181
182    /// Parsing the raw value into typed value, save the raw value and result.
183    /// The function will map the failure error to `Ok(false)`.
184    pub fn store_all(
185        &mut self,
186        arg: Option<&OsStr>,
187        ctx: &Ctx,
188        act: &Action,
189    ) -> Result<bool, Error> {
190        match self.store(arg, ctx, act) {
191            Ok(_) => {
192                if let Some(raw) = arg {
193                    self.rawval.push(raw.to_os_string());
194                }
195                Ok(true)
196            }
197            Err(e) => Err(e),
198        }
199    }
200}
201
202impl Deref for ValAccessor {
203    type Target = AnyValue;
204
205    fn deref(&self) -> &Self::Target {
206        &self.any_value
207    }
208}
209
210impl DerefMut for ValAccessor {
211    fn deref_mut(&mut self) -> &mut Self::Target {
212        &mut self.any_value
213    }
214}
215
216impl ErasedValue for ValAccessor {
217    fn initialize(&mut self) -> Result<(), Error> {
218        let handler = &mut self.any_value;
219
220        self.initializer.invoke(handler)
221    }
222
223    fn store(&mut self, arg: Option<&OsStr>, ctx: &Ctx, act: &Action) -> Result<(), Error> {
224        let handler = &mut self.any_value;
225
226        self.storer.invoke(arg, ctx, act, handler)
227    }
228
229    fn store_act<U: ErasedTy>(&mut self, val: U, _: &Ctx, act: &Action) -> Result<(), Error> {
230        let handler = &mut self.any_value;
231        let value = val;
232
233        match act {
234            Action::Set => {
235                handler.set(vec![value]);
236            }
237            Action::App => {
238                handler.push(value);
239            }
240            Action::Pop => {
241                handler.pop::<U>();
242            }
243            Action::Cnt => {
244                handler.entry::<u64>().or_insert(vec![0])[0] += 1;
245            }
246            Action::Clr => {
247                handler.remove::<U>();
248            }
249            Action::Null => {
250                // NOTHING
251            }
252        }
253        Ok(())
254    }
255
256    fn val<U: ErasedTy>(&self) -> Result<&U, Error> {
257        self.any_value.val()
258    }
259
260    fn val_mut<U: ErasedTy>(&mut self) -> Result<&mut U, Error> {
261        self.any_value.val_mut()
262    }
263
264    fn vals<U: ErasedTy>(&self) -> Result<&Vec<U>, Error> {
265        self.any_value.vals()
266    }
267
268    fn vals_mut<U: ErasedTy>(&mut self) -> Result<&mut Vec<U>, Error> {
269        self.any_value.vals_mut()
270    }
271
272    fn take_val<U: ErasedTy>(&mut self) -> Result<U, Error> {
273        self.any_value.pop().ok_or_else(|| {
274            error!(
275                "can not take more value for type `{:?}` in ErasedVal(take_val)",
276                type_name::<U>()
277            )
278        })
279    }
280
281    fn take_vals<U: ErasedTy>(&mut self) -> Result<Vec<U>, Error> {
282        self.any_value.remove().ok_or_else(|| {
283            error!(
284                "can not take more values for type `{:?}` in ErasedVal(take_vals)",
285                type_name::<U>()
286            )
287        })
288    }
289
290    fn rawval(&self) -> Result<&OsString, Error> {
291        self.rawval
292            .last()
293            .ok_or_else(|| error!("no more raw value in accessor"))
294    }
295
296    fn rawval_mut(&mut self) -> Result<&mut OsString, Error> {
297        self.rawval
298            .last_mut()
299            .ok_or_else(|| error!("no more raw value in accessor"))
300    }
301
302    fn rawvals(&self) -> Result<&Vec<OsString>, Error> {
303        Ok(&self.rawval)
304    }
305
306    fn rawvals_mut(&mut self) -> Result<&mut Vec<OsString>, Error> {
307        Ok(&mut self.rawval)
308    }
309
310    fn take_rawval<U: ErasedTy>(&mut self) -> Result<OsString, Error> {
311        self.rawval
312            .pop()
313            .ok_or_else(|| error!("no more raw value in accessor"))
314    }
315
316    fn take_rawvals<U: ErasedTy>(&mut self) -> Result<Vec<OsString>, Error> {
317        Ok(std::mem::take(&mut self.rawval))
318    }
319}
aopt_core/value/accessor.rs

aopt_core/value/
accessor.rs
