modio 0.14.2

Rust interface for integrating https://mod.io - a modding API for game developers
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

use std::fmt;

use crate::types::id::{FileId, GameId, ModId};

type Source = Box<dyn std::error::Error + Send + Sync>;

/// The Errors that may occur when using [`Download::download`].
///
/// [`Download::download`]: crate::util::Download::download
pub struct Error {
    kind: ErrorKind,
    source: Option<Source>,
}

impl Error {
    #[inline]
    pub(crate) fn new(kind: ErrorKind) -> Self {
        Self { kind, source: None }
    }

    #[inline]
    pub(crate) fn with<E: Into<Source>>(mut self, source: E) -> Self {
        self.source = Some(source.into());
        self
    }

    pub const fn kind(&self) -> &ErrorKind {
        &self.kind
    }
}

impl Error {
    #[inline]
    pub(crate) fn request<E: Into<Source>>(source: E) -> Self {
        Self::new(ErrorKind::Request).with(source)
    }

    #[inline]
    pub(crate) fn body<E: Into<Source>>(source: E) -> Self {
        Self::new(ErrorKind::Body).with(source)
    }
}

impl fmt::Debug for Error {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let mut s = f.debug_struct("Error");

        s.field("kind", &self.kind);
        if let Some(ref source) = self.source {
            s.field("source", source);
        }
        s.finish()
    }
}

impl fmt::Display for Error {
    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
        match &self.kind {
            ErrorKind::Request => fmt.write_str("request failed"),
            ErrorKind::Body => fmt.write_str("failed to load response body"),
            ErrorKind::Io => fmt.write_str("IO error"),
            ErrorKind::ModNotFound { game_id, mod_id } => write!(
                fmt,
                "Mod {{id: {mod_id}, game_id: {game_id}}} not found.",
            ),
            ErrorKind::FileNotFound {
                game_id,
                mod_id,
                file_id,
            } => write!(
                fmt,
                "Mod {{id: {mod_id}, game_id: {game_id}}}: File {{ id: {file_id} }} not found.",
            ),
            ErrorKind::MultipleFilesFound {
                game_id,
                mod_id,
                version,
            } => write!(
                fmt,
                "Mod {{id: {mod_id}, game_id: {game_id}}}: Multiple files found for version '{version}'.",
            ),
            ErrorKind::NoPrimaryFile { game_id, mod_id } => write!(
                fmt,
                "Mod {{id: {mod_id}, game_id: {game_id}}} Mod has no primary file.",
            ),
            ErrorKind::VersionNotFound {
                game_id,
                mod_id,
                version,
            } => write!(
                fmt,
                "Mod {{id: {mod_id}, game_id: {game_id}}}: No file with version '{version}' found.",
            ),
        }
    }
}

impl std::error::Error for Error {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        self.source.as_ref().map(|e| &**e as _)
    }
}

#[derive(Debug)]
pub enum ErrorKind {
    Request,
    Body,
    Io,
    /// The mod has not found.
    ModNotFound {
        game_id: GameId,
        mod_id: ModId,
    },
    /// The mod has no primary file.
    NoPrimaryFile {
        game_id: GameId,
        mod_id: ModId,
    },
    /// The specific file of a mod was not found.
    FileNotFound {
        game_id: GameId,
        mod_id: ModId,
        file_id: FileId,
    },
    /// Multiple files for a given version were found and the policy was set to
    /// [`ResolvePolicy::Fail`].
    ///
    /// [`ResolvePolicy::Fail`]: super::ResolvePolicy::Fail
    MultipleFilesFound {
        game_id: GameId,
        mod_id: ModId,
        version: String,
    },
    /// No file for a given version was found.
    VersionNotFound {
        game_id: GameId,
        mod_id: ModId,
        version: String,
    },
}