compris 0.0.11

Composite Primitive Schema (CPS) for Rust
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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

use super::{
    super::{annotate::*, normal::*, *},
    errors::*,
    serializer::*,
};

use {
    depiction::*,
    std::{fs::*, io, path},
};

//
// RepresentationWriter
//

/// Either serializes (using [Serializer]) or writes the [Depict].
pub struct RepresentationWriter {
    /// Optional format. When [None] will write a debug depiction.
    format: Option<Format>,

    /// Pretty output (for YAML, JSON, and XML).
    pretty: bool,

    /// Base64 output (for CBOR and MessagePack).
    base64: bool,
}

impl RepresentationWriter {
    /// Constructor.
    pub fn new(format: Option<Format>, pretty: bool, base64: bool) -> Self {
        Self { format, pretty, base64 }
    }

    /// Write to file or stdout.
    pub fn write_to_file_or_stdout<PathT, AnnotatedT>(
        &self,
        variant: &Variant<AnnotatedT>,
        quiet: bool,
        quiet_empty: bool,
        trace: bool,
        path: Option<PathT>,
    ) -> Result<(), SerializeError>
    where
        PathT: AsRef<path::Path>,
        AnnotatedT: Annotated + Clone + Default,
    {
        let format = if trace && let Some(format) = self.format { format.as_str() } else { "debug depiction" };

        if let Some(path) = path {
            let path = path.as_ref();
            if trace {
                tracing::info!("writing {} to file: {}", format, path.display());
            }

            self.write(variant, &mut io::BufWriter::new(File::create(path)?))?;
        } else if quiet {
            if quiet_empty {
                if trace {
                    tracing::info!("writing {} to empty", format);
                }

                self.write(variant, &mut io::empty())?;
            }
        } else if self.is_binary() {
            if trace {
                tracing::info!("writing {} to stdout (raw)", format);
            }

            self.write(variant, &mut io::stdout())?;
        } else {
            if trace {
                tracing::info!("writing {} to stdout", format);
            }

            self.write(variant, &mut anstream::stdout())?;
        }

        Ok(())
    }

    /// Write.
    pub fn write<AnnotatedT, WriteT>(
        &self,
        variant: &Variant<AnnotatedT>,
        mut writer: WriteT,
    ) -> Result<(), SerializeError>
    where
        AnnotatedT: Annotated + Clone + Default,
        WriteT: io::Write,
    {
        match self.format {
            Some(format) => Serializer::new(format)
                .with_pretty(self.pretty)
                .with_base64(self.base64)
                .write_modal(variant, &mut writer),

            None => Ok(if self.pretty {
                variant.write_default_depiction(&mut writer)
            } else {
                variant.write_plain_depiction(&mut writer)
            }?),
        }
    }

    // Don't use anstream::stdout with raw binary.
    fn is_binary(&self) -> bool {
        if let Some(format) = self.format
            && format.is_binary()
            && !self.base64
        {
            true
        } else {
            false
        }
    }
}