Guzzle is a Custom Derive that will help you pass a stream of keys and values into a struct.
Derive Guzzle, then use the attribute tags to annotate your struct
```rust use guzzle::Guzzle;
struct GuzzleExample { /// This field is annotated with noguzzle, therefore it will not be parsed by guzzle #[noguzzle] ignored: String,
/// This field is not annotated, so if a key matches the field name, it will set the value
basic: String,
/// This field is annotated, but with no keys, so it uses the field name as a key
/// Currently `#[guzzle]` doesn't do anything different to the default behavior (see
/// above), but in the future the default behaviour may be toggleable.
#[guzzle]
basic_too: String,
/// This field may be filled from multiple keys
#[guzzle(keys = ["one", "two"])]
listed_keys: String,
/// This field is not a string, you must provider a parser that will transform it into
/// the correct type
#[guzzle(parser = u64_parser)]
other_types: u64,
/// This field isn't a string and has multiple keys
#[guzzle(parser = u64_parser, keys = ["three", "four"])]
other_types_with_listed_keys: u64,
/// Guzzle will wire up this field so that data being guzzled by the `GuzzleExample`
/// will first be sent to the `TypeThatAlsoImplementsGuzzle`. If the
/// `TypeThatAlsoImplementsGuzzle` consumes the value, `GuzzleExample` will not.
#[deep_guzzle]
recurse_guzzle_to_populate_this_field: TypeThatAlsoImplementsGuzzle,
}
// This is the deeply nested TypeThatAlsoImplementsGuzzle
struct TypeThatAlsoImplementsGuzzle { /// This struct represents some deeply nested data #[guzzle(keys = ["deepdata"], parser = boolparser)] deeplynesteddata: bool }
// These are the parsers referenced above fn u64parser(s: String) -> u64 { s.parse().unwrap() } fn boolparser(s: String) -> bool { s.parse().unwrap() }
// These are our keys and values let exampledata: Vec<(&str, String)> = vec![ ("basic", "basic info".tostring()), ("basictoo", "more basic info".tostring()), ("one", "1".tostring()), ("two", "2".tostring()), ("othertypes", "20".tostring()), ("three", "3".tostring()), ("four", "4".tostring()), ("ignored", "ignored data".tostring()), ("deepdata", "true".to_string()) ];
// Create our object let mut guzzle_example = GuzzleExample::default();
// Feed our keys and values to our object, capturing any that weren't consumed let remainingdata: Vec<(&str, String)> = exampledata .intoiter() .filtermap(|v| guzzle_example.guzzle(v)) .collect();
// All appropriate fields are now set asserteq!(guzzleexample.basic, "basic info".tostring()); asserteq!(guzzleexample.basictoo, "more basic info".tostring()); asserteq!(guzzleexample.listedkeys, "2".tostring()); asserteq!(guzzleexample.othertypes, 20); asserteq!(guzzleexample.othertypeswithlistedkeys, 4);
// Including the deeply nested field assert!(guzzleexample.recurseguzzletopopulatethisfield.deeplynesteddata);
// Ignored data is left over assert!(guzzleexample.ignored.isempty()); asserteq!(remainingdata, vec![("ignored", "ignored data".to_string())]); ```
This project came out of a need to take Wordpress metadata data and put it into complex Rust structs.