Enum 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_expr(expr: &Expr) -> Result<Self, Error>

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 for Override<T>

where T: PartialEq,

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Eq for Override<T>

where T: Eq,

impl<T> StructuralPartialEq for Override<T>