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

use std::fs::File;
use std::io::{Read, Write};
use std::path::Path;
use serde::{Deserialize, Serialize};
use toml;

use {Result, Error};

/// Converts from the TOML file to a value of `T` type.
pub fn from_toml_file<T, P>(path: P) -> Result<T>
where
    T: for<'a> Deserialize<'a>,
    P: AsRef<Path>,
{
    let f = track!(File::open(path).map_err(Error::from))?;
    track!(from_toml_reader(f))
}

/// Reads a TOML string from the reader and converts it to a value of `T` type.
pub fn from_toml_reader<T, R>(mut reader: R) -> Result<T>
where
    T: for<'a> Deserialize<'a>,
    R: Read,
{
    let mut toml = String::new();
    track!(reader.read_to_string(&mut toml).map_err(Error::from))?;
    track!(from_toml_str(&toml))
}

/// Converts from the TOML string to a value of `T` type.
///
/// # Examples
///
/// ```
/// extern crate serde;
/// #[macro_use]
/// extern crate serde_derive;
/// extern crate serdeconv;
///
/// // Defines a deserializable struct.
/// #[derive(Deserialize)]
/// struct Foo {
///     bar: String,
///     baz: usize
/// }
///
/// # fn main() {
/// // Converts from the TOML string to a `Foo` value.
/// let toml = r#"
/// bar = "aaa"
/// baz = 123
/// "#;
/// let foo: Foo = serdeconv::from_toml_str(toml).unwrap();
/// assert_eq!(foo.bar, "aaa");
/// assert_eq!(foo.baz, 123);
/// # }
/// ```
pub fn from_toml_str<'a, T>(toml: &'a str) -> Result<T>
where
    T: Deserialize<'a>,
{
    let value = track!(toml::from_str(toml).map_err(Error::from))?;
    Ok(value)
}

/// Converts from the TOML bytes to a value of `T` type.
pub fn from_toml_slice<'a, T>(toml: &'a [u8]) -> Result<T>
where
    T: Deserialize<'a>,
{
    let value = track!(toml::from_slice(toml).map_err(Error::from))?;
    Ok(value)
}

/// Converts the value to a TOML string and writes it to the speficied file.
pub fn to_toml_file<T, P>(value: &T, path: P) -> Result<()>
where
    T: ?Sized + Serialize,
    P: AsRef<Path>,
{
    let f = track!(File::create(path).map_err(Error::from))?;
    track!(to_toml_writer(value, f))
}

/// Converts the value to a TOML string and writes it to the writer.
pub fn to_toml_writer<T, W>(value: &T, mut writer: W) -> Result<()>
where
    T: ?Sized + Serialize,
    W: Write,
{
    let toml = track!(to_toml_string(value).map_err(Error::from))?;
    track!(writer.write_all(toml.as_bytes()).map_err(Error::from))?;
    Ok(())
}

/// Converts the value to a TOML string.
///
/// # Examples
///
/// ```
/// extern crate serde;
/// #[macro_use]
/// extern crate serde_derive;
/// extern crate serdeconv;
///
/// // Defines a serializable struct.
/// #[derive(Serialize)]
/// struct Foo {
///     bar: &'static str,
///     baz: usize
/// }
///
/// # fn main() {
/// // Converts the `Foo` value to a TOML string.
/// let foo = Foo { bar: "aaa", baz: 123 };
/// let toml = serdeconv::to_toml_string(&foo).unwrap();
/// assert_eq!(toml, "\
/// bar = \"aaa\"
/// baz = 123
/// ");
/// # }
/// ```
pub fn to_toml_string<T>(value: &T) -> Result<String>
where
    T: ?Sized + Serialize,
{
    let toml = track!(toml::to_string(value).map_err(Error::from))?;
    Ok(toml)
}