getters3 0.1.1

Generate getters, mutable getters, setters, and copy accessors for structs and enums
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
116
117

# Getters3

Note: **fork** of Getters2 (unmaintained)

Getters3 is the *real* best "auto-getters"/"auto-setters" crate for Rust.

* Selectable immutable/mutable/clone/deref getters
* Support for named, tuple, and newtype structs
* Support for named, tuple, and newtype *enums*

- [Getters2](#getters2)
  - [Installation](#installation)
  - [Examples](#examples)
    - [Structs](#structs)
    - [Enums](#enums)
  - [Prior Art](#prior-art)

## Installation

```sh
cargo add getters2
```

or, add it to `Cargo.toml`

```toml
[dependencies]
getters2 = "0.1.0"
```


## Examples

Getters2 has a dead simple API.

### Structs

```rust
use getters2::Getters;
#[derive(Getters)]
#[getters(mutable, clone, deref)]
struct Vector3 {
   x: f32,
   y: f32,
   z: f32,
   #[getters(skip, skip_mutable, skip_clone, skip_deref)]
   name: String,
}

let mut v = Vector3 { x: 1.0, y: 2.0, z: 3.0, name: "MyVec".to_string() };
assert_eq!(v.x_ref(), &1.0);
assert_eq!(v.y_ref(), &2.0);
assert_eq!(v.z_ref(), &3.0);
assert_eq!(v.x_deref(), 1.0);
assert_eq!(v.y_deref(), 2.0);
assert_eq!(v.z_deref(), 3.0);
assert_eq!(v.x_clone(), 1.0);
assert_eq!(v.y_clone(), 2.0);
assert_eq!(v.z_clone(), 3.0);
*v.x_mut() = 4.0;
*v.y_mut() = 5.0;
*v.z_mut() = 6.0;
assert_eq!(v.x_ref(), &4.0);
assert_eq!(v.y_ref(), &5.0);
assert_eq!(v.z_ref(), &6.0);
```

### Enums

```rust
use getters2::Getters;
#[derive(Getters)]
#[getters(deref, clone, mutable)]
enum Animal {
   Dog { name: String, age: u8 },
   Cat { name: String, age: u8 },
}
let mut dog = Animal::Dog { name: "Rover".to_string(), age: 5 };
let mut cat = Animal::Cat { name: "Mittens".to_string(), age: 3 };
assert_eq!(dog.dog_name_ref(), Some(&"Rover".to_string()));
assert_eq!(dog.dog_name_deref(), Some("Rover".to_string()));
assert_eq!(dog.dog_name_clone(), Some("Rover".to_string()));
assert_eq!(dog.dog_age_ref(), Some(&5));
assert_eq!(dog.dog_age_deref(), Some(5));
assert_eq!(dog.dog_age_clone(), Some(5));

let Some(dog_name) = dog.dog_name_mut() else {
   panic!("Expected Some");
};
*dog_name = "Spot".to_string();

assert_eq!(dog.dog_name_ref(), Some(&"Spot".to_string()));

assert_eq!(cat.cat_name_ref(), Some(&"Mittens".to_string()));
assert_eq!(cat.cat_name_deref(), Some("Mittens".to_string()));
assert_eq!(cat.cat_name_clone(), Some("Mittens".to_string()));
assert_eq!(cat.cat_age_ref(), Some(&3));
assert_eq!(cat.cat_age_deref(), Some(3));
assert_eq!(cat.cat_age_clone(), Some(3));

let Some(cat_name) = cat.cat_name_mut() else {
  panic!("Expected Some");
};
*cat_name = "Whiskers".to_string();

assert_eq!(cat.cat_name_ref(), Some(&"Whiskers".to_string()));
```


## Prior Art

There are a lot of crates that claim to do this. Getters2 has something they all don't.

* [accessors](https://crates.io/crates/accessors) - Unmaintained
* [accessors-rs](https://crates.io/crates/accessors-rs) - Doesn't support Enums
* [getters](https://crates.io/crates/getters) - Yanked
* [derive-getters](https://crates.io/crates/derive-getters) - Doesn't support enums