Struct darling_core::options::Core

pub struct Core {
    pub ident: Ident,
    pub generics: Generics,
    pub default: Option<DefaultExpression>,
    pub rename_rule: RenameRule,
    pub map: Option<Path>,
    pub data: Data<InputVariant, InputField>,
    pub bound: Option<Vec<WherePredicate>>,
}

A struct or enum which should have FromMeta or FromDeriveInput implementations generated.

Fields

ident: Ident

The type identifier.

generics: Generics

The type's generics. If the type does not use any generics, this will be an empty instance.

default: Option<DefaultExpression>

Controls whether missing properties should cause errors or should be filled by the result of a function call. This can be overridden at the field level.

rename_rule: RenameRule

The rule that should be used to rename all fields/variants in the container.

map: Option<Path>

An infallible function with the signature FnOnce(T) -> T which will be called after the target instance is successfully constructed.

data: Data<InputVariant, InputField>

The body of the deriving type.

bound: Option<Vec<WherePredicate>>

The custom bound to apply to the generated impl

Methods

impl Core

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

Partially initializes Core by reading the identity, generics, and body shape.

Trait Implementations

impl Debug for Core

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

Formats the value using the given formatter.

impl Clone for Core

fn clone(&self) -> Core

Returns a copy of the value.

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

Performs copy-assignment from source.

impl PartialEq for Core

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

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

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

This method tests for !=.

impl Eq for Core

impl ParseAttribute for Core

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 Core

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

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

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>

impl<'a> From<&'a Core> for TraitImpl<'a>

fn from(v: &'a Core) -> Self

Performs the conversion.