serde-libconfigasaurus 0.3.0

Serde serialization and deserialization for libconfig format
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
92
93
94
95
96
97
98
99

//! Basic example showing serialization and deserialization

use serde::{Deserialize, Serialize};
use libconfig::{from_str, to_string};

#[derive(Debug, Serialize, Deserialize, PartialEq)]
struct AppConfig {
    version: String,
    application: Application,
}

#[derive(Debug, Serialize, Deserialize, PartialEq)]
struct Application {
    window: Window,
    constants: Constants,
}

#[derive(Debug, Serialize, Deserialize, PartialEq)]
struct Window {
    title: String,
    size: Size,
    pos: Position,
}

#[derive(Debug, Serialize, Deserialize, PartialEq)]
struct Size {
    w: i32,
    h: i32,
}

#[derive(Debug, Serialize, Deserialize, PartialEq)]
struct Position {
    x: i32,
    y: i32,
}

#[derive(Debug, Serialize, Deserialize, PartialEq)]
struct Constants {
    pi: f64,
    columns: Vec<String>,
}

fn main() {
    // Create a configuration
    let config = AppConfig {
        version: "1.0".to_string(),
        application: Application {
            window: Window {
                title: "My Application".to_string(),
                size: Size { w: 640, h: 480 },
                pos: Position { x: 350, y: 250 },
            },
            constants: Constants {
                pi: 3.141592654,
                columns: vec![
                    "Last Name".to_string(),
                    "First Name".to_string(),
                    "MI".to_string(),
                ],
            },
        },
    };

    // Serialize to libconfig format
    println!("=== Serialization ===");
    let serialized = to_string(&config).expect("Failed to serialize");
    println!("{}", serialized);

    // Deserialize from libconfig format
    println!("\n=== Deserialization ===");
    let libconfig_str = r#"
        version = "1.0";
        application = {
            window = {
                title = "My Application";
                size = { w = 640; h = 480; };
                pos = { x = 350; y = 250; };
            };
            constants = {
                pi = 3.141592654;
                columns = ["Last Name", "First Name", "MI"];
            };
        };
    "#;

    let deserialized: AppConfig = from_str(libconfig_str).expect("Failed to deserialize");
    println!("{:#?}", deserialized);

    // Verify round-trip
    println!("\n=== Round-trip Verification ===");
    let reserialized = to_string(&deserialized).expect("Failed to re-serialize");
    let redeserialized: AppConfig = from_str(&reserialized).expect("Failed to re-deserialize");

    if config == redeserialized {
        println!("Round-trip successful!");
    } else {
        println!("Round-trip failed!");
    }
}