Enum darling::util::Override

pub enum Override<T> {
    Inherit,
    Explicit(T),
}

A value which can inherit a default value or have an explicit value specified.

Usage

This type is meant for attributes like default in darling, which can take the following forms:

• #[darling(default)]
• #[darling(default="path::to::fn")]

In a struct collecting input for this attribute, that would be written as:

use darling::{util::Override, FromField};
#[derive(FromField)]
#[darling(attributes(darling))]
pub struct Options {
   default: Option<Override<syn::Path>>,
}

impl Options {
    fn hydrate(self) -> Option<syn::Path> {
        self.default.map(|ov| ov.unwrap_or(syn::parse_path("::Default::default").unwrap()))
    }
}

The word format (with no associated value), would produce Override::Inherit, while a list or value format would produce Override::Explicit.

Variants

Inherit

Inherit the eventual value from an external source.

Explicit(T)

Explicitly set the value.

Implementations

impl<T> Override<T>

pub fn as_ref(&self) -> Override<&T>

Converts from Override<T> to Override<&T>.

Produces a new Override, containing a reference into the original, leaving the original in place.

pub fn as_mut(&mut self) -> Override<&mut T>

Converts from Override<T> to Override<&mut T>.

Produces a new Override, containing a mutable reference into the original.

pub fn is_explicit(&self) -> bool

Returns true if the override is an Explicit value.

pub fn explicit(self) -> Option<T>

Converts from Override<T> to Option<T>.

pub fn unwrap_or(self, optb: T) -> T

Unwraps an override, yielding the content of an Explicit. Otherwise, it returns optb.

pub fn unwrap_or_else<F>(self, op: F) -> T where
    F: FnOnce() -> T, 

Unwraps an override, yielding the content of an Explicit. Otherwise, it calls op.

impl<T> Override<T> where
    T: Default, 

pub fn unwrap_or_default(self) -> T

Returns the contained value or the default value of T.

Trait Implementations

impl<T> Clone for Override<T> where
    T: Clone, 

fn clone(&self) -> Override<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Override<T> where
    T: Debug, 

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

Formats the value using the given formatter.

impl<T> Default for Override<T>

fn default() -> Override<T>

Returns the “default value” for a type.

impl<T> Display for Override<T> where
    T: Display, 

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

Formats the value using the given formatter.

impl<T> From<Option<T>> for Override<T>

fn from(v: Option<T>) -> Override<T>

Converts to this type from the input type.

impl<T> FromMeta for Override<T> where
    T: FromMeta, 

Parses a Meta. A bare word will produce Override::Inherit, while any value will be forwarded to T::from_meta.

fn from_word() -> Result<Override<T>, Error>

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

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

Create an instance from a list of nested meta items.

fn from_value(lit: &Lit) -> Result<Override<T>, 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_nested_meta(item: &NestedMeta) -> Result<Self, Error>

fn from_meta(item: &Meta) -> Result<Self, 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_none() -> Option<Self>

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_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<T> PartialEq<Override<T>> for Override<T> where
    T: PartialEq<T>, 

fn eq(&self, other: &Override<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Override<T>) -> bool

This method tests for !=.

impl<T> Eq for Override<T> where
    T: Eq, 

impl<T> StructuralEq for Override<T>

impl<T> StructuralPartialEq for Override<T>