unfolder 0.0.3

library and executable to unfold a file into a folder and fold a previously unfolded folder into a file
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

use std::fmt::Display;

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum Error {
    IOError(String),
    FlattenFileInputError(String),
    FlattenFileOutputError(String),
    UnflattenFileInputError(String),
    UnflattenFileOutputError(String),
    InvalidIndexError(String),
    MissingIndexError(String),
    UnreadableIndexError(String),
    CorruptedDataError(String),
    ChecksumMismatch(String),
}
impl Display for Error {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(
            f,
            "{}: {}",
            self.variant(),
            match self {
                Self::IOError(e) => e.to_string(),
                Self::FlattenFileInputError(e) => e.to_string(),
                Self::FlattenFileOutputError(e) => e.to_string(),
                Self::UnflattenFileInputError(e) => e.to_string(),
                Self::UnflattenFileOutputError(e) => e.to_string(),
                Self::InvalidIndexError(e) => e.to_string(),
                Self::MissingIndexError(e) => e.to_string(),
                Self::UnreadableIndexError(e) => e.to_string(),
                Self::CorruptedDataError(e) => e.to_string(),
                Self::ChecksumMismatch(e) => e.to_string(),
            }
        )
    }
}

impl Error {
    pub fn variant(&self) -> String {
        match self {
            Error::IOError(_) => "IOError",
            Self::FlattenFileInputError(_) => "FlattenFileInputError",
            Self::FlattenFileOutputError(_) => "FlattenFileOutputError",
            Self::UnflattenFileInputError(_) => "UnflattenFileInputError",
            Self::UnflattenFileOutputError(_) => "UnflattenFileOutputError",
            Self::InvalidIndexError(_) => "InvalidIndexError",
            Self::MissingIndexError(_) => "MissingIndexError",
            Self::UnreadableIndexError(_) => "UnreadableIndexError",
            Self::CorruptedDataError(_) => "CorruptedDataError",
            Self::ChecksumMismatch(_) => "ChecksumMismatch",
       }
        .to_string()
    }
}

impl std::error::Error for Error {}
impl From<std::io::Error> for Error {
    fn from(e: std::io::Error) -> Self {
        Error::IOError(format!("{}", e))
    }
}
impl From<iocore::Error> for Error {
    fn from(e: iocore::Error) -> Self {
        Error::IOError(format!("{}", e))
    }
}
pub type Result<T> = std::result::Result<T, Error>;

#[derive(Debug, Clone)]
pub enum Exit {
    Success,
    Error(Error),
}
impl std::process::Termination for Exit {
    fn report(self) -> std::process::ExitCode {
        match &self {
            Exit::Success => std::process::ExitCode::from(0),
            Exit::Error(error) => {
                eprintln!("{}", error);
                std::process::ExitCode::from(1)
            },
        }
    }
}
impl<T> From<std::result::Result<T, Error>> for Exit {
    fn from(result: std::result::Result<T, Error>) -> Exit {
        match result {
            Ok(_) => Exit::Success,
            Err(e) => Exit::Error(e),
        }
    }
}