json-ld 0.22.0

JSON-LD implementation
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

use std::{hash::Hash, str::FromStr};

use json_syntax::{JsonNumber, JsonNumberBuf};

#[derive(Debug, thiserror::Error)]
#[error("unknown JSON-LD version `{0}`")]
pub struct UnknownJsonLdVersion(pub String);

/// Version number.
///
/// The only allowed value is a number with the value `1.1`.
#[derive(Clone, Copy, PartialOrd, Ord, Debug)]
pub enum JsonLdVersion {
	V1_1,
}

impl JsonLdVersion {
	pub fn into_bytes(self) -> &'static [u8] {
		match self {
			Self::V1_1 => b"1.1",
		}
	}

	pub fn into_str(self) -> &'static str {
		match self {
			Self::V1_1 => "1.1",
		}
	}

	pub fn into_json_number(self) -> &'static JsonNumber {
		unsafe { JsonNumber::new_unchecked(self.into_bytes()) }
	}

	pub fn into_json_number_buf(self) -> JsonNumberBuf {
		unsafe { JsonNumberBuf::new_unchecked(self.into_bytes().into()) }
	}
}

impl PartialEq for JsonLdVersion {
	fn eq(&self, _other: &Self) -> bool {
		true
	}
}

impl Eq for JsonLdVersion {}

impl Hash for JsonLdVersion {
	fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
		self.into_str().hash(state)
	}
}

impl From<JsonLdVersion> for &JsonNumber {
	fn from(v: JsonLdVersion) -> Self {
		v.into_json_number()
	}
}

impl From<JsonLdVersion> for JsonNumberBuf {
	fn from(v: JsonLdVersion) -> Self {
		v.into_json_number_buf()
	}
}

impl TryFrom<JsonNumberBuf> for JsonLdVersion {
	type Error = UnknownJsonLdVersion;

	fn try_from(value: JsonNumberBuf) -> Result<Self, Self::Error> {
		if value.trimmed().as_str() == "1.1" {
			Ok(Self::V1_1)
		} else {
			Err(UnknownJsonLdVersion(value.to_string()))
		}
	}
}

impl FromStr for JsonLdVersion {
	type Err = UnknownJsonLdVersion;

	fn from_str(s: &str) -> Result<Self, Self::Err> {
		if s == "1.1" {
			Ok(JsonLdVersion::V1_1)
		} else {
			Err(UnknownJsonLdVersion(s.to_owned()))
		}
	}
}

impl TryFrom<f32> for JsonLdVersion {
	type Error = UnknownJsonLdVersion;

	fn try_from(value: f32) -> Result<Self, Self::Error> {
		if value == 1.1 {
			Ok(JsonLdVersion::V1_1)
		} else {
			Err(UnknownJsonLdVersion(value.to_string()))
		}
	}
}

impl TryFrom<f64> for JsonLdVersion {
	type Error = UnknownJsonLdVersion;

	fn try_from(value: f64) -> Result<Self, Self::Error> {
		if value == 1.1 {
			Ok(JsonLdVersion::V1_1)
		} else {
			Err(UnknownJsonLdVersion(value.to_string()))
		}
	}
}

#[cfg(feature = "serde")]
impl serde::Serialize for JsonLdVersion {
	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
	where
		S: serde::Serializer,
	{
		self.into_json_number().serialize(serializer)
	}
}

#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for JsonLdVersion {
	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
	where
		D: serde::Deserializer<'de>,
	{
		JsonNumberBuf::deserialize(deserializer)?
			.try_into()
			.map_err(serde::de::Error::custom)
	}
}