Enum darling::ast::Data

pub enum Data<V, F> {
    Enum(Vec<V, Global>),
    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, Global>)

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.

pub fn as_ref(&'a self) -> Data<&'a V, &'a 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, Global>>

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<Data<V, F>> for Data<V, F> where
    V: PartialEq<V>,
    F: PartialEq<F>, 

fn eq(&self, other: &Data<V, F>) -> bool

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

fn ne(&self, other: &Data<V, F>) -> bool

This method tests for !=.

impl<V, F> UsesLifetimes for Data<V, F> where
    V: UsesLifetimes,
    F: UsesLifetimes, 

fn uses_lifetimes(
    &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(
    &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> StructuralEq for Data<V, F>

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