Struct ArgList 

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

Available on crate feature functions only.

A list of arguments that can be passed to a DynamicFunction or DynamicFunctionMut.

Example

let foo = 123;
let bar = 456;
let mut baz = 789;
let args = ArgList::new()
  // Push an owned argument
  .with_owned(foo)
  // Push an owned and boxed argument
  .with_boxed(Box::new(foo))
  // Push a reference argument
  .with_ref(&bar)
  // Push a mutable reference argument
  .with_mut(&mut baz)
  // Push a manually constructed argument
  .with_arg(ArgValue::Ref(&3.14));

Implementations

impl<'a> ArgList<'a>

pub fn new() -> Self

Create a new empty list of arguments.

pub fn push_arg(&mut self, arg: ArgValue<'a>)

Push an ArgValue onto the list.

If an argument was previously removed from the beginning of the list, this method will also re-index the list.

pub fn push_ref(&mut self, arg: &'a dyn PartialReflect)

Push an ArgValue::Ref onto the list with the given reference.

If an argument was previously removed from the beginning of the list, this method will also re-index the list.

pub fn push_mut(&mut self, arg: &'a mut dyn PartialReflect)

Push an ArgValue::Mut onto the list with the given mutable reference.

If an argument was previously removed from the beginning of the list, this method will also re-index the list.

pub fn push_owned(&mut self, arg: impl PartialReflect)

Push an ArgValue::Owned onto the list with the given owned value.

If an argument was previously removed from the beginning of the list, this method will also re-index the list.

pub fn push_boxed(&mut self, arg: Box<dyn PartialReflect>)

Push an ArgValue::Owned onto the list with the given boxed value.

If an argument was previously removed from the beginning of the list, this method will also re-index the list.

pub fn with_arg(self, arg: ArgValue<'a>) -> Self

Push an ArgValue onto the list.

If an argument was previously removed from the beginning of the list, this method will also re-index the list.

pub fn with_ref(self, arg: &'a dyn PartialReflect) -> Self

Push an ArgValue::Ref onto the list with the given reference.

If an argument was previously removed from the beginning of the list, this method will also re-index the list.

pub fn with_mut(self, arg: &'a mut dyn PartialReflect) -> Self

Push an ArgValue::Mut onto the list with the given mutable reference.

If an argument was previously removed from the beginning of the list, this method will also re-index the list.

pub fn with_owned(self, arg: impl PartialReflect) -> Self

Push an ArgValue::Owned onto the list with the given owned value.

If an argument was previously removed from the beginning of the list, this method will also re-index the list.

pub fn with_boxed(self, arg: Box<dyn PartialReflect>) -> Self

Push an ArgValue::Owned onto the list with the given boxed value.

If an argument was previously removed from the beginning of the list, this method will also re-index the list.

pub fn take_arg(&mut self) -> Result<Arg<'a>, ArgError>

Remove the first argument in the list and return it.

It’s generally preferred to use Self::take instead of this method as it provides a more ergonomic way to immediately downcast the argument.

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

Remove the first argument in the list and return Ok(T::This).

If the list is empty or the FromArg::from_arg call fails, returns an error.

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: Reflect + TypePath>(&mut self) -> Result<T, ArgError>

Remove the first argument in the list and return Ok(T) if the argument is ArgValue::Owned.

If the list is empty or 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: Reflect + TypePath>(&mut self) -> Result<&'a T, ArgError>

Remove the first argument in the list and return Ok(&T) if the argument is ArgValue::Ref.

If the list is empty or 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: Reflect + TypePath>(&mut self) -> Result<&'a mut T, ArgError>

Remove the first argument in the list and return Ok(&mut T) if the argument is ArgValue::Mut.

If the list is empty or 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 pop_arg(&mut self) -> Result<Arg<'a>, ArgError>

Remove the last argument in the list and return it.

It’s generally preferred to use Self::pop instead of this method as it provides a more ergonomic way to immediately downcast the argument.

pub fn pop<T: FromArg>(&mut self) -> Result<T::This<'a>, ArgError>

Remove the last argument in the list and return Ok(T::This).

If the list is empty or the FromArg::from_arg call fails, returns an error.

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 c = args.pop::<&mut u32>().unwrap();
assert_eq!(*c, 3);

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

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

pub fn pop_owned<T: Reflect + TypePath>(&mut self) -> Result<T, ArgError>

Remove the last argument in the list and return Ok(T) if the argument is ArgValue::Owned.

If the list is empty or the argument is not owned, returns an error.

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

Example

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

pub fn pop_ref<T: Reflect + TypePath>(&mut self) -> Result<&'a T, ArgError>

Remove the last argument in the list and return Ok(&T) if the argument is ArgValue::Ref.

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

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

Example

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

pub fn pop_mut<T: Reflect + TypePath>(&mut self) -> Result<&'a mut T, ArgError>

Remove the last argument in the list and return Ok(&mut T) if the argument is ArgValue::Mut.

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

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

Example

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

pub fn iter(&self) -> Iter<'_, Arg<'a>>

Returns an iterator over the arguments in the list.

pub fn len(&self) -> usize

Returns the number of arguments in the list.

pub fn is_empty(&self) -> bool

Returns true if the list of arguments is empty.

Trait Implementations

impl<'a> Debug for ArgList<'a>

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

Formats the value using the given formatter.

impl<'a> Default for ArgList<'a>

fn default() -> ArgList<'a>

Returns the “default value” for a type.

impl From<&ArgList<'_>> for ArgumentSignature

fn from(args: &ArgList<'_>) -> Self

Converts to this type from the input type.