getset

To use getset, derive the desired trait (e.g., Getters, Setters, MutGetters) on your struct and use the #[getset(...)] attribute on specific fields to control which accessors are generated and their visibility.

Field-level attributes take precedence over struct-level attributes. You can specify visibility (e.g., pub) directly within the attribute.

Common attribute options:

• get: Generates a reference getter.
• set: Generates a mutable setter returning &mut Self.
• get_mut: Generates a mutable reference getter.
• set_with: Generates a with_ style setter returning Self.
• get_copy: Generates a getter that returns the value by copy.
• get_clone: Generates a getter that returns the value by cloning (useful for Arc).
• skip: Prevents generation for a specific field, even if the struct has a general attribute.

use std::sync::Arc;
use getset::{Getters, Setters, WithSetters, MutGetters, CopyGetters, CloneGetters};

#[derive(Getters, Setters, WithSetters, MutGetters, CopyGetters, CloneGetters, Default)]
pub struct Foo<T>
where
    T: Copy + Clone + Default,
{
    #[getset(get, set, get_mut, set_with)]
    private: T,

    #[getset(get_copy = "pub", set = "pub", get_mut = "pub", set_with = "pub")]
    public: T,

    #[getset(get_clone = "pub", set = "pub", get_mut = "pub", set_with = "pub")]
    arc: Arc<u16>,
}

You can control how methods are generated using attributes at both the struct and field levels.

Struct-level Configuration

Attributes applied to the struct apply to all fields. You can use #[getset(skip)] to prevent a field from having any generated methods.

Field-level Configuration

• Visibility: Specify visibility for a specific method: #[getset(get = "pub")].
• Prefixing: Use with_prefix to add a get_ prefix to the generated method name: #[getset(get = "pub with_prefix")] results in pub fn get_field(&self) -> &T.
• Skipping: Use #[getset(skip)] to opt-out a field from the macro's generation, allowing you to implement custom logic manually.

Unary Structs (Tuple Structs)

For a tuple struct with exactly one field, the macros generate methods named after the macro type (e.g., get(), set(), get_mut()) rather than a field name.

// Prefixing example
#[derive(Getters)]
pub struct Foo {
    #[getset(get = "pub with_prefix")]
    field: bool,
}
// Generates: pub fn get_field(&self) -> &bool

// Skipping example
#[derive(CopyGetters, Setters, WithSetters)]
#[getset(get_copy, set, set_with)]
pub struct Foo {
    #[getset(skip)]
    skipped: String,
    field1: usize,
}

// Unary struct example
#[derive(Setters, Getters, MutGetters)]
struct UnaryTuple(#[getset(set, get, get_mut)] i32);

let mut tup = UnaryTuple(42);
assert_eq!(tup.get(), &42);

The getset crate provides procedural macros to automatically generate basic getters and setters for struct fields. This reduces boilerplate for simple data access patterns.

Supported Macro Types

• Getters: Generates fn field(&self) -> &T.
• MutGetters: Generates fn field(&mut self) -> &mut T.
• Setters: Generates fn field(&mut self, val: T) -> &mut Self (builder-style).
• WithSetters: Generates fn field(mut self, val: T) -> Self (consuming builder-style).
• CopyGetters: Generates fn field(&self) -> T (requires T: Copy).
• CloneGetters: Generates fn field(&self) -> T (requires T: Clone, useful for Arc<T>).

Visibility and Customization

By default, generated methods use the field's visibility. You can override this using the #[getset(... = "visibility")] syntax (e.g., pub, private).

Field-level attributes take precedence over struct-level attributes.

use getset::{Getters, Setters, MutGetters, WithSetters, CopyGetters, CloneGetters};

#[derive(Getters, Setters, MutGetters, WithSetters, CopyGetters, CloneGetters)]
pub struct Foo {
    #[getset(get = "pub", set = "pub")]
    public_field: i32,

    #[getset(get_copy)]
    private_copy_field: u8,
}