Trait ParseAttrs

pub trait ParseAttrs: Default + Parse {
    // Required method
    fn try_merge(self, another: Self) -> Result<Self>;

    // Provided methods
    fn validate(&self, _: &str, _: Span) -> Result<()> { ... }
    fn fallback(&mut self, _: &[Attribute]) -> Result<()> { ... }
    fn parse_attrs<T>(name: &str, item: &T) -> Result<Self>
       where T: Attrs,
             for<'a> &'a T: IntoSpan { ... }
}

Parseing of syn::Attributes into a custom defined struct.

Required Methods

fn try_merge(self, another: Self) -> Result<Self>

Tries to merge two sets of parsed attributes into a single one, reporting about duplicates, if any.

Errors

If merging cannot be performed.

Provided Methods

fn validate(&self, _: &str, _: Span) -> Result<()>

Validates these parsed attributes to meet additional invariants, if required.

The provided string contains name of the parsed syn::Attribute, and the provided Span refers to the item this syn::Attribute is applied to. Use them to make reported errors well descriptive.

Errors

If validation fails.

fn fallback(&mut self, _: &[Attribute]) -> Result<()>

Falls back to another values from syn::Attributes, if required.

Errors

If retrieving fallback values fails.

fn parse_attrs<T>(name: &str, item: &T) -> Result<Self>

where T: Attrs, for<'a> &'a T: IntoSpan,

Parses this structure from the syn::Attributes with the given name and contained in the given item.

If multiple syn::Attributes occur with the same name then they all are parsed separately and then Attrs::try_merged.

If none syn::Attributes occur with the given name then Default value is returned, modulo Attrs::validate.

Errors

• If Parseing of this Attrs fails.
• If either Attrs::try_merge(), Attrs::validate() or Attrs::fallback() fails.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<V: Attrs + Default + Parse> Attrs for Box<V>

fn try_merge(self, another: Self) -> Result<Self>

fn validate(&self, attr_name: &str, item_span: Span) -> Result<()>

fn fallback(&mut self, attrs: &[Attribute]) -> Result<()>

fn parse_attrs<T>(name: &str, item: &T) -> Result<Self>

where T: Attrs, for<'a> &'a T: IntoSpan,

Implementors