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

use std::hash::Hash;

use crate::{
	JsonLdIndexedObject, JsonLdVisit,
	object::{JsonLdObjectMut, JsonLdObjectRef},
};

use super::AnyJsonLdObject;

#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
/// List object.
pub struct JsonLdList {
	#[cfg_attr(feature = "serde", serde(rename = "@list"))]
	entry: Vec<JsonLdIndexedObject>,
}

impl JsonLdList {
	/// Creates a new list object.
	pub fn new(objects: Vec<JsonLdIndexedObject>) -> Self {
		Self { entry: objects }
	}

	pub fn len(&self) -> usize {
		self.entry.len()
	}

	pub fn is_empty(&self) -> bool {
		self.entry.is_empty()
	}

	/// Returns a reference to the "@list" entry of the list object.
	///
	/// Alias for `as_slice`.
	pub fn entry(&self) -> &[JsonLdIndexedObject] {
		&self.entry
	}

	pub fn entry_mut(&mut self) -> &mut Vec<JsonLdIndexedObject> {
		&mut self.entry
	}

	pub fn as_slice(&self) -> &[JsonLdIndexedObject] {
		self.entry.as_slice()
	}

	pub fn as_mut_slice(&mut self) -> &mut [JsonLdIndexedObject] {
		self.entry.as_mut_slice()
	}

	pub fn into_entry(self) -> Vec<JsonLdIndexedObject> {
		self.entry
	}

	pub fn push(&mut self, object: JsonLdIndexedObject) {
		self.entry.push(object)
	}

	pub fn pop(&mut self) -> Option<JsonLdIndexedObject> {
		self.entry.pop()
	}

	pub fn iter(&self) -> core::slice::Iter<'_, JsonLdIndexedObject> {
		self.entry.iter()
	}

	pub fn iter_mut(&mut self) -> core::slice::IterMut<'_, JsonLdIndexedObject> {
		self.entry.iter_mut()
	}
}

impl JsonLdVisit for JsonLdList {
	fn visit_with(&self, f: &mut impl FnMut(JsonLdObjectRef)) {
		f(JsonLdObjectRef::List(self));
		for t in self {
			t.visit_with(f);
		}
	}

	fn visit_mut_with(&mut self, f: &mut impl FnMut(JsonLdObjectMut)) {
		f(JsonLdObjectMut::List(self));
		for t in &mut self.entry {
			t.visit_mut_with(f);
		}
	}
}

impl AnyJsonLdObject for JsonLdList {
	fn as_ref(&self) -> super::JsonLdObjectRef<'_> {
		super::JsonLdObjectRef::List(self)
	}
}

impl<'a> IntoIterator for &'a JsonLdList {
	type Item = &'a JsonLdIndexedObject;
	type IntoIter = core::slice::Iter<'a, JsonLdIndexedObject>;

	fn into_iter(self) -> Self::IntoIter {
		self.iter()
	}
}

impl<'a> IntoIterator for &'a mut JsonLdList {
	type Item = &'a mut JsonLdIndexedObject;
	type IntoIter = core::slice::IterMut<'a, JsonLdIndexedObject>;

	fn into_iter(self) -> Self::IntoIter {
		self.iter_mut()
	}
}

impl IntoIterator for JsonLdList {
	type Item = JsonLdIndexedObject;
	type IntoIter = std::vec::IntoIter<JsonLdIndexedObject>;

	fn into_iter(self) -> Self::IntoIter {
		self.entry.into_iter()
	}
}