get_set_macro 1.0.0

Procedural macro to generate customizable getters and setters in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

# get_set_macro

[![Crates.io](https://img.shields.io/crates/v/get_set_macro)](https://crates.io/crates/get_set_macro)
[![Docs.rs](https://docs.rs/get_set_macro/badge.svg)](https://docs.rs/get_set_macro)

Procedural macro to automatically generate getters and setters for struct fields in Rust, with fine-grained control over behavior.

## Features

- Generate **getters** that return either **references** or **copies**, depending on your needs.
- Automatically generate **setters** for fields.
- Customize method names for getters and setters.
- Choose to have a getter or setter be not inlined with `noinline`
- Return proper compiler errors instead of panicking.
- Lightweight and minimal dependencies.

---

## Installation

Add the following to your `Cargo.toml`:

```toml
[dependencies]
get_set_macro = "0.1"
```

---

## Usage

Import the macro:

```rust
use get_set_macro::get_set;
```

Apply it to a struct: (see [`tests/ui/ok_readme.rs`](./tests/ui/ok_readme.rs))
```rust
#[get_set]
struct Example {
    #[gsflag(get)]
    name: String,

    #[gsflag(get_copy)]
    age: u32,

    #[gsflag(get(inline_always, rename = "city_ref"), set(rename = "set_city"))]
    city: String,
}

// Has functionality
fn main() {
    let mut example = Example {
        name: "ExampleName".to_string(),
        age: 55,
        city: "ExampleCity".to_string(),
    };

    assert_eq!("ExampleName", example.get_name().as_str());
    assert_eq!(55, example.get_age());
    assert_eq!("ExampleCity", example.city_ref().as_str());

    example.set_city("NewCity".to_string());

    assert_eq!("NewCity", example.city_ref().as_str());
}
```

## Attributes

| Attribute | Description |
|:-|:-|
| `#[get]` | Generate a getter that returns a **reference**. |
| `#[get_copy]` | Generate a getter that returns a **copy**. (Use only with `Copy` types.) |
| `#[set]` | Generate a setter that sets a new value. |
| `rename = "..."` | Customize the method name (e.g., `#[gsflags(get(rename = "fetch_{name}"))]`). |
| `inline(\|_always\|_never)` | Choose to have a getter or setter inlined and how (e.g. `#[gsflags(get(inline_always, rename = "always_inlined_get"))]`). |
| `#[set_get(`struct-wide settings`)]` | Applies get/set settings to all fields in the struct (ignores `rename`). |
| `skip` | Skip `struct`-wide gs-settings for this field. |

> **Note:** Only structs with **named fields** are currently supported.

---

## Limitations

- Only named fields (`struct Foo { x: T }`) are supported — **tuple structs** are not yet supported.

---

## Planned Features

- `#[accessor]` tag on fields (would be the same as `#[gsflags(get, set)]`)
- Default tag(s) -- `#[get_set(all = "get")]` would be equivalent to `#[gsflags(get)]` on every field.

---

## Contributing

Pull requests, issues, and suggestions are welcome!

If you find a bug or would like to request a feature, feel free to open an issue.

---

## License

This project is licensed under the [MIT License](LICENSE).

---

## Acknowledgments

I did this.