ds-rom 0.7.0

Library for extracting/building Nintendo DS ROMs.
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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use std::{
    backtrace::Backtrace,
    fs::{self, File, ReadDir},
    io,
    path::Path,
};

use snafu::Snafu;

#[derive(Debug, Snafu)]
pub enum FileError {
    #[snafu(transparent)]
    Io { source: io::Error },
    #[snafu(display("the file '{path}' was not found:\n{backtrace}"))]
    FileNotFound { path: String, backtrace: Backtrace },
    #[snafu(display("parent directory does not exist for file '{path}':\n{backtrace}"))]
    FileParentNotFound { path: String, backtrace: Backtrace },
    #[snafu(display("the directory '{path}' was not found:\n{backtrace}"))]
    DirNotFound { path: String, backtrace: Backtrace },
    #[snafu(display("failed to read file '{path}', ran out of memory:\n{backtrace}"))]
    FileOutOfMemory { path: String, backtrace: Backtrace },
    #[snafu(display("failed to read file '{path}', ran out of memory:\n{backtrace}"))]
    DirOutOfMemory { path: String, backtrace: Backtrace },
    #[snafu(display("the file '{path}' already exists:\n{backtrace}"))]
    AlreadyExists { path: String, backtrace: Backtrace },
}

/// Wrapper for [`File::open`] with clearer errors.
pub fn open_file<P: AsRef<Path>>(path: P) -> Result<File, FileError> {
    let path = path.as_ref();
    let file = match File::open(path) {
        Ok(file) => file,
        Err(err) => {
            let path = path.to_string_lossy();
            match err.kind() {
                io::ErrorKind::NotFound => return FileNotFoundSnafu { path }.fail(),
                _ => Err(err)?,
            }
        }
    };
    Ok(file)
}

/// Wrapper for [`File::create`] with clearer errors.
pub fn create_file<P: AsRef<Path>>(path: P) -> Result<File, FileError> {
    let path = path.as_ref();
    let file = match File::create(path) {
        Ok(file) => file,
        Err(err) => {
            let path = path.to_string_lossy();
            match err.kind() {
                io::ErrorKind::AlreadyExists => return AlreadyExistsSnafu { path }.fail(),
                io::ErrorKind::NotFound => return FileParentNotFoundSnafu { path }.fail(),
                _ => Err(err)?,
            }
        }
    };
    Ok(file)
}

/// Creates a file using [`create_file`] and its parent directories using [`create_dir_all`].
pub fn create_file_and_dirs<P: AsRef<Path>>(path: P) -> Result<File, FileError> {
    let path = path.as_ref();
    create_dir_all(path.parent().unwrap())?;
    create_file(path)
}

/// Wrapper for [`fs::read`] with clearer errors.
pub fn read_file<P: AsRef<Path>>(path: P) -> Result<Vec<u8>, FileError> {
    let path = path.as_ref();
    let bytes = match fs::read(path) {
        Ok(bytes) => bytes,
        Err(err) => {
            let path = path.to_string_lossy();
            match err.kind() {
                io::ErrorKind::NotFound => return FileNotFoundSnafu { path }.fail(),
                io::ErrorKind::OutOfMemory => return FileOutOfMemorySnafu { path }.fail(),
                _ => todo!(),
            }
        }
    };
    Ok(bytes)
}

/// Wrapper for [`fs::write`] with clearer errors.
pub fn write_file<P: AsRef<Path>, C: AsRef<[u8]>>(path: P, contents: C) -> Result<(), FileError> {
    let path = path.as_ref();
    let contents = contents.as_ref();
    match fs::write(path, contents) {
        Ok(()) => Ok(()),
        Err(err) => {
            let path = path.to_string_lossy();
            match err.kind() {
                io::ErrorKind::AlreadyExists => AlreadyExistsSnafu { path }.fail(),
                _ => Err(err)?,
            }
        }
    }
}

/// Wrapper for [`fs::read_to_string`] with clearer errors.
pub fn read_to_string<P: AsRef<Path>>(path: P) -> Result<String, FileError> {
    let path = path.as_ref();
    let string = match fs::read_to_string(path) {
        Ok(string) => string,
        Err(err) => {
            let path = path.to_string_lossy();
            match err.kind() {
                io::ErrorKind::NotFound => return FileNotFoundSnafu { path }.fail(),
                io::ErrorKind::OutOfMemory => return FileOutOfMemorySnafu { path }.fail(),
                _ => Err(err)?,
            }
        }
    };
    Ok(string)
}

/// Wrapper for [`fs::read_dir`] with clearer errors.
pub fn read_dir<P: AsRef<Path>>(path: P) -> Result<ReadDir, FileError> {
    let path = path.as_ref();
    let dir = match fs::read_dir(path) {
        Ok(dir) => dir,
        Err(err) => {
            let path = path.to_string_lossy();
            match err.kind() {
                io::ErrorKind::NotFound => return DirNotFoundSnafu { path }.fail(),
                io::ErrorKind::OutOfMemory => return DirOutOfMemorySnafu { path }.fail(),
                _ => Err(err)?,
            }
        }
    };
    Ok(dir)
}

/// Wrapper for [`fs::create_dir_all`] with clearer errors.
pub fn create_dir_all<P: AsRef<Path>>(path: P) -> Result<(), FileError> {
    let path = path.as_ref();
    if let Err(err) = fs::create_dir_all(path) {
        let path = path.to_string_lossy();
        match err.kind() {
            io::ErrorKind::NotFound => return DirNotFoundSnafu { path }.fail(),
            _ => Err(err)?,
        }
    }
    Ok(())
}