Struct ValAccessor

pub struct ValAccessor { /* private fields */ }

ValAccessor manage the option value and raw value.

Example

let ctx = Ctx::default().with_inner_ctx(InnerCtx::default());
{
    let mut value = ValAccessor::fallback::<i32>();
    let raw_value = OsStr::new("123");

    value.initialize()?;
    value.set(vec![1, 4]);
    value.store_all(Some(&raw_value), &ctx, &Action::App)?;
    assert_eq!(value.pop::<i32>(), Some(123));
    assert_eq!(value.rawval()?, &raw_value);
}
{
    let mut value =
        ValAccessor::new(ValStorer::fallback::<i32>(), ValInitializer::new_values(vec![7]));
    let raw_value = OsStr::new("42");

    value.initialize()?;
    value.store_all(Some(&raw_value), &ctx, &Action::Set)?;
    assert_eq!(value.pop::<i32>(), Some(42));
    assert_eq!(value.rawval()?, &raw_value);
}
{
    let validator = ValValidator::range_from(-32i32);
    let mut value = ValAccessor::new_validator(validator, ValInitializer::fallback());
    let raw_value1 = OsStr::new("8");

    value.initialize()?;
    value.set(vec![1, 4]);
    assert_eq!(
        value.store_all(Some(&raw_value1), &ctx, &Action::App)?,
        true
    );
    assert_eq!(value.pop::<i32>(), Some(8));
    assert_eq!(value.rawval()?, &raw_value1);

    let raw_value2 = OsStr::new("-66");

    assert!(value.store_all(Some(&raw_value2), &ctx, &Action::App).is_err());
    assert_eq!(value.pop::<i32>(), Some(4));
    assert_eq!(value.rawval()?, &raw_value1);
}
{
    let validator = ValValidator::range_to(-42);
    let mut value =
        ValAccessor::new_validator(validator, ValInitializer::new_values(vec![-88, 1]));
    let raw_value1 = OsStr::new("-68");

    value.initialize()?;
    assert_eq!(
        value.store_all(Some(&raw_value1), &ctx, &Action::Set)?,
        true
    );
    assert_eq!(value.pop::<i32>(), Some(-68));
    assert_eq!(value.rawval()?, &raw_value1);

    let raw_value2 = OsStr::new("-20");

    assert!(value.store_all(Some(&raw_value2), &ctx, &Action::App).is_err());
    assert_eq!(value.pop::<i32>(), None);
    assert_eq!(value.rawval()?, &raw_value1);
}

Implementations

impl ValAccessor

pub fn new(storer: ValStorer, initializer: ValInitializer) -> Self

pub fn new_validator<U: ErasedTy + RawValParser>( validator: ValValidator<U>, initializer: ValInitializer, ) -> Self

pub fn fallback<U: ErasedTy + RawValParser>() -> Self

pub fn with_storer(self, storer: ValStorer) -> Self

pub fn with_initializer(self, initializer: ValInitializer) -> Self

pub fn set_storer(&mut self, storer: ValStorer) -> &mut Self

pub fn set_initializer(&mut self, initializer: ValInitializer) -> &mut Self

pub fn storer(&self) -> &ValStorer

pub fn initializer(&self) -> &ValInitializer

pub fn storer_mut(&mut self) -> &mut ValStorer

pub fn initializer_mut(&mut self) -> &mut ValInitializer

pub fn handlers(&mut self) -> (&mut Vec<OsString>, &mut AnyValue)

pub fn store_all( &mut self, arg: Option<&OsStr>, ctx: &Ctx<'_>, act: &Action, ) -> Result<bool, Error>

Parsing the raw value into typed value, save the raw value and result. The function will map the failure error to Ok(false).

Methods from Deref<Target = AnyValue>

pub fn clear(&mut self)

pub fn contain_type<T: ErasedTy>(&self) -> bool

pub fn pop<T: ErasedTy>(&mut self) -> Option<T>

pub fn entry<T: ErasedTy>(&mut self) -> Entry<'_, Vec<T>>

pub fn push<T: ErasedTy>(&mut self, val: T) -> &mut Self

Push a value to the values of type T.

pub fn set<T: ErasedTy>(&mut self, vals: Vec<T>) -> Option<Vec<T>>

Set the values of type T.

pub fn remove<T: ErasedTy>(&mut self) -> Option<Vec<T>>

Remove the values of type T.

pub fn val<T: ErasedTy>(&self) -> Result<&T, Error>

Get the last value reference of type T.

pub fn val_mut<T: ErasedTy>(&mut self) -> Result<&mut T, Error>

Get the last value mutable reference of type T.

pub fn vals<T: ErasedTy>(&self) -> Result<&Vec<T>, Error>

Get the values of type T.

pub fn vals_mut<T: ErasedTy>(&mut self) -> Result<&mut Vec<T>, Error>

Get the values of type T.

Trait Implementations

impl Debug for ValAccessor

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ValAccessor

fn default() -> Self

Returns the “default value” for a type.

impl Deref for ValAccessor

type Target = AnyValue

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for ValAccessor

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl ErasedValue for ValAccessor

fn initialize(&mut self) -> Result<(), Error>

fn store( &mut self, arg: Option<&OsStr>, ctx: &Ctx<'_>, act: &Action, ) -> Result<(), Error>

fn store_act<U: ErasedTy>( &mut self, val: U, _: &Ctx<'_>, act: &Action, ) -> Result<(), Error>

fn val<U: ErasedTy>(&self) -> Result<&U, Error>

fn val_mut<U: ErasedTy>(&mut self) -> Result<&mut U, Error>

fn vals<U: ErasedTy>(&self) -> Result<&Vec<U>, Error>

fn vals_mut<U: ErasedTy>(&mut self) -> Result<&mut Vec<U>, Error>

fn take_val<U: ErasedTy>(&mut self) -> Result<U, Error>

fn take_vals<U: ErasedTy>(&mut self) -> Result<Vec<U>, Error>

fn rawval(&self) -> Result<&OsString, Error>

fn rawval_mut(&mut self) -> Result<&mut OsString, Error>

fn rawvals(&self) -> Result<&Vec<OsString>, Error>

fn rawvals_mut(&mut self) -> Result<&mut Vec<OsString>, Error>

fn take_rawval<U: ErasedTy>(&mut self) -> Result<OsString, Error>

fn take_rawvals<U: ErasedTy>(&mut self) -> Result<Vec<OsString>, Error>