Struct Arg 

pub struct Arg<'a> { /* private fields */ }

Represents an argument that can be passed to a DynamicFunction or DynamicFunctionMut.

Implementations

impl<'a> Arg<'a>

pub fn new(index: usize, value: ArgValue<'a>) -> Arg<'a>

Create a new Arg with the given index and value.

pub fn index(&self) -> usize

The index of the argument.

pub fn value(&self) -> &ArgValue<'a>

The value of the argument.

pub fn take_value(self) -> ArgValue<'a>

Take the value of the argument.

pub fn take<T>(self) -> Result<<T as FromArg>::This<'a>, ArgError>

where T: FromArg,

Take the value of the argument and attempt to convert it to a concrete value, T.

This is a convenience method for calling FromArg::from_arg on the argument.

Example

let a = 1u32;
let b = 2u32;
let mut c = 3u32;
let mut args = ArgList::new().with_owned(a).with_ref(&b).with_mut(&mut c);

let a = args.take::<u32>().unwrap();
assert_eq!(a, 1);

let b = args.take::<&u32>().unwrap();
assert_eq!(*b, 2);

let c = args.take::<&mut u32>().unwrap();
assert_eq!(*c, 3);

pub fn take_owned<T>(self) -> Result<T, ArgError>

where T: Reflect + TypePath,

Returns Ok(T) if the argument is ArgValue::Owned.

If the argument is not owned, returns an error.

It’s generally preferred to use Self::take instead of this method.

Example

let value = 123u32;
let mut args = ArgList::new().with_owned(value);
let value = args.take_owned::<u32>().unwrap();
assert_eq!(value, 123);

pub fn take_ref<T>(self) -> Result<&'a T, ArgError>

where T: Reflect + TypePath,

Returns Ok(&T) if the argument is ArgValue::Ref.

If the argument is not a reference, returns an error.

It’s generally preferred to use Self::take instead of this method.

Example

let value = 123u32;
let mut args = ArgList::new().with_ref(&value);
let value = args.take_ref::<u32>().unwrap();
assert_eq!(*value, 123);

pub fn take_mut<T>(self) -> Result<&'a mut T, ArgError>

where T: Reflect + TypePath,

Returns Ok(&mut T) if the argument is ArgValue::Mut.

If the argument is not a mutable reference, returns an error.

It’s generally preferred to use Self::take instead of this method.

Example

let mut value = 123u32;
let mut args = ArgList::new().with_mut(&mut value);
let value = args.take_mut::<u32>().unwrap();
assert_eq!(*value, 123);

pub fn is<T>(&self) -> bool

where T: TypePath,

Returns true if the argument is of type T.

Trait Implementations

impl<'a> Debug for Arg<'a>

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

Formats the value using the given formatter.