nested-struct 0.1.0

Create nested structs using a macro
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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

# Nested Struct

Ever wanted to be able to create a data structure that contains nested
data? Do you find yourself creating many individual structs simply to
combine them together? Well, this is the library for you!

Transform this

```rust
pub struct MyStruct {
    pub data: MyStructData,
}

pub struct MyStructData {
    pub data: u32
}
```

Into this

```rust
use nested_struct::*;

nested_struct! {
    pub struct MyStruct {
        pub data: MyStructData {
            pub data: u32
        }
    }
}
```

### Basic usage

Creates a new struct that may feature nested fields.

```rust
use nested_struct::*;

nested_struct! {
    pub struct MyStruct {
        pub regular_field: u32,
        pub nested_field: NestedField {
            pub inner_field: bool
        }
    }
}

let _ = MyStruct {
    regular_field: 123,
    nested_field: NestedField {
        inner_field: true,
    },
};
```

### Deeply-nested structs

Nesting is not limited to a single level. You can generate structs with multi-nested fields:

```rust
use nested_struct::*;

nested_struct! {
    pub struct MyStruct {
        pub nested_field: NestedField {
            pub nested_field: DeeperNestedField {
                pub inner_field: bool
            }
        }
    }
}

let _ = MyStruct {
    nested_field: NestedField {
        nested_field: DeeperNestedField {
            inner_field: true,
        }
    },
};
```

### Applying field attributes to fields that are nested structs

Like with a normal struct, nested fields can have attributes placed on them:

```rust
use nested_struct::*;

nested_struct! {
    pub struct MyStruct {
        pub regular_field: u32,

        #[doc = "my nested field"]
        pub nested_field: NestedField {
            pub inner_field: bool
        }
    }
}
```

### Applying struct-level attributes to nested structs

If you want to apply attributes on the generated, nested struct, you need to
use the `@nested` marker. This can be used multiple times, but must occur AFTER
any field-specific attributes:

```rust
use nested_struct::*;

nested_struct! {
    pub struct MyStruct {
        pub regular_field: u32,

        #[doc = "my nested field"]
        @nested(#[derive(Clone)])
        pub nested_field: NestedField {
            pub inner_field: bool
        }
    }
}

let nested_field = NestedField { inner_field: true };
let _ = MyStruct {
    regular_field: 123,
    nested_field: nested_field.clone(),
};
```

## License

This project is licensed under either of

Apache License, Version 2.0, (LICENSE-APACHE or
[apache-license][apache-license]) MIT license (LICENSE-MIT or
[mit-license][mit-license]) at your option.

[apache-license]: http://www.apache.org/licenses/LICENSE-2.0
[mit-license]: http://opensource.org/licenses/MIT