Struct `Flags`

struct Flags { ... }

A group of flags.

This corresponds only to the sequence of flags themselves, e.g., is-u.

Fields

span: Span: The span of this group of flags.
items: Vec<FlagsItem>: A sequence of flag items. Each item is either a flag or a negation operator.

Implementations

`impl Flags`

fn add_item(self: &mut Self, item: FlagsItem) -> Option<usize>

Add the given item to this sequence of flags.

If the item was added successfully, then None is returned. If the given item is a duplicate, then Some(i) is returned, where items[i].kind == item.kind.

fn flag_state(self: &Self, flag: Flag) -> Option<bool>

Returns the state of the given flag in this set.

If the given flag is in the set but is negated, then Some(false) is returned.

If the given flag is in the set and is not negated, then Some(true) is returned.

Otherwise, None is returned.

`impl Clone for Flags`

fn clone(self: &Self) -> Flags

`impl Debug for Flags`

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

`impl Eq for Flags`

`impl Freeze for Flags`

`impl PartialEq for Flags`

fn eq(self: &Self, other: &Flags) -> bool

`impl RefUnwindSafe for Flags`

`impl Send for Flags`

`impl StructuralPartialEq for Flags`

`impl Sync for Flags`

`impl Unpin for Flags`

`impl UnsafeUnpin for Flags`

`impl UnwindSafe for Flags`

`impl<T> Any for Flags`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for Flags`

fn borrow(self: &Self) -> &T

`impl<T> BorrowMut for Flags`

fn borrow_mut(self: &mut Self) -> &mut T

`impl<T> CloneToUninit for Flags`

unsafe fn clone_to_uninit(self: &Self, dest: *mut u8)

`impl<T> From for Flags`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> ToOwned for Flags`

fn to_owned(self: &Self) -> T
fn clone_into(self: &Self, target: &mut T)

`impl<T, U> Into for Flags`

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom for Flags`

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

`impl<T, U> TryInto for Flags`

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>