multiio 0.2.3

A unified I/O orchestration library for CLI/server applications
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

use std::sync::Arc;

use crate::format::FormatKind;
use crate::io::{InputProvider, OutputTarget};

#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum FileExistsPolicy {
    /// Overwrite existing files
    Overwrite,
    /// Append to existing files
    Append,
    #[default]
    /// Return an error if file exists
    Error,
}

impl std::str::FromStr for FileExistsPolicy {
    type Err = ();

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let policy = match s.to_ascii_lowercase().as_str() {
            "overwrite" => FileExistsPolicy::Overwrite,
            "append" => FileExistsPolicy::Append,
            "error" => FileExistsPolicy::Error,
            _ => return Err(()),
        };
        Ok(policy)
    }
}

#[derive(Debug, Clone)]
pub struct InputSpec {
    /// Raw input argument or configuration string
    pub raw: String,
    /// The input provider implementation
    pub provider: Arc<dyn InputProvider>,
    /// Explicitly specified format (if any)
    pub explicit_format: Option<FormatKind>,
    /// Candidate formats to try (in order)
    pub format_candidates: Vec<FormatKind>,
}

impl InputSpec {
    pub fn new(raw: impl Into<String>, provider: Arc<dyn InputProvider>) -> Self {
        Self {
            raw: raw.into(),
            provider,
            explicit_format: None,
            format_candidates: Vec::new(),
        }
    }

    /// Set the explicit format.
    pub fn with_format(mut self, format: FormatKind) -> Self {
        self.explicit_format = Some(format);
        self
    }

    /// Set the format candidates.
    pub fn with_candidates(mut self, candidates: Vec<FormatKind>) -> Self {
        self.format_candidates = candidates;
        self
    }
}

#[derive(Debug, Clone)]
pub struct OutputSpec {
    /// Raw output argument or configuration string
    pub raw: String,
    /// The output target implementation
    pub target: Arc<dyn OutputTarget>,
    /// Explicitly specified format (if any)
    pub explicit_format: Option<FormatKind>,
    /// Candidate formats to try (in order)
    pub format_candidates: Vec<FormatKind>,
    /// Policy for handling existing files
    pub file_exists_policy: FileExistsPolicy,
}

impl OutputSpec {
    pub fn new(raw: impl Into<String>, target: Arc<dyn OutputTarget>) -> Self {
        Self {
            raw: raw.into(),
            target,
            explicit_format: None,
            format_candidates: Vec::new(),
            file_exists_policy: FileExistsPolicy::default(),
        }
    }

    /// Set the explicit format.
    pub fn with_format(mut self, format: FormatKind) -> Self {
        self.explicit_format = Some(format);
        self
    }

    /// Set the format candidates.
    pub fn with_candidates(mut self, candidates: Vec<FormatKind>) -> Self {
        self.format_candidates = candidates;
        self
    }

    /// Set the file exists policy.
    pub fn with_file_exists_policy(mut self, policy: FileExistsPolicy) -> Self {
        self.file_exists_policy = policy;
        self
    }
}