Enum darling::ast::Data

pub enum Data<V, F> {
    Enum(Vec<V>),
    Struct(Fields<F>),
}

A struct or enum body.

V is the type which receives any encountered variants, and F receives struct fields.

Variants

Enum(Vec<V>)

Struct(Fields<F>)

Implementations

impl<V, F> Data<V, F>

pub fn empty_from(src: &Data) -> Data<V, F>

Creates an empty body of the same shape as the passed-in body.

Panics

This function will panic if passed syn::Data::Union.

pub fn try_empty_from(src: &Data) -> Result<Data<V, F>, Error>

Creates an empty body of the same shape as the passed-in body.

darling does not support unions; calling this function with a union body will return an error.

pub fn as_ref(&self) -> Data<&V, &F>

Creates a new Data<&'a V, &'a F> instance from Data<V, F>.

pub fn map_enum_variants<T, U>(self, map: T) -> Data<U, F>

where T: FnMut(V) -> U,

Applies a function V -> U on enum variants, if this is an enum.

pub fn map_struct_fields<T, U>(self, map: T) -> Data<V, U>

where T: FnMut(F) -> U,

Applies a function F -> U on struct fields, if this is a struct.

pub fn map_struct<T, U>(self, map: T) -> Data<V, U>

where T: FnMut(Fields<F>) -> Fields<U>,

Applies a function to the Fields if this is a struct.

pub fn take_struct(self) -> Option<Fields<F>>

Consumes the Data, returning Fields<F> if it was a struct.

pub fn take_enum(self) -> Option<Vec<V>>

Consumes the Data, returning Vec<V> if it was an enum.

pub fn is_enum(&self) -> bool

Returns true if this instance is Data::Enum.

pub fn is_struct(&self) -> bool

Returns true if this instance is Data::Struct.

impl<V, F> Data<V, F>

where V: FromVariant, F: FromField,

pub fn try_from(body: &Data) -> Result<Data<V, F>, Error>

Attempt to convert from a syn::Data instance.

Trait Implementations

impl<V, F> Clone for Data<V, F>

where V: Clone, F: Clone,

fn clone(&self) -> Data<V, F>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<V, F> Debug for Data<V, F>

where V: Debug, F: Debug,

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

Formats the value using the given formatter.

impl<V, F> PartialEq for Data<V, F>

where V: PartialEq, F: PartialEq,

fn eq(&self, other: &Data<V, F>) -> 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<V, F> UsesLifetimes for Data<V, F>

where V: UsesLifetimes, F: UsesLifetimes,

fn uses_lifetimes<'a>( &self, options: &Options, lifetimes: &'a HashSet<Lifetime, BuildHasherDefault<FnvHasher>>, ) -> HashSet<&'a Lifetime, BuildHasherDefault<FnvHasher>>

Returns the subset of the queried lifetimes that are used by the implementing syntax element.

fn uses_lifetimes_cloned( &self, options: &Options, lifetimes: &HashSet<Lifetime, BuildHasherDefault<FnvHasher>>, ) -> HashSet<Lifetime, BuildHasherDefault<FnvHasher>>

Find all used lifetimes, then clone them and return that set.

impl<V, F> UsesTypeParams for Data<V, F>

where V: UsesTypeParams, F: UsesTypeParams,

fn uses_type_params<'a>( &self, options: &Options, type_set: &'a HashSet<Ident, BuildHasherDefault<FnvHasher>>, ) -> HashSet<&'a Ident, BuildHasherDefault<FnvHasher>>

Returns the subset of the queried type parameters that are used by the implementing syntax element.

fn uses_type_params_cloned( &self, options: &Options, type_set: &HashSet<Ident, BuildHasherDefault<FnvHasher>>, ) -> HashSet<Ident, BuildHasherDefault<FnvHasher>>

Find all type params using uses_type_params, then clone the found values and return the set.

impl<V, F> Eq for Data<V, F>

where V: Eq, F: Eq,

impl<V, F> StructuralPartialEq for Data<V, F>