Struct AttributePropertyBoolean

pub struct AttributePropertyBoolean<Marker = AttributePropertyBooleanMarker>(/* private fields */);

A generic boolean attribute property. Defaults to false.

Example

use macro_tools::AttributePropertyBoolean;

#[ derive( Debug, Default, Clone, Copy ) ]
pub struct DebugMarker;

#[ derive( Debug, Default, Clone, Copy ) ]
pub struct EnabledMarker;

pub trait AttributePropertyComponent
{
  const KEYWORD : &'static str;
}

impl AttributePropertyComponent for DebugMarker
{
  const KEYWORD : &'static str = "debug";
}

impl AttributePropertyComponent for EnabledMarker
{
  const KEYWORD : &'static str = "enabled";
}

#[ derive( Debug, Default ) ]
struct MyAttributes
{
  pub debug : AttributePropertyBoolean< DebugMarker >,
  pub enabled : AttributePropertyBoolean< EnabledMarker >,
}

impl syn::parse::Parse for MyAttributes
{
  fn parse( input : syn::parse::ParseStream< '_ > ) -> syn::Result< Self >
  {
    let mut debug = AttributePropertyBoolean::< DebugMarker >::default();
    let mut enabled = AttributePropertyBoolean::< EnabledMarker >::default();

    while !input.is_empty()
    {
      let lookahead = input.lookahead1();
      if lookahead.peek( syn::Ident )
      {
        let ident : syn::Ident = input.parse()?;
        match ident.to_string().as_str()
        {
          DebugMarker::KEYWORD => debug = input.parse()?,
          EnabledMarker::KEYWORD => enabled = input.parse()?,
          _ => return Err( lookahead.error() ),
        }
      }
      else
      {
        return Err( lookahead.error() );
      }

      // Optional comma handling
      if input.peek( syn::Token![,] )
      {
        input.parse::< syn::Token![,] >()?;
      }
    }

    Ok( MyAttributes { debug, enabled } )
  }
}

let input : syn::Attribute = syn::parse_quote!( #[ attribute( enabled = true ) ] );
let meta = match input.meta
{
  syn::Meta::List( meta_list ) => meta_list,
  _ => panic!( "Expected a Meta::List" ),
};

let nested_meta_stream : proc_macro2::TokenStream = meta.tokens;
let attrs : MyAttributes = syn::parse2( nested_meta_stream ).unwrap();
println!( "{:?}", attrs );

In this example, the AttributePropertyBoolean struct is used to define attributes with boolean properties. The DebugMarker and EnabledMarker structs act as markers to distinguish between different boolean attributes. The MyAttributes struct aggregates these boolean attributes.

The Parse implementation for MyAttributes iterates through the attribute’s key-value pairs, identifying each by its marker’s keyword and parsing the boolean value. It uses the ParseStream to parse identifiers and their associated values, matching them to the appropriate marker’s keyword. If an unrecognized identifier is encountered, it returns an error.

The parse_quote! macro is used to create a syn::Attribute instance with the attribute syntax, which is then parsed into the MyAttributes struct. The resulting MyAttributes instance is printed to the console.

Implementations

impl<Marker> AttributePropertyBoolean<Marker>

pub fn internal(self) -> bool

Just unwraps and returns the internal data.

pub fn ref_internal(&self) -> &bool

Returns a reference to the internal boolean value.

Trait Implementations

impl<Marker> AsRef<bool> for AttributePropertyBoolean<Marker>

fn as_ref(&self) -> &bool

Converts this type into a shared reference of the (usually inferred) input type.

impl<Marker, IntoT> Assign<AttributePropertyBoolean<Marker>, IntoT> for AttributePropertyBoolean<Marker>

where IntoT: Into<AttributePropertyBoolean<Marker>>,

fn assign(&mut self, component: IntoT)

Sets or replaces the component on the object with the given value.

fn impute(self, component: IntoT) -> Self

where Self: Sized,

Sets or replaces the component on the object with the given value. Unlike function (assing) function (impute) also consumes self and return it what is useful for builder pattern.

impl<Marker> AttributePropertyComponent for AttributePropertyBoolean<Marker>

where Marker: AttributePropertyComponent,

const KEYWORD: &'static str = Marker::KEYWORD

The keyword that identifies the component.

impl<Marker> Clone for AttributePropertyBoolean<Marker>

where Marker: Clone,

fn clone(&self) -> AttributePropertyBoolean<Marker>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Marker> Debug for AttributePropertyBoolean<Marker>

where Marker: Debug,

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

Formats the value using the given formatter.

impl<Marker> Default for AttributePropertyBoolean<Marker>

where Marker: Default,

fn default() -> AttributePropertyBoolean<Marker>

Returns the “default value” for a type.

impl<Marker> Deref for AttributePropertyBoolean<Marker>

type Target = bool

The resulting type after dereferencing.

fn deref(&self) -> &bool

Dereferences the value.

impl<Marker> From<AttributePropertyBoolean<Marker>> for bool

fn from(src: AttributePropertyBoolean<Marker>) -> bool

Converts to this type from the input type.

impl<Marker> From<bool> for AttributePropertyBoolean<Marker>

fn from(src: bool) -> AttributePropertyBoolean<Marker>

Converts to this type from the input type.

impl<Marker> Parse for AttributePropertyBoolean<Marker>

fn parse( input: &ParseBuffer<'_>, ) -> Result<AttributePropertyBoolean<Marker>, Error>

impl<Marker> Copy for AttributePropertyBoolean<Marker>

where Marker: Copy,