Struct darling::util::Flag

pub struct Flag(/* private fields */);

A meta-item that can be present as a word - with no value - or absent.

Defaulting

Like Option, Flag does not require #[darling(default)] to be optional. If the caller does not include the property, then an absent Flag will be included in the receiver struct.

Spans

Flag keeps the span where its word was seen. This enables attaching custom error messages to the word, such as in the case of two conflicting flags being present.

Example

#[derive(FromMeta)]
#[darling(and_then = "Self::not_both")]
struct Demo {
    flag_a: Flag,
    flag_b: Flag,
}

impl Demo {
    fn not_both(self) -> Result<Self> {
        if self.flag_a.is_present() && self.flag_b.is_present() {
            Err(Error::custom("Cannot set flag_a and flag_b").with_span(self.flag_b))
        } else {
            Ok(self)
        }
    }
}

The above struct would then produce the following error.

#[example(flag_a, flag_b)]
//                ^^^^^^ Cannot set flag_a and flag_b

Implementations

impl Flag

pub fn present() -> Flag

Creates a new Flag which corresponds to the presence of a value.

pub fn is_present(&self) -> bool

Check if the flag is present.

pub fn is_some(&self) -> bool

👎Deprecated since 0.14.0: Use Flag::is_present

Trait Implementations

impl Clone for Flag

fn clone(&self) -> Flag

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Flag

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

Formats the value using the given formatter.

impl Default for Flag

fn default() -> Flag

Returns the “default value” for a type.

impl From<Flag> for bool

fn from(flag: Flag) -> bool

Converts to this type from the input type.

impl From<bool> for Flag

fn from(v: bool) -> Flag

Converts to this type from the input type.

impl FromMeta for Flag

fn from_none() -> Option<Flag>

When a field is omitted from a parent meta-item, from_none is used to attempt recovery before a missing field error is generated.

fn from_meta(mi: &Meta) -> Result<Flag, Error>

Create an instance from a syn::Meta by dispatching to the format-appropriate trait function. This generally should not be overridden by implementers.

fn from_nested_meta(item: &NestedMeta) -> Result<Self, Error>

fn from_word() -> Result<Self, Error>

Create an instance from the presence of the word in the attribute with no additional options specified.

fn from_list(items: &[NestedMeta]) -> Result<Self, Error>

Create an instance from a list of nested meta items.

fn from_value(value: &Lit) -> Result<Self, Error>

Create an instance from a literal value of either foo = "bar" or foo("bar"). This dispatches to the appropriate method based on the type of literal encountered, and generally should not be overridden by implementers.

fn from_char(value: char) -> Result<Self, Error>

Create an instance from a char literal in a value position.

fn from_string(value: &str) -> Result<Self, Error>

Create an instance from a string literal in a value position.

fn from_bool(value: bool) -> Result<Self, Error>

Create an instance from a bool literal in a value position.

impl Spanned for Flag

fn span(&self) -> Span

Returns a Span covering the complete contents of this syntax tree node, or Span::call_site() if this node is empty.

impl Copy for Flag