singlefile 0.5.0

Dead simple file data manipulation.
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

//! Errors that can occur within `singlefile`.

use thiserror::Error;

use crate::manager::FileMode;

use std::convert::Infallible;
use std::io;

/// An error that can occur within `singlefile`.
#[derive(Debug, Error)]
pub enum Error<FE> {
  /// An error caused by an implementation of [`FileFormat`].
  ///
  /// [`FileFormat`]: crate::format::FileFormat
  #[error("format error: {0}")]
  Format(FE),
  /// An error caused by the filesystem.
  #[error(transparent)]
  Io(#[from] io::Error),
  /// Any other kind of error.
  #[error(transparent)]
  Other(#[from] OtherError)
}

impl From<Error<io::Error>> for io::Error {
  fn from(err: Error<io::Error>) -> Self {
    match err {
      Error::Format(err) | Error::Io(err) => err,
      Error::Other(err) => io::Error::other(err)
    }
  }
}

/// A value that may be an error or a user-generated error.
#[derive(Debug, Error)]
pub enum OrUserError<T, U> {
  /// An error.
  #[error(transparent)]
  Base(T),
  /// A user-generated error.
  #[error("user error: {0}")]
  User(U)
}

impl<T, U> OrUserError<T, U> {
  /// Converts this error into another error.
  /// The new error type `E` must implement [`From<T>`].
  /// Additionally takes a closure allowing the user to decide how to convert the user error.
  pub fn convert_with<E, F>(self, f: F) -> E
  where T: Into<E>, F: FnOnce(U) -> E {
    match self {
      Self::Base(err) => err.into(),
      Self::User(err) => f(err)
    }
  }

  /// Converts this error into another error.
  /// The new error type `E` must implement [`From<T>`] and [`From<U>`].
  pub fn convert<E>(self) -> E
  where T: Into<E>, U: Into<E> {
    self.convert_with(U::into)
  }
}

impl<T> OrUserError<T, Infallible> {
  /// Converts this error to `T` (the base error variant), given that `U` (the user error variant) is [`Infallible`].
  pub fn into_base(self) -> T {
    match self {
      Self::Base(err) => err,
      Self::User(i) => match i {}
    }
  }
}

impl<U> OrUserError<Infallible, U> {
  /// Converts this error to `U` (the user error variant), given that `T` (the base error variant) is [`Infallible`].
  pub fn into_user(self) -> U {
    match self {
      Self::User(err) => err,
      Self::Base(i) => match i {}
    }
  }
}

impl<T, U> From<T> for OrUserError<T, U> {
  fn from(err: T) -> Self {
    OrUserError::Base(err)
  }
}

/// An error that can occur within `singlefile`, with the exception of:
/// - Format Errors
/// - I/O Errors
/// - User Errors
#[non_exhaustive]
#[derive(Debug, Error)]
pub enum OtherError {
  /// The user tried to perform an operation that is incompatible with the set [`FileMode`].
  #[error("file mode {0:?} is incompatible with this operation")]
  IncompatibleFileMode(FileMode)
}