spuz_piston 0.1.1

Minecraft json documents described in Rust
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

use std::{
	collections::HashMap,
	fmt::{Debug, Display},
	ops::Deref,
	str::FromStr,
};

use serde::{Deserialize, Serialize};

use crate::{
	platform::NativeClassifier,
	rule::{ConditionalValue, Rule},
	Arr, BoxPath, Size, Str,
};

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(untagged)]
pub enum ListOrValue<T> {
	List(Arr<T>),
	Value(T),
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "camelCase")]
pub struct AssetIndexRef {
	pub id: Str,
	pub url: Str,
	pub total_size: Size,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct Artifact {
	pub path: BoxPath,
	pub sha1: Str,
	pub size: Size,
	pub url: Str,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(untagged)]
pub enum Argument {
	Plain(Str),
	Conditional(ConditionalValue<ListOrValue<Str>>),
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct Arguments {
	pub game: Arr<Argument>,
	pub jvm: Arr<Argument>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct Library {
	pub name: Str,
	pub downloads: Specifiers,
	pub rules: Option<Arr<Rule>>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct Specifiers {
	pub artifact: Option<Artifact>,
	pub classifiers: Option<HashMap<NativeClassifier, Artifact>>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct DownloadItem {
	pub sha1: Str,
	pub size: Size,
	pub url: Str,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct Downloads {
	pub client: DownloadItem,
	pub client_mappings: Option<DownloadItem>,
	pub server: DownloadItem,
	pub server_mappings: Option<DownloadItem>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct LoggingFile {
	pub id: Str,
	pub sha1: Str,
	pub size: Size,
	pub url: Str,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct ClientLogging {
	pub argument: Str,
	pub file: LoggingFile,
	pub r#type: Str,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct Logging {
	pub client: ClientLogging,
}

impl Deref for Logging {
	type Target = ClientLogging;

	fn deref(&self) -> &Self::Target {
		&self.client
	}
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "camelCase")]
pub struct Manifest {
	pub r#type: Str,
	pub id: Str,
	pub time: Str,
	pub release_time: Str,
	pub main_class: Str,
	pub assets: Str,
	pub asset_index: AssetIndexRef,
	pub libraries: Arr<Library>,
	pub arguments: Arguments,
	pub downloads: Downloads,
	pub logging: Logging,
}

impl FromStr for Manifest {
	type Err = serde_json::Error;

	fn from_str(s: &str) -> Result<Self, Self::Err> {
		serde_json::from_str(s)
	}
}

impl Display for Manifest {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		serde_json::to_string(self).map_err(|_| std::fmt::Error).fmt(f)
	}
}