enpow 2.0.3

Generating methods for user defined enums as known from Option<T> or Result<T, E>
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

### Configuration

The helper attribute `inner` is used to configure the main macros `expand` and `enpow`. For this, `inner` can be attached to both the enum itself and to individual variants. However, it has to be placed after each main macro it should be effective for. An `inner` macro placed after multiple main macros will be effective for each one of them.

#### Derives

The argument `derive()` enables to add auto trait derives to the automatically generated types. The position of the attribute decides on whether the given traits are implemented for all variant types or just for the selected ones.

> ℹ️ `Ref` structs always automatically derive `Clone` and `Copy`, while `Mut` structs are prohibited from deriving these traits. This exclusion will be handled automatically by the macro.

```rust
# use enpow::{enpow, extract};
#
#[extract(Unit, Single, Unnamed)]
#[enpow(UnwrapVar, VarAsRef)]
#[inner(derive(Debug, PartialEq))]
enum IpAddress {
    None,
    V4(u8, u8, u8, u8),
    V6(String),
    #[inner(derive(Clone))]
    Multi {
        v4: (u8, u8, u8, u8),
        v6: String,
    },
}

// Using PartialEq, Debug, and Clone derive
assert_eq!(
    IpAddress::Multi { v4: (0, 0, 0, 0), v6: "::".into() }.unwrap_multi(),
    IpAddressMulti { v4: (0, 0, 0, 0), v6: "::".into() }.clone()
);

// Using automatic Copy derive on Ref struct
let ip = IpAddress::Multi { v4: (0, 0, 0, 0), v6: "::".into() };
let copy = ip.unwrap_multi_as_ref();
let another_copy = copy;
assert_eq!(copy, IpAddressMultiRef { v4: &(0, 0, 0, 0), v6: &"::".into() });
assert_eq!(another_copy, IpAddressMultiRef { v4: &(0, 0, 0, 0), v6: &"::".into() });
```

#### Type Names

With the argument `type_name` or `type_names`, the standard way of naming the generated structs can be changed. There are multiple naming schemes possible, depending on the keyword or string literal provided:

* `type_name=EnumVar` \[default\] will give each type the name of the enum followed by the name of the corresponding variant, e.g. `IpAddressMulti`
* `type_name=Var` will let each type be named just like its corresponding variant, e.g. `Multi`
* `type_name=VarEnum` will give each type the name of the corresponding variant followed by the name of the enum, e.g. `MultiIpAddress`
* `type_name="My{enum}Var{var}"` will give each type the specified name with occurences of `{enum}` and `{var}` replaced by the name of the enum and the name of the corresponding variant, e.g. `MyIpAddressMulti`

This example generates the types `IpNone`, `IpV4`, `IpV6`, and `IpV4_6`.

```rust
# use enpow::{enpow, extract};

#[extract(All)]
#[enpow(UnwrapVar)]
#[inner(type_names="Ip{var}", derive(Debug, PartialEq))]
#[derive(Debug, PartialEq)]
enum IpAddress {
    None,
    V4(u8, u8, u8, u8),
    V6(String),
    #[inner(type_name="IpV4_6")]
    Multi {
        v4: (u8, u8, u8, u8),
        v6: String,
    },
}

assert_eq!(IpAddress::from(IpNone).unwrap_none(), IpNone);
assert_eq!(IpAddress::from(IpV4(192, 168, 0, 1)).unwrap_v4(), IpV4(192, 168, 0, 1));
assert_eq!(IpAddress::from(IpV6("::1".into())).unwrap_v6(), IpV6("::1".into()));
assert_eq!(
    IpAddress::from(IpV4_6 { v4: (0, 0, 0, 0), v6: "::1".into() }).unwrap_multi(),
    IpV4_6 { v4: (0, 0, 0, 0), v6: "::1".into() }
);
```