Rust-Property

Generate several common methods for structs automatically.

Usage

• Apply the derive proc-macro #[derive(Property)] to structs, and use #[property(..)] to configure it.

  There are three kinds of configurable attributes: get, set, mut.

• Set container attributes can change the default settings for all fields.

• Change the settings of a single field via setting field attributes.

• The visibility of a method can be set via #[property(get(visibility-type))]

  There are four kinds of the visibility type: disable, public, crate (default for all methods), and private.

• The method name can be set in two ways:

  1. Assign a complete name via #[property(get(name = "method-name"))].

  2. Set prefix and / or suffix via #[property(set(prefix = "set_"), mut(suffix = "mut_"))].

  The default setting for all fields is: #[property(get(prefix = "", suffix = ""), set(prefix = "set_"), mut(prefix = "mut_"))].

• The return type of get method can be set via #[property(get(type = "return-type"))].

  There are three kinds of the return type: ref (default in most cases), clone and copy.

• The input type of set method can be set via #[property(set(type = "input-type"))].

  There are three kinds of the input type: ref (default) and own.

In Action

Original Code

use property::Property;

#[derive(Copy, Clone)]
pub enum Species {
    Dog,
    Cat,
    Bird,
    Other,
}

#[derive(Property)]
#[property(get(public), set(private), mut(disable))]
pub struct Pet {
    #[property(get(name = "identification"), set(disable))]
    id: [u8; 32],
    name: String,
    #[property(set(crate, type = "own"))]
    age: u32,
    #[property(get(type = "copy"))]
    species: Species,
    #[property(get(prefix = "is_"))]
    died: bool,
    #[property(get(type = "clone"))]
    owner: String,
    family_members: Vec<String>,
    #[property(get(type = "ref"), mut(crate))]
    info: String,
    #[property(mut(public, suffix = "_mut"))]
    note: Option<String>,
}

Generated Code

impl Pet {
    #[inline(always)]
    pub fn identification(&self) -> &[u8] {
        &self.id[..]
    }
    #[inline(always)]
    pub fn name(&self) -> &str {
        &self.name[..]
    }
    #[inline(always)]
    fn set_name<T: Into<String>>(&mut self, val: T) -> &mut Self {
        self.name = val.into();
        self
    }
    #[inline(always)]
    pub fn age(&self) -> u32 {
        self.age
    }
    #[inline(always)]
    pub(crate) fn set_age<T: Into<u32>>(mut self, val: T) -> Self {
        self.age = val.into();
        self
    }
    #[inline(always)]
    pub fn species(&self) -> Species {
        self.species
    }
    #[inline(always)]
    fn set_species<T: Into<Species>>(&mut self, val: T) -> &mut Self {
        self.species = val.into();
        self
    }
    #[inline(always)]
    pub fn is_died(&self) -> bool {
        self.died
    }
    #[inline(always)]
    fn set_died<T: Into<bool>>(&mut self, val: T) -> &mut Self {
        self.died = val.into();
        self
    }
    #[inline(always)]
    pub fn owner(&self) -> String {
        self.owner.clone()
    }
    #[inline(always)]
    fn set_owner<T: Into<String>>(&mut self, val: T) -> &mut Self {
        self.owner = val.into();
        self
    }
    #[inline(always)]
    pub fn family_members(&self) -> &[String] {
        &self.family_members[..]
    }
    #[inline(always)]
    fn set_family_members<T: Into<String>>(
        &mut self,
        val: impl IntoIterator<Item = T>,
    ) -> &mut Self {
        self.family_members = val.into_iter().map(Into::into).collect();
        self
    }
    #[inline(always)]
    pub fn info(&self) -> &String {
        &self.info
    }
    #[inline(always)]
    fn set_info<T: Into<String>>(&mut self, val: T) -> &mut Self {
        self.info = val.into();
        self
    }
    #[inline(always)]
    pub(crate) fn mut_info(&mut self) -> &mut String {
        &mut self.info
    }
    #[inline(always)]
    pub fn note(&self) -> Option<&String> {
        self.note.as_ref()
    }
    #[inline(always)]
    fn set_note<T: Into<Option<String>>>(&mut self, val: T) -> &mut Self {
        self.note = val.into();
        self
    }
    #[inline(always)]
    pub fn note_mut(&mut self) -> &mut Option<String> {
        &mut self.note
    }
}

Enjoy it!

License

Licensed under either of Apache License, Version 2.0 or MIT License, at your option.