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)
}
pub fn retain(&mut self, mut keep: impl FnMut(&str, &mut Value<'a>) -> bool) {
self.members.retain_mut(|(key, value)| keep(key, value));
}
pub fn sort_keys(&mut self) {
self.members.sort_by(|(a, _), (b, _)| a.cmp(b));
}
pub fn entry(&mut self, key: impl Into<Cow<'a, str>>) -> Entry<'_, 'a> {
let key = key.into();
match self.members.iter().position(|(k, _)| *k == key) {
Some(index) => Entry::Occupied(OccupiedEntry {
object: self,
index,
}),
None => Entry::Vacant(VacantEntry { object: self, key }),
}
}
#[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(),
}
}
#[allow(clippy::indexing_slicing)]
fn member_value(&mut self, index: usize) -> &mut Value<'a> {
&mut self.members[index].1
}
#[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 core::hash::Hash for Object<'_> {
fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
self.len().hash(state);
for (key, value) in self {
key.hash(state);
value.hash(state);
}
}
}
#[derive(Debug)]
pub enum Entry<'o, 'a> {
Occupied(OccupiedEntry<'o, 'a>),
Vacant(VacantEntry<'o, 'a>),
}
impl<'o, 'a> Entry<'o, 'a> {
pub fn or_insert(self, default: impl Into<Value<'a>>) -> &'o mut Value<'a> {
match self {
Self::Occupied(entry) => entry.into_mut(),
Self::Vacant(entry) => entry.insert(default),
}
}
pub fn or_insert_with(self, default: impl FnOnce() -> Value<'a>) -> &'o mut Value<'a> {
match self {
Self::Occupied(entry) => entry.into_mut(),
Self::Vacant(entry) => entry.insert(default()),
}
}
pub fn or_default(self) -> &'o mut Value<'a> {
self.or_insert(Value::Null)
}
#[must_use]
pub fn and_modify(self, change: impl FnOnce(&mut Value<'a>)) -> Self {
match self {
Self::Occupied(mut entry) => {
change(entry.get_mut());
Self::Occupied(entry)
}
vacant @ Self::Vacant(_) => vacant,
}
}
#[must_use]
pub fn key(&self) -> &str {
match self {
Self::Occupied(entry) => entry.key(),
Self::Vacant(entry) => &entry.key,
}
}
}
#[derive(Debug)]
pub struct OccupiedEntry<'o, 'a> {
object: &'o mut Object<'a>,
index: usize,
}
impl<'o, 'a> OccupiedEntry<'o, 'a> {
#[must_use]
pub fn key(&self) -> &str {
self.object.members.get(self.index).map_or("", |(k, _)| k)
}
#[must_use]
pub fn get(&self) -> &Value<'a> {
self.object
.members
.get(self.index)
.map_or(&crate::value::NULL, |(_, v)| v)
}
pub fn get_mut(&mut self) -> &mut Value<'a> {
let index = self.index;
self.object.member_value(index)
}
pub fn into_mut(self) -> &'o mut Value<'a> {
self.object.member_value(self.index)
}
pub fn insert(&mut self, value: impl Into<Value<'a>>) -> Value<'a> {
core::mem::replace(self.get_mut(), value.into())
}
pub fn remove(self) -> Value<'a> {
if self.index < self.object.members.len() {
self.object.members.remove(self.index).1
} else {
Value::Null
}
}
}
#[derive(Debug)]
pub struct VacantEntry<'o, 'a> {
object: &'o mut Object<'a>,
key: Cow<'a, str>,
}
impl<'o, 'a> VacantEntry<'o, 'a> {
#[must_use]
pub fn key(&self) -> &str {
&self.key
}
pub fn insert(self, value: impl Into<Value<'a>>) -> &'o mut Value<'a> {
let index = self.object.members.len();
self.object.members.push((self.key, value.into()));
self.object.member_value(index)
}
}
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<'_, '_> {}