serde_any 0.5.0

Dynamic serialization and deserialization with the format chosen at runtime
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

# Serde Any

Dynamic serialization and deserialization with the format chosen at runtime.
This crate allows you to serialize and deserialize data using [serde](https://serde.rs/) without having to choose the data format up-front.
The format can be either chosen at runtime, inferred from the file name, or guessed by attemting each supported format until one succeeds.

## Supported formats

By default, JSON, YAML, TOML, RON, XML, and URL encoding formats are supported

```
[dependencies]
serde_any = "0.5"
```

The list of supported formats can be controlled via feature flags

```
[dependencies]
serde_any = { version = "0.5", default-features = false, features = ["yaml", "toml"] }
```

## Deserialization

Structs that implement `serde::de::Deserialize` can be deserialized from a given file

```
let m: MyStruct = serde_any::from_file("my_data.json")?;
```

If support for multiple formats is desired, data can be deserialized from a fixed file stem.
The following will look for `my_data.json`, `my_data.yaml`, `my_data.yml`, `my_data.toml`, `my_data.ron`, `my_data.xml`.

```
let m: MyStruct = serde_any::from_file_stem("my_data")?;
```

Deserialization can also be done from a string, a byte array, or a reader, with any format

```
let m1: MyStruct = serde_any::from_str_any(r#"{"name": "value"}"#)?;
let m2: MyStruct = serde_any::from_slice_any(b"name: value")?;
```

The `serde_any` crate also provides similar deserialization function with a fixed format

```
let m1: MyStruct = serde_any::from_str(r#"{"name": "value"}"#, serde_any::Format::Json)?;
let m2: MyStruct = serde_any::from_slice(b"name: value", serde_any::Format::Yaml)?;
let m3: MyStruct = serde_any::from_reader(File::open("some_data_file.toml")?, serde_any::Format::Toml)?;
```

## Serialization

Structs that implement `serde::ser::Serialize` can be serialized into a file

```
    let m = MyStruct { ... };
    serde_any::to_file("my_data.json")?;
```

or to a string, a byte array, or a writer, with a fixed format


```
let m = MyStruct { ... };
let json_string = serde_any::to_string(&m, Format::Json)?;
let yaml_byte_vec = serde_any::to_vec(&m, Format::Yaml)?;

let writer = File::create("some_data_file.toml")?;
serde_any::to_writer(writer, Format::Toml)?;
```

All serialization functions have pretty printing variants with a `_pretty` suffix.

## License

Licensed under either of

 * Apache License, Version 2.0
   ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
 * MIT license
   ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)

at your option.

## Contribution

Unless you explicitly state otherwise, any contribution intentionally submitted
for inclusion in the work by you, as defined in the Apache-2.0 license, shall be
dual licensed as above, without any additional terms or conditions.