Matrix of possible enum helpers and for which enums they can be generated.
```text ------------------------|------|---------|---------|---------| | Enum | TagEnum | RefEnum | MutEnum | ------------------------|------|---------|---------|---------| Can be generated | | X | X | X |
Is Function | X | X | X | X |
------------------------|------|---------|---------|---------|
Unwrap Function | X | | X | X |
------------------------|------|---------|---------|---------|
UnwrapRef Function | X | | | |
------------------------|------|---------|---------|---------|
UnwrapMut Function | X | | | |
------------------------|------|---------|---------|---------|
ToTag Function | X | | X | X |
------------------------|------|---------|---------|---------|
AsRef Function | X | | | |
------------------------|------|---------|---------|---------|
AsMut Function | X | | | |
------------------------|------|---------|---------|---------|
Get | X | | X | X |
------------------------|------|---------|---------|---------|
GetRef | X | | | |
------------------------|------|---------|---------|---------|
GetMut | X | | | |
------------------------|------|---------|---------|---------|
TagEnum, RefEnum and MutEnums are enums itself which can be generated.
The other items are functions which are implemented for the crossed enums.
For example:
rust,ignore
enum MyEnum { Variant1(Type) }
generates code which looks like:
rust,ignore
enum MyEnum { Varaint1(Type), ... }
enum MyEnumTag { Variant1, ... }
enum MyEnumRef<'a> { Variant1(&'a Type), ... }
enum MyEnumMut<'a> { Varaint1(&'a mut Type), ... }
impl MyEnum {
fn isvariant1(&self) -> bool {...} // And other is... functions
fn unwrapvariant1(self) -> Type {...} // And other unwrap functions
fn unwrapmutvariant1(&mut self) -> &mut Type { ... } // And other unwrapmut functions
fn totag(&self) -> MyEnumTag {...}
fn asmut(&self) -> MyEnumMut<'> {...}
fn get_variant1(self) -> Option
impl MyEnumTag { fn isvariant1(self) -> bool {...} // And other is... functions }
impl<'a> MyEnumRef<'a> { fn totag(&self) -> MyEnumTag { ... } fn unwrapvariant1(&self) -> &'a mut Type { ... } // And other unwrap_ functions }
``
generate_enum_helpers works with named and unnnamed variant fields. Also it works with variants having no, a single or multiple fields. In case of multiple fields, the unwrap functions return tuples. Further derive and attribute macros are applied to all generated enums except the TagEnum. Please report any issue on GitHub.
To see what code is generated by this proc macro you could use a command likecargo expand. Fo instance usecargo expand --test named_multifieldto runcargo expand` on a single integration test.