use alloc::{borrow::Cow, vec, vec::Vec};
use core::{fmt, iter::FusedIterator, ops::Index, slice};
use crate::{Value, tree, tree::Member};
#[derive(Default)]
pub struct Object<'a> {
members: Vec<Member<'a>>,
}
impl<'a> Object<'a> {
#[inline]
#[must_use]
pub const fn new() -> Self {
Self {
members: Vec::new(),
}
}
#[inline]
#[must_use]
pub fn with_capacity(capacity: usize) -> Self {
Self {
members: Vec::with_capacity(capacity),
}
}
#[inline]
#[must_use]
pub fn len(&self) -> usize {
self.members.len()
}
#[inline]
#[must_use]
pub fn is_empty(&self) -> bool {
self.members.is_empty()
}
#[must_use]
pub fn get(&self, key: &str) -> Option<&Value<'a>> {
self.members.iter().find(|(k, _)| k == key).map(|(_, v)| v)
}
#[must_use]
pub fn get_mut(&mut self, key: &str) -> Option<&mut Value<'a>> {
self.members
.iter_mut()
.find(|(k, _)| k == key)
.map(|(_, v)| v)
}
#[must_use]
pub fn contains_key(&self, key: &str) -> bool {
self.members.iter().any(|(k, _)| k == key)
}
pub fn insert(
&mut self,
key: impl Into<Cow<'a, str>>,
value: impl Into<Value<'a>>,
) -> Option<Value<'a>> {
let key = key.into();
let value = value.into();
match self.get_mut(&key) {
Some(slot) => Some(core::mem::replace(slot, value)),
None => {
self.members.push((key, value));
None
}
}
}
pub fn push(&mut self, key: impl Into<Cow<'a, str>>, value: impl Into<Value<'a>>) {
self.members.push((key.into(), value.into()));
}
pub fn remove(&mut self, key: &str) -> Option<Value<'a>> {
let at = self.members.iter().position(|(k, _)| k == key)?;
Some(self.members.remove(at).1)
}
#[inline]
pub fn iter(&self) -> Iter<'_, 'a> {
Iter {
inner: self.members.iter(),
}
}
#[inline]
pub fn iter_mut(&mut self) -> IterMut<'_, 'a> {
IterMut {
inner: self.members.iter_mut(),
}
}
pub fn keys(&self) -> impl DoubleEndedIterator<Item = &str> + ExactSizeIterator {
self.members.iter().map(|(k, _)| k.as_ref())
}
pub fn values(&self) -> impl DoubleEndedIterator<Item = &Value<'a>> + ExactSizeIterator {
self.members.iter().map(|(_, v)| v)
}
#[inline]
#[must_use]
pub fn as_slice(&self) -> &[(Cow<'a, str>, Value<'a>)] {
&self.members
}
#[inline]
#[must_use]
pub fn into_vec(mut self) -> Vec<(Cow<'a, str>, Value<'a>)> {
core::mem::take(&mut self.members)
}
#[must_use]
pub fn into_owned(self) -> Object<'static> {
match tree::into_owned(Value::Object(self)) {
Value::Object(o) => o,
_ => Object::new(),
}
}
#[inline]
pub(crate) fn members_mut(&mut self) -> &mut Vec<Member<'a>> {
&mut self.members
}
}
impl Drop for Object<'_> {
fn drop(&mut self) {
tree::drop_members(&mut self.members);
}
}
impl Clone for Object<'_> {
fn clone(&self) -> Self {
Self {
members: tree::clone_members(&self.members),
}
}
}
impl PartialEq for Object<'_> {
fn eq(&self, other: &Self) -> bool {
self.members.len() == other.members.len()
&& self
.members
.iter()
.zip(&other.members)
.all(|((ka, va), (kb, vb))| ka == kb && tree::eq(va, vb))
}
}
impl Eq for Object<'_> {}
impl fmt::Debug for Object<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_map().entries(self.iter()).finish()
}
}
impl<'a> From<Vec<(Cow<'a, str>, Value<'a>)>> for Object<'a> {
#[inline]
fn from(members: Vec<(Cow<'a, str>, Value<'a>)>) -> Self {
Self { members }
}
}
impl<'a, K: Into<Cow<'a, str>>, V: Into<Value<'a>>> FromIterator<(K, V)> for Object<'a> {
fn from_iter<I: IntoIterator<Item = (K, V)>>(iter: I) -> Self {
Self {
members: iter
.into_iter()
.map(|(k, v)| (k.into(), v.into()))
.collect(),
}
}
}
impl<'a, K: Into<Cow<'a, str>>, V: Into<Value<'a>>> Extend<(K, V)> for Object<'a> {
fn extend<I: IntoIterator<Item = (K, V)>>(&mut self, iter: I) {
self.members
.extend(iter.into_iter().map(|(k, v)| (k.into(), v.into())));
}
}
impl<'a> Index<&str> for Object<'a> {
type Output = Value<'a>;
fn index(&self, key: &str) -> &Value<'a> {
self.get(key).unwrap_or(&crate::value::NULL)
}
}
impl<'a> IntoIterator for Object<'a> {
type Item = (Cow<'a, str>, Value<'a>);
type IntoIter = vec::IntoIter<(Cow<'a, str>, Value<'a>)>;
#[inline]
fn into_iter(self) -> Self::IntoIter {
self.into_vec().into_iter()
}
}
impl<'r, 'a> IntoIterator for &'r Object<'a> {
type Item = (&'r str, &'r Value<'a>);
type IntoIter = Iter<'r, 'a>;
#[inline]
fn into_iter(self) -> Self::IntoIter {
self.iter()
}
}
impl<'r, 'a> IntoIterator for &'r mut Object<'a> {
type Item = (&'r str, &'r mut Value<'a>);
type IntoIter = IterMut<'r, 'a>;
#[inline]
fn into_iter(self) -> Self::IntoIter {
self.iter_mut()
}
}
#[derive(Clone, Debug)]
pub struct Iter<'r, 'a> {
inner: slice::Iter<'r, Member<'a>>,
}
impl<'r, 'a> Iterator for Iter<'r, 'a> {
type Item = (&'r str, &'r Value<'a>);
#[inline]
fn next(&mut self) -> Option<Self::Item> {
self.inner.next().map(|(k, v)| (k.as_ref(), v))
}
#[inline]
fn size_hint(&self) -> (usize, Option<usize>) {
self.inner.size_hint()
}
}
impl DoubleEndedIterator for Iter<'_, '_> {
#[inline]
fn next_back(&mut self) -> Option<Self::Item> {
self.inner.next_back().map(|(k, v)| (k.as_ref(), v))
}
}
impl ExactSizeIterator for Iter<'_, '_> {}
impl FusedIterator for Iter<'_, '_> {}
#[derive(Debug)]
pub struct IterMut<'r, 'a> {
inner: slice::IterMut<'r, Member<'a>>,
}
impl<'r, 'a> Iterator for IterMut<'r, 'a> {
type Item = (&'r str, &'r mut Value<'a>);
#[inline]
fn next(&mut self) -> Option<Self::Item> {
self.inner.next().map(split_mut)
}
#[inline]
fn size_hint(&self) -> (usize, Option<usize>) {
self.inner.size_hint()
}
}
impl DoubleEndedIterator for IterMut<'_, '_> {
#[inline]
fn next_back(&mut self) -> Option<Self::Item> {
self.inner.next_back().map(split_mut)
}
}
#[inline]
fn split_mut<'r, 'a>(member: &'r mut Member<'a>) -> (&'r str, &'r mut Value<'a>) {
let (key, value) = member;
let key: &'r Cow<'a, str> = key;
(key, value)
}
impl ExactSizeIterator for IterMut<'_, '_> {}
impl FusedIterator for IterMut<'_, '_> {}