Struct `Flags`

pub struct Flags { pub span: Span, pub items: Vec<FlagsItem> }

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(&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, 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.

Trait Implementations

`impl Clone for Flags`

fn clone(&self) -> Self

`impl Debug for Flags`

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

`impl Eq for Flags`

`impl PartialEq for Flags`

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

`impl StructuralPartialEq for Flags`

Auto Trait Implementations

`impl Freeze for Flags`

`impl RefUnwindSafe for Flags`

`impl Send for Flags`

`impl Sync for Flags`

`impl Unpin for Flags`

`impl UnsafeUnpin for Flags`

`impl UnwindSafe for Flags`

Blanket Implementations

`impl<T> Any for Flags where T: 'static + ?Sized,`

fn type_id(&self) -> TypeId

`impl<T> Borrow<T> for Flags where T: ?Sized,`

fn borrow(&self) -> &T

`impl<T> BorrowMut<T> for Flags where T: ?Sized,`

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

`impl<T> CloneToUninit for Flags where T: Clone,`

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

`impl<T> From<T> for Flags`

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

`impl<T> ToOwned for Flags where T: Clone,`

type Owned = T;
fn to_owned(&self) -> T
fn clone_into(&self, target: &mut T)

`impl<T, U> Into for Flags where U: From<T>,`

fn into(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 where U: Into<T>,`

type Error = never;
fn try_from(value: U) -> Result<T, never>

`impl<T, U> TryInto for Flags where U: TryFrom<T>,`

type Error = >::Error;
fn try_into(self) -> Result<U, >::Error>