Struct OuterFrom

pub struct OuterFrom {
    pub ident: Option<Ident>,
    pub attrs: Option<AttrsField>,
    pub container: Core,
    pub attr_names: PathList,
    pub forward_attrs: Option<ForwardAttrsFilter>,
    pub from_ident: bool,
}

Reusable base for FromDeriveInput, FromVariant, FromField, and other top-level From* traits.

Fields

ident: Option<Ident>

The field on the target struct which should receive the type identifier, if any.

attrs: Option<AttrsField>

The field on the target struct which should receive the type attributes, if any.

container: Core

attr_names: PathList

The attribute names that should be searched.

forward_attrs: Option<ForwardAttrsFilter>

The attribute names that should be forwarded. The presence of the word with no additional filtering will cause all attributes to be cloned and exposed to the struct after parsing.

from_ident: bool

Whether or not the container can be made through conversion from the type Ident.

Implementations

impl OuterFrom

pub fn start(di: &DeriveInput) -> Result<Self>

pub fn as_forward_attrs(&self) -> ForwardAttrs<'_>

Trait Implementations

impl Clone for OuterFrom

fn clone(&self) -> OuterFrom

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for OuterFrom

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

Formats the value using the given formatter.

impl ParseAttribute for OuterFrom

fn parse_nested(&mut self, mi: &Meta) -> Result<()>

Read a meta-item, and apply its values to the current instance.

fn parse_attributes(self, attrs: &[Attribute]) -> Result<Self>

impl ParseData for OuterFrom

fn parse_field(&mut self, field: &Field) -> Result<()>

Apply the next found struct field to the object, returning an error if parsing goes wrong.

fn validate_body(&self, errors: &mut Accumulator)

Perform validation checks that require data from more than one field or variant. The default implementation does no validations. Implementors can override this method as appropriate for their use-case.

fn parse_body(self, body: &Data) -> Result<Self>

fn parse_variant(&mut self, variant: &Variant) -> Result<()>

Apply the next found variant to the object, returning an error if parsing goes wrong.