Struct Core

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

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.

post_transform: Option<PostfixTransform>

A transform which will be called on darling::Result<Self>. It must either be an FnOnce(T) -> T when map is used, or FnOnce(T) -> darling::Result<T> when and_then is used.

map and and_then are mutually-exclusive to avoid confusion about the order in which the two are applied.

data: Data<InputVariant, InputField>

The body of the deriving type.

bound: Option<Vec<WherePredicate>>

The custom bound to apply to the generated impl

allow_unknown_fields: Option<bool>

Whether or not unknown fields should produce an error at compilation time.

Implementations

impl Core

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

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

fn as_codegen_default(&self) -> Option<DefaultExpression<'_>>

Trait Implementations

impl Clone for Core

fn clone(&self) -> Core

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Core

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

Formats the value using the given formatter.

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

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

Converts to this type from the input type.

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