| datetime.rs |
|
17282 |
| de.rs |
Deserializing TOML into Rust structures.
This module contains all the Serde support for deserializing TOML documents
into Rust structures. Note that some top-level functions here are also
provided at the top of the crate. |
72977 |
| lib.rs |
A [serde]-compatible [TOML]-parsing library
TOML itself is a simple, ergonomic, and readable configuration format:
```toml
[package]
name = "toml"
version = "0.4.2"
authors = ["Alex Crichton <alex@alexcrichton.com>"]
[dependencies]
serde = "1.0"
```
The TOML format tends to be relatively common throughout the Rust community
for configuration, notably being used by [Cargo], Rust's package manager.
## TOML values
A value in TOML is represented with the [`Value`] enum in this crate:
```rust,ignore
pub enum Value {
String(String),
Integer(i64),
Float(f64),
Boolean(bool),
Datetime(Datetime),
Array(Array),
Table(Table),
}
```
TOML is similar to JSON with the notable addition of a [`Datetime`]
type. In general, TOML and JSON are interchangeable in terms of
formats.
## Parsing TOML
The easiest way to parse a TOML document is via the [`Value`] type:
```rust
use toml::Value;
let value = "foo = 'bar'".parse::<Value>().unwrap();
assert_eq!(value["foo"].as_str(), Some("bar"));
```
The [`Value`] type implements a number of convenience methods and
traits; the example above uses [`FromStr`] to parse a [`str`] into a
[`Value`].
## Deserialization and Serialization
This crate supports [`serde`] 1.0 with a number of
implementations of the `Deserialize`, `Serialize`, `Deserializer`, and
`Serializer` traits. Namely, you'll find:
* `Deserialize for Value`
* `Serialize for Value`
* `Deserialize for Datetime`
* `Serialize for Datetime`
* `Deserializer for de::Deserializer`
* `Serializer for ser::Serializer`
* `Deserializer for Value`
This means that you can use Serde to deserialize/serialize the
[`Value`] type as well as the [`Datetime`] type in this crate. You can also
use the [`Deserializer`], [`Serializer`], or [`Value`] type itself to act as
a deserializer/serializer for arbitrary types.
An example of deserializing with TOML is:
```rust
use serde_derive::Deserialize;
#[derive(Deserialize)]
struct Config {
ip: String,
port: Option<u16>,
keys: Keys,
}
#[derive(Deserialize)]
struct Keys {
github: String,
travis: Option<String>,
}
fn main() {
let config: Config = toml::from_str(r#"
ip = '127.0.0.1'
[keys]
github = 'xxxxxxxxxxxxxxxxx'
travis = 'yyyyyyyyyyyyyyyyy'
"#).unwrap();
assert_eq!(config.ip, "127.0.0.1");
assert_eq!(config.port, None);
assert_eq!(config.keys.github, "xxxxxxxxxxxxxxxxx");
assert_eq!(config.keys.travis.as_ref().unwrap(), "yyyyyyyyyyyyyyyyy");
}
```
You can serialize types in a similar fashion:
```rust
use serde_derive::Serialize;
#[derive(Serialize)]
struct Config {
ip: String,
port: Option<u16>,
keys: Keys,
}
#[derive(Serialize)]
struct Keys {
github: String,
travis: Option<String>,
}
fn main() {
let config = Config {
ip: "127.0.0.1".to_string(),
port: None,
keys: Keys {
github: "xxxxxxxxxxxxxxxxx".to_string(),
travis: Some("yyyyyyyyyyyyyyyyy".to_string()),
},
};
let toml = toml::to_string(&config).unwrap();
}
```
[TOML]: https://github.com/toml-lang/toml
[Cargo]: https://crates.io/
[`serde`]: https://serde.rs/
[serde]: https://serde.rs/ |
4628 |
| macros.rs |
|
20727 |
| map.rs |
A map of String to toml::Value.
By default the map is backed by a [`BTreeMap`]. Enable the `preserve_order`
feature of toml-rs to use [`LinkedHashMap`] instead.
[`BTreeMap`]: https://doc.rust-lang.org/std/collections/struct.BTreeMap.html
[`LinkedHashMap`]: https://docs.rs/linked-hash-map/*/linked_hash_map/struct.LinkedHashMap.html |
16550 |
| ser.rs |
Serializing Rust structures into TOML.
This module contains all the Serde support for serializing Rust structures
into TOML documents (as strings). Note that some top-level functions here
are also provided at the top of the crate.
Note that the TOML format has a restriction that if a table itself contains
tables, all keys with non-table values must be emitted first. This is
typically easy to ensure happens when you're defining a `struct` as you can
reorder the fields manually, but when working with maps (such as `BTreeMap`
or `HashMap`) this can lead to serialization errors. In those situations you
may use the `tables_last` function in this module like so:
```rust
# use serde_derive::Serialize;
# use std::collections::HashMap;
#[derive(Serialize)]
struct Manifest {
package: Package,
#[serde(serialize_with = "toml::ser::tables_last")]
dependencies: HashMap<String, Dependency>,
}
# type Package = String;
# type Dependency = String;
# fn main() {}
``` |
53694 |
| spanned.rs |
|
4327 |
| tokens.rs |
|
23744 |
| value.rs |
Definition of a TOML value |
31018 |