This crate provides Arraygen derive macro for structs, which generates methods returning arrays filled with the selected struct fields.
```rust
struct Person { #[inarray(getnames)] firstname: String, #[inarray(getnames)] lastname: String, }
let mut person = Person { firstname: "Ada".into(), lastname: "Lovelace".into() }; for name in person.getnames().itermut() { **name = name.to_lowercase(); }
asserteq!(format!("{:?}", person), "Person { firstname: \"ada\", last_name: \"lovelace\" }"); // PASSES ! ```
As you can see above, the attribute gen_array generates a new method returning an array of the given type. And the attribute in_array selects those struct fields to be used by that method.
What Arraygen does under the hood is simmply generating the following impl:
rust
impl Person {
#[inline(always)]
fn get_names(&mut self) -> [&mut String; 2] {
[&mut self.first_name, &mut self.last_name]
}
}
gen_arrayFor generating an Arraygen method you have to use the attribute gen_array on top of the struct, indicating the method name.
```rust
struct Foo {...} ```
In the code above, the struct Foo would have a new method with the following signature: fn get_strings(&self) -> [&Strings; ?] {...}.
in_arrayIn order to fill your Arraygen methods with struct fields, you have to use the attribute in_array in each struct field you want to select.
```rust // inside a struct
name: String
```
You have to match the method name used in gen_array and in in_array in order to include those fields in the generated method.
For more information, check the documentation page.
There are not particular limitations, really. You can use this derive to return Copy objects, Trait objects, and basically any kind of object that can be a struct member.
Also, notice that there are no dynamic memory allocations involved.
The only drawback would be a little impact in compilation times.
I'm open to change the syntax for the 1.0 version. Participate in the issue Syntax propolsas to give your opinion on this matter.
This crate is heavily inspired by GettersByType which is another derive that allows you to do the same thing. But that one is more opinionated, less flexible and less powerful, with the only advantage of being less verbose.
MIT