Adding upstream version 1.69.0+dfsg1.upstream/1.69.0+dfsg1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

3 files changed, 146 insertions, 0 deletions

diff --git a/vendor/toml-0.5.9/examples/decode.rs b/vendor/toml-0.5.9/examples/decode.rs
new file mode 100644
index 000000000..256069b35
--- /dev/null
+++ b/vendor/toml-0.5.9/examples/decode.rs
@@ -0,0 +1,54 @@
+//! An example showing off the usage of `Deserialize` to automatically decode
+//! TOML into a Rust `struct`
+
+#![deny(warnings)]
+#![allow(dead_code)]
+
+use serde_derive::Deserialize;
+
+/// This is what we're going to decode into. Each field is optional, meaning
+/// that it doesn't have to be present in TOML.
+#[derive(Debug, Deserialize)]
+struct Config {
+    global_string: Option<String>,
+    global_integer: Option<u64>,
+    server: Option<ServerConfig>,
+    peers: Option<Vec<PeerConfig>>,
+}
+
+/// Sub-structs are decoded from tables, so this will decode from the `[server]`
+/// table.
+///
+/// Again, each field is optional, meaning they don't have to be present.
+#[derive(Debug, Deserialize)]
+struct ServerConfig {
+    ip: Option<String>,
+    port: Option<u64>,
+}
+
+#[derive(Debug, Deserialize)]
+struct PeerConfig {
+    ip: Option<String>,
+    port: Option<u64>,
+}
+
+fn main() {
+    let toml_str = r#"
+        global_string = "test"
+        global_integer = 5
+
+        [server]
+        ip = "127.0.0.1"
+        port = 80
+
+        [[peers]]
+        ip = "127.0.0.1"
+        port = 8080
+
+        [[peers]]
+        ip = "127.0.0.1"
+    "#;
+
+    let decoded: Config = toml::from_str(toml_str).unwrap();
+    println!("{:#?}", decoded);
+}
diff --git a/vendor/toml-0.5.9/examples/enum_external.rs b/vendor/toml-0.5.9/examples/enum_external.rs
new file mode 100644
index 000000000..7de061f61
--- /dev/null
+++ b/vendor/toml-0.5.9/examples/enum_external.rs
@@ -0,0 +1,45 @@
+//! An example showing off the usage of `Deserialize` to automatically decode
+//! TOML into a Rust `struct`, with enums.
+
+#![deny(warnings)]
+#![allow(dead_code)]
+
+use serde_derive::Deserialize;
+
+/// This is what we're going to decode into.
+#[derive(Debug, Deserialize)]
+struct Config {
+    plain: MyEnum,
+    plain_table: MyEnum,
+    tuple: MyEnum,
+    #[serde(rename = "struct")]
+    structv: MyEnum,
+    newtype: MyEnum,
+    my_enum: Vec<MyEnum>,
+}
+
+#[derive(Debug, Deserialize)]
+enum MyEnum {
+    Plain,
+    Tuple(i64, bool),
+    NewType(String),
+    Struct { value: i64 },
+}
+
+fn main() {
+    let toml_str = r#"
+    plain = "Plain"
+    plain_table = { Plain = {} }
+    tuple = { Tuple = { 0 = 123, 1 = true } }
+    struct = { Struct = { value = 123 } }
+    newtype = { NewType = "value" }
+    my_enum = [
+        { Plain = {} },
+        { Tuple = { 0 = 123, 1 = true } },
+        { NewType = "value" },
+        { Struct = { value = 123 } }
+    ]"#;
+
+    let decoded: Config = toml::from_str(toml_str).unwrap();
+    println!("{:#?}", decoded);
+}
diff --git a/vendor/toml-0.5.9/examples/toml2json.rs b/vendor/toml-0.5.9/examples/toml2json.rs
new file mode 100644
index 000000000..1b90c9fde
--- /dev/null
+++ b/vendor/toml-0.5.9/examples/toml2json.rs
@@ -0,0 +1,47 @@
+#![deny(warnings)]
+
+use std::env;
+use std::fs::File;
+use std::io;
+use std::io::prelude::*;
+
+use serde_json::Value as Json;
+use toml::Value as Toml;
+
+fn main() {
+    let mut args = env::args();
+    let mut input = String::new();
+    if args.len() > 1 {
+        let name = args.nth(1).unwrap();
+        File::open(&name)
+            .and_then(|mut f| f.read_to_string(&mut input))
+            .unwrap();
+    } else {
+        io::stdin().read_to_string(&mut input).unwrap();
+    }
+
+    match input.parse() {
+        Ok(toml) => {
+            let json = convert(toml);
+            println!("{}", serde_json::to_string_pretty(&json).unwrap());
+        }
+        Err(error) => println!("failed to parse TOML: {}", error),
+    }
+}
+
+fn convert(toml: Toml) -> Json {
+    match toml {
+        Toml::String(s) => Json::String(s),
+        Toml::Integer(i) => Json::Number(i.into()),
+        Toml::Float(f) => {
+            let n = serde_json::Number::from_f64(f).expect("float infinite and nan not allowed");
+            Json::Number(n)
+        }
+        Toml::Boolean(b) => Json::Bool(b),
+        Toml::Array(arr) => Json::Array(arr.into_iter().map(convert).collect()),
+        Toml::Table(table) => {
+            Json::Object(table.into_iter().map(|(k, v)| (k, convert(v))).collect())
+        }
+        Toml::Datetime(dt) => Json::String(dt.to_string()),
+    }
+}