Struct darling_core::options::OuterFrom

pub struct OuterFrom {
    pub ident: Option<Ident>,
    pub attrs: Option<Ident>,
    pub container: Core,
    pub attr_names: IdentList,
    pub forward_attrs: Option<ForwardAttrs>,
    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<Ident>

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

container: Core

attr_names: IdentList

The attribute names that should be searched.

forward_attrs: Option<ForwardAttrs>

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.

Methods

impl OuterFrom

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

Trait Implementations

impl Debug for OuterFrom

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

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 PartialEq for OuterFrom

fn eq(&self, __arg_0: &OuterFrom) -> bool

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

fn ne(&self, __arg_0: &OuterFrom) -> bool

This method tests for !=.

impl Eq for OuterFrom

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 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.