Struct serenity::framework::standard::Args [−][src]
pub struct Args { /* fields omitted */ }
Expand description
A utility struct for handling “arguments” of a command.
An “argument” is a part of the message up that ends at one of the specified delimiters, or the end of the message.
Example
use serenity::framework::standard::{Args, Delimiter}; let mut args = Args::new("hello world!", &[Delimiter::Single(' ')]); // A space is our delimiter. // Parse our argument as a `String` and assert that it's the "hello" part of the message. assert_eq!(args.single::<String>().unwrap(), "hello"); // Same here. assert_eq!(args.single::<String>().unwrap(), "world!");
We can also parse “quoted arguments” (no pun intended):
use serenity::framework::standard::{Args, Delimiter}; // Let us imagine this scenario: // You have a `photo` command that grabs the avatar url of a user. This command accepts names only. // Now, one of your users wants the avatar of a user named Princess Zelda. // Problem is, her name contains a space; our delimiter. This would result in two arguments, "Princess" and "Zelda". // So how shall we get around this? Through quotes! By surrounding her name in them we can perceive it as one single argument. let mut args = Args::new(r#""Princess Zelda""#, &[Delimiter::Single(' ')]); // Hooray! assert_eq!(args.single_quoted::<String>().unwrap(), "Princess Zelda");
In case of a mistake, we can go back in time… er I mean, one step (or entirely):
use serenity::framework::standard::{Args, Delimiter}; let mut args = Args::new("4 2", &[Delimiter::Single(' ')]); assert_eq!(args.single::<u32>().unwrap(), 4); // Oh wait, oops, meant to double the 4. // But I won't able to access it now... // oh wait, I can `rewind`. args.rewind(); assert_eq!(args.single::<u32>().unwrap() * 2, 8); // And the same for the 2 assert_eq!(args.single::<u32>().unwrap() * 2, 4); // WAIT, NO. I wanted to concatenate them into a "42" string... // Argh, what should I do now???? // .... // oh, `restore` args.restore(); let res = format!("{}{}", args.single::<String>().unwrap(), args.single::<String>().unwrap()); // Yay. assert_eq!(res, "42");
Hmm, taking a glance at the prior example, it seems we have an issue with reading the same argument over and over.
Is there a more sensible solution than rewinding…? Actually, there is! The Self::current
and Self::parse
methods:
use serenity::framework::standard::{Args, Delimiter}; let mut args = Args::new("trois cinq quatre six", &[Delimiter::Single(' ')]); assert_eq!(args.parse::<String>().unwrap(), "trois"); // It might suggest we've lost the `trois`. But in fact, we didn't! And not only that, we can do it an infinite amount of times! assert_eq!(args.parse::<String>().unwrap(), "trois"); assert_eq!(args.current(), Some("trois")); assert_eq!(args.parse::<String>().unwrap(), "trois"); assert_eq!(args.current(), Some("trois")); // Only if we use its brother method we'll then lose it. assert_eq!(args.single::<String>().unwrap(), "trois"); assert_eq!(args.single::<String>().unwrap(), "cinq"); assert_eq!(args.single::<String>().unwrap(), "quatre"); assert_eq!(args.single::<String>().unwrap(), "six");
Implementations
impl Args
[src]
impl Args
[src]pub fn new(message: &str, possible_delimiters: &[Delimiter]) -> Self
[src]
pub fn new(message: &str, possible_delimiters: &[Delimiter]) -> Self
[src]Create a new instance of Args
for parsing arguments.
For more reference, look at Args
’s struct documentation.
Example
use serenity::framework::standard::{Args, Delimiter}; let mut args = Args::new( // Our message from which we'll parse over. "the quick brown fox jumps over the lazy", // The "delimiters", or aka the separators. They denote how we distinguish arguments as their own. // For this example, we'll use one delimiter, the space (`0x20`), which will separate the message. &[Delimiter::Single(' ')], ); assert_eq!(args.single::<String>().unwrap(), "the"); assert_eq!(args.single::<String>().unwrap(), "quick"); assert_eq!(args.single::<String>().unwrap(), "brown"); // We shall not see `the quick brown` again. assert_eq!(args.rest(), "fox jumps over the lazy");
pub fn advance(&mut self) -> &mut Self
[src]
pub fn advance(&mut self) -> &mut Self
[src]Move to the next argument. This increments the offset pointer.
Does nothing if the message is empty.
pub fn rewind(&mut self) -> &mut Self
[src]
pub fn rewind(&mut self) -> &mut Self
[src]Go one step behind. This decrements the offset pointer.
Does nothing if the offset pointer is 0
.
pub fn current(&self) -> Option<&str>
[src]
pub fn current(&self) -> Option<&str>
[src]Retrieve the current argument.
Applies modifications set by Self::trimmed
and Self::quoted
.
Note
This borrows Args
for the entire lifetime of the returned argument.
Examples
use serenity::framework::standard::{Args, Delimiter}; let mut args = Args::new("4 2", &[Delimiter::Single(' ')]); assert_eq!(args.current(), Some("4")); args.advance(); assert_eq!(args.current(), Some("2")); args.advance(); assert_eq!(args.current(), None);
pub fn trimmed(&mut self) -> &mut Self
[src]
pub fn trimmed(&mut self) -> &mut Self
[src]Apply trimming of whitespace to all arguments.
Examples
use serenity::framework::standard::Args; let mut args = Args::new(" 42 ", &[]); // trimmed lasts for the whole lifetime of `Args` args.trimmed(); assert_eq!(args.current(), Some("42")); // or until we decide ourselves args.untrimmed(); assert_eq!(args.current(), Some(" 42 ")); assert_eq!(args.message(), " 42 ");
pub fn quoted(&mut self) -> &mut Self
[src]
pub fn quoted(&mut self) -> &mut Self
[src]Remove quotations surrounding all arguments.
Note that only the quotes of the argument are taken into account. The quotes in the message are preserved.
Examples
use serenity::framework::standard::Args; let mut args = Args::new("\"42\"", &[]); // `quoted` lasts the whole lifetime of `Args` args.quoted(); assert_eq!(args.current(), Some("42")); // or until we decide args.unquoted(); assert_eq!(args.current(), Some("\"42\"")); assert_eq!(args.message(), "\"42\"");
pub fn parse<T: FromStr>(&self) -> Result<T, Error<T::Err>>
[src]
pub fn parse<T: FromStr>(&self) -> Result<T, Error<T::Err>>
[src]Parse the current argument.
Modifications of Self::trimmed
and Self::quoted
are also applied if they were called.
Examples
use serenity::framework::standard::{Args, Delimiter}; let mut args = Args::new("4 2", &[Delimiter::Single(' ')]); assert_eq!(args.parse::<u32>().unwrap(), 4); assert_eq!(args.current(), Some("4"));
Errors
May return either Error::Parse
if a parse error occurs, or
Error::Eos
if there are no further remaining args.
pub fn single<T: FromStr>(&mut self) -> Result<T, Error<T::Err>>
[src]
pub fn single<T: FromStr>(&mut self) -> Result<T, Error<T::Err>>
[src]Parse the current argument and advance.
Shorthand for calling Self::parse
, storing the result,
calling Self::advance
and returning the result.
Examples
use serenity::framework::standard::{Args, Delimiter}; let mut args = Args::new("4 2", &[Delimiter::Single(' ')]); assert_eq!(args.single::<u32>().unwrap(), 4); // `4` is now out of the way. Next we have `2` assert_eq!(args.single::<u32>().unwrap(), 2); assert!(args.is_empty());
Errors
May return the same errors as parse
.
pub fn single_quoted<T: FromStr>(&mut self) -> Result<T, Error<T::Err>>
[src]
pub fn single_quoted<T: FromStr>(&mut self) -> Result<T, Error<T::Err>>
[src]Remove surrounding quotations, if present, from the argument; parse it and advance.
Shorthand for .quoted().single::<T>()
Examples
use serenity::framework::standard::{Args, Delimiter}; let mut args = Args::new(r#""4" "2""#, &[Delimiter::Single(' ')]); assert_eq!(args.single_quoted::<String>().unwrap(), "4"); assert_eq!(args.single_quoted::<u32>().unwrap(), 2); assert!(args.is_empty());
Errors
May return the same errors as Self::parse
.
pub fn iter<T: FromStr>(&mut self) -> Iter<'_, T>ⓘ
[src]
pub fn iter<T: FromStr>(&mut self) -> Iter<'_, T>ⓘ
[src]By starting from the current offset, iterate over any available arguments until there are none.
Modifications of Iter::trimmed
and Iter::quoted
are also applied to all arguments if they were called.
Examples
Assert that all of the numbers in the message are even.
use serenity::framework::standard::{Args, Delimiter}; let mut args = Args::new("4 2", &[Delimiter::Single(' ')]); for arg in args.iter::<u32>() { // Zero troubles, zero worries. let arg = arg.unwrap_or(0); assert!(arg % 2 == 0); } assert!(args.is_empty());
pub fn raw(&self) -> RawArguments<'_>ⓘNotable traits for RawArguments<'a>
impl<'a> Iterator for RawArguments<'a> type Item = &'a str;
[src]
pub fn raw(&self) -> RawArguments<'_>ⓘNotable traits for RawArguments<'a>
impl<'a> Iterator for RawArguments<'a> type Item = &'a str;
[src]Return an iterator over all unmodified arguments.
Examples
Join the arguments by a comma and a space.
use serenity::framework::standard::{Args, Delimiter}; let args = Args::new("Harry Hermione Ronald", &[Delimiter::Single(' ')]); let protagonists = args.raw().collect::<Vec<&str>>().join(", "); assert_eq!(protagonists, "Harry, Hermione, Ronald");
pub fn raw_quoted(&self) -> RawArguments<'_>ⓘNotable traits for RawArguments<'a>
impl<'a> Iterator for RawArguments<'a> type Item = &'a str;
[src]
pub fn raw_quoted(&self) -> RawArguments<'_>ⓘNotable traits for RawArguments<'a>
impl<'a> Iterator for RawArguments<'a> type Item = &'a str;
[src]Return an iterator over all arguments, stripped of their quotations if any were present.
Examples
use serenity::framework::standard::{Args, Delimiter}; let args = Args::new("Saw \"The Mist\" \"A Quiet Place\"", &[Delimiter::Single(' ')]); let horror_movies = args.raw_quoted().collect::<Vec<&str>>(); assert_eq!(&*horror_movies, &["Saw", "The Mist", "A Quiet Place"]);
pub fn find<T: FromStr>(&mut self) -> Result<T, Error<T::Err>>
[src]
pub fn find<T: FromStr>(&mut self) -> Result<T, Error<T::Err>>
[src]Search for any available argument that can be parsed, and remove it from the “arguments queue”.
Note
The removal is irreversible. And happens after the search and the parse were successful.
Note 2
“Arguments queue” is the list which contains all arguments that were deemed unique as defined by quotations and delimiters.
The ‘removed’ argument can be, likewise, still accessed via Self::message
.
Examples
use serenity::framework::standard::{Args, Delimiter}; let mut args = Args::new("c4 2", &[Delimiter::Single(' ')]); assert_eq!(args.find::<u32>().unwrap(), 2); assert_eq!(args.single::<String>().unwrap(), "c4"); assert!(args.is_empty());
Errors
Returns Error::Eos
if no argument can be parsed.
pub fn find_n<T: FromStr>(&mut self) -> Result<T, Error<T::Err>>
[src]
pub fn find_n<T: FromStr>(&mut self) -> Result<T, Error<T::Err>>
[src]Search for any available argument that can be parsed.
Examples
use serenity::framework::standard::{Args, Delimiter}; let mut args = Args::new("c4 2", &[Delimiter::Single(' ')]); assert_eq!(args.find_n::<u32>().unwrap(), 2); // The `2` is still here, so let's parse it again. assert_eq!(args.single::<String>().unwrap(), "c4"); assert_eq!(args.single::<u32>().unwrap(), 2); assert!(args.is_empty());
Errors
Returns Error::Eos
if no argument can be parsed.
pub fn rest(&self) -> &str
[src]
pub fn rest(&self) -> &str
[src]Starting from the offset, return the remainder of available arguments.
pub fn remains(&self) -> Option<&str>
[src]
pub fn remains(&self) -> Option<&str>
[src]Starting from the offset, return the remainder of available arguments.
Returns None
if there are no remaining arguments.
pub fn len(&self) -> usize
[src]
pub fn len(&self) -> usize
[src]Return the full amount of recognised arguments. The length of the “arguments queue”.
Note
The value returned is to be assumed to stay static.
However, if Self::find
was called previously, and was successful, then the value is substracted by one.
Trait Implementations
Auto Trait Implementations
impl RefUnwindSafe for Args
impl Send for Args
impl Sync for Args
impl Unpin for Args
impl UnwindSafe for Args
Blanket Implementations
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]pub fn borrow_mut(&mut self) -> &mut T
[src]
pub fn borrow_mut(&mut self) -> &mut T
[src]Mutably borrows from an owned value. Read more
impl<T> Instrument for T
[src]
impl<T> Instrument for T
[src]fn instrument(self, span: Span) -> Instrumented<Self>
[src]
fn instrument(self, span: Span) -> Instrumented<Self>
[src]Instruments this type with the provided Span
, returning an
Instrumented
wrapper. Read more
fn in_current_span(self) -> Instrumented<Self>
[src]
fn in_current_span(self) -> Instrumented<Self>
[src]impl<T> Same<T> for T
impl<T> Same<T> for T
type Output = T
type Output = T
Should always be Self
impl<T> ToOwned for T where
T: Clone,
[src]
impl<T> ToOwned for T where
T: Clone,
[src]type Owned = T
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn to_owned(&self) -> T
[src]Creates owned data from borrowed data, usually by cloning. Read more
pub fn clone_into(&self, target: &mut T)
[src]
pub fn clone_into(&self, target: &mut T)
[src]🔬 This is a nightly-only experimental API. (toowned_clone_into
)
recently added
Uses borrowed data to replace owned data, usually by cloning. Read more
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
impl<V, T> VZip<V> for T where
V: MultiLane<T>,