Struct json_syntax::object::Entry

source ·

pub struct Entry<M = ()> {
    pub key: Meta<Key, M>,
    pub value: MetaValue<M>,
}

Expand description

Object entry.

Fields§

§key: Meta<Key, M>§value: MetaValue<M>

Implementations§

source §

impl<M> Entry<M>

source

pub fn new(key: Meta<Key, M>, value: MetaValue<M>) -> Self

Examples found in repository ?

src/object.rs (line 389)

	pub fn push(&mut self, key: Meta<Key, M>, value: MetaValue<M>) -> bool {
		self.push_entry(Entry::new(key, value))
	}

	pub fn push_entry(&mut self, entry: Entry<M>) -> bool {
		let index = self.entries.len();
		self.entries.push(entry);
		self.indexes.insert(&self.entries, index)
	}

	/// Removes the entry at the given index.
	pub fn remove_at(&mut self, index: usize) -> Option<Entry<M>> {
		if index < self.entries.len() {
			self.indexes.remove(&self.entries, index);
			self.indexes.shift(index);
			Some(self.entries.remove(index))
		} else {
			None
		}
	}

	/// Inserts the given key-value pair.
	///
	/// If one or more entries are already matching the given key,
	/// all of them are removed and returned in the resulting iterator.
	/// Otherwise, `None` is returned.
	pub fn insert(
		&mut self,
		key: Meta<Key, M>,
		value: MetaValue<M>,
	) -> Option<RemovedByInsertion<M>> {
		match self.index_of(key.value()) {
			Some(index) => {
				let mut entry = Entry::new(key, value);
				core::mem::swap(&mut entry, &mut self.entries[index]);
				Some(RemovedByInsertion {
					index,
					first: Some(entry),
					object: self,
				})
			}
			None => {
				self.push(key, value);
				None
			}
		}
	}

More examples

Hide additional examples

src/convert/serde_json.rs (line 38)

	pub fn from_serde_json(
		value: serde_json::Value,
		f: impl Clone + Fn(SerdeJsonFragment) -> M,
	) -> Meta<Self, M> {
		let meta = f(SerdeJsonFragment::Value(&value));

		let v = match value {
			serde_json::Value::Null => Self::Null,
			serde_json::Value::Bool(b) => Self::Boolean(b),
			serde_json::Value::Number(n) => Self::Number(n.into()),
			serde_json::Value::String(s) => Self::String(s.into()),
			serde_json::Value::Array(a) => Self::Array(
				a.into_iter()
					.map(|i| Self::from_serde_json(i, f.clone()))
					.collect(),
			),
			serde_json::Value::Object(o) => Self::Object(
				o.into_iter()
					.map(|(k, v)| {
						let k_meta = f(SerdeJsonFragment::Key(&k));
						Entry::new(Meta(k.into(), k_meta), Self::from_serde_json(v, f.clone()))
					})
					.collect(),
			),
		};

		Meta(v, meta)
	}

source

pub fn map_metadata<N>(self, f: impl FnMut(M) -> N) -> Entry<N>

Examples found in repository ?

src/object.rs (line 474)

	pub fn map_metadata<N>(self, mut f: impl FnMut(M) -> N) -> Object<N> {
		let entries = self
			.entries
			.into_iter()
			.map(|entry| entry.map_metadata(&mut f))
			.collect();

		Object {
			entries,
			indexes: self.indexes,
		}
	}

source

pub fn try_map_metadata<N, E>(
self,
f: impl FnMut(M) -> Result<N, E>
) -> Result<Entry<N>, E>

Examples found in repository ?

src/object.rs (line 490)

	pub fn try_map_metadata<N, E>(
		self,
		mut f: impl FnMut(M) -> Result<N, E>,
	) -> Result<Object<N>, E> {
		let mut entries = Vec::with_capacity(self.len());
		for entry in self.entries {
			entries.push(entry.try_map_metadata(&mut f)?)
		}

		Ok(Object {
			entries,
			indexes: self.indexes,
		})
	}