sequent 0.3.0

A library for interactive discrete-event simulation.
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

//! Persistence extensions for working with YAML files.

use crate::persistence::{
    check_ext, read, write, IntoInner, PersistentScenario, ReadScenarioError, WriteScenarioError,
};
use crate::{Decoder, Scenario};
use serde::{Deserialize, Serialize};
use std::fmt::{Debug, Formatter};
use std::fs::File;
use std::io::{BufReader, BufWriter, Write};
use std::path::Path;
use std::str::FromStr;

const EXT: &str = "yaml";

/// A container for de/serializing arbitrary types from/into YAML.
pub struct Carrier<T>(T);

impl<T: PartialEq> PartialEq for Carrier<T> {
    fn eq(&self, other: &Self) -> bool {
        self.0 == other.0
    }
}

impl<T: Debug> Debug for Carrier<T> {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "Carrier({:?})", self.0)
    }
}

impl<T> From<T> for Carrier<T> {
    fn from(value: T) -> Self {
        Self(value)
    }
}

/// Serializes the content of a [`Carrier`] to its YAML representation.
impl<T: Serialize> ToString for Carrier<T> {
    fn to_string(&self) -> String {
        serde_yaml::to_string(&self.0).unwrap()
    }
}

/// Populates the contents of a new [`Carrier`] from a YAML string.
impl<T> FromStr for Carrier<T>
where
    for<'a> T: Deserialize<'a>,
{
    type Err = serde_yaml::Error;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let value: T = serde_yaml::from_str(s)?;
        Ok(Self(value))
    }
}

impl<T> IntoInner<T> for Carrier<T> {
    fn into_inner(self) -> T {
        self.0
    }
}

/// Reads and decodes a scenario from a given YAML file.
///
/// # Errors
/// [`ReadScenarioError`] if the scenario could not be read.
pub fn read_from_file<S>(
    decoder: &Decoder<S>,
    path: impl AsRef<Path>,
) -> Result<Scenario<S>, ReadScenarioError>
where
    for<'de> S: Deserialize<'de>,
{
    check_ext(path.as_ref(), EXT)?;
    let mut r = BufReader::new(File::open(&path)?);
    read::<Carrier<PersistentScenario<S>>, _, _>(decoder, &mut r)
}

/// Writs a scenario to a YAML file.
///
/// # Errors
/// [`WriteScenarioError`] if the scenario could not be written.
pub fn write_to_file<S: Clone + Serialize>(
    scenario: &Scenario<S>,
    path: impl AsRef<Path>,
) -> Result<(), WriteScenarioError> {
    check_ext(path.as_ref(), EXT)?;
    let mut w = BufWriter::new(File::create(&path)?);
    write::<Carrier<PersistentScenario<S>>, _>(scenario, &mut w)?;
    w.flush()?;
    Ok(())
}

#[cfg(test)]
mod tests;