Struct ObjectAsVec 

pub struct ObjectAsVec<'ctx, P: Property, E: Element>(/* private fields */);

Represents a JSON key/value type.

For performance reasons we use a Vec instead of a Hashmap. This comes with a tradeoff of slower key accesses as we need to iterate and compare.

The ObjectAsVec struct is a wrapper around a Vec of (&str, Value) pairs. It provides methods to make it easy to migrate from serde_json::Value::Object or serde_json::Map.

Implementations

impl<'ctx, P: Property, E: Element> ObjectAsVec<'ctx, P, E>

pub fn new() -> Self

pub fn with_capacity(capacity: usize) -> Self

pub fn as_vec(&self) -> &Vec<(Key<'ctx, P>, Value<'ctx, P, E>)>

Access to the underlying Vec.

Note

Since KeyStrType can be changed via a feature flag avoid using as_vec and use other methods instead. This could be a problem with feature unification, when one crate uses it as &str and another uses it as Cow<str>, both will get Cow<str>

pub fn as_mut_vec(&mut self) -> &mut Vec<(Key<'ctx, P>, Value<'ctx, P, E>)>

pub fn into_vec(self) -> Vec<(Key<'ctx, P>, Value<'ctx, P, E>)>

Access to the underlying Vec. Keys are normalized to Cow.

pub fn get(&self, key: &Key<'_, P>) -> Option<&Value<'ctx, P, E>>

Returns a reference to the value corresponding to the key.

Performance

As this is backed by a Vec, this searches linearly through the Vec as may be much more expensive than a Hashmap for larger Objects.

pub fn get_ignore_case(&self, key: &str) -> Option<&Value<'ctx, P, E>>

pub fn get_mut(&mut self, key: &Key<'ctx, P>) -> Option<&mut Value<'ctx, P, E>>

Returns a mutable reference to the value corresponding to the key, if it exists.

Performance

As this is backed by a Vec, this searches linearly through the Vec as may be much more expensive than a Hashmap for larger Objects.

pub fn get_key_value( &self, key: &Key<'_, P>, ) -> Option<(&Key<'_, P>, &Value<'ctx, P, E>)>

Returns the key-value pair corresponding to the supplied key.

Performance

As this is backed by a Vec, this searches linearly through the Vec as may be much more expensive than a Hashmap for larger Objects.

pub fn iter(&self) -> impl Iterator<Item = (&Key<'ctx, P>, &Value<'ctx, P, E>)>

An iterator visiting all key-value pairs

pub fn iter_mut( &mut self, ) -> impl Iterator<Item = (&mut Key<'ctx, P>, &mut Value<'ctx, P, E>)>

pub fn len(&self) -> usize

Returns the number of elements in the object

pub fn is_empty(&self) -> bool

Returns true if the object contains no elements

pub fn keys(&self) -> impl Iterator<Item = &Key<'ctx, P>>

An iterator visiting all keys

pub fn values(&self) -> impl Iterator<Item = &Value<'ctx, P, E>>

An iterator visiting all values

pub fn contains_key(&self, key: &Key<'ctx, P>) -> bool

Returns true if the object contains a value for the specified key.

Performance

As this is backed by a Vec, this searches linearly through the Vec as may be much more expensive than a Hashmap for larger Objects.

pub fn contains_key_value( &self, key: &Key<'ctx, P>, value: &Value<'ctx, P, E>, ) -> bool

pub fn contains_any_key(&self, keys: &[Key<'ctx, P>]) -> bool

pub fn remove(&mut self, key: &Key<'ctx, P>) -> Option<Value<'ctx, P, E>>

pub fn insert( &mut self, key: impl Into<Key<'ctx, P>>, value: impl Into<Value<'ctx, P, E>>, ) -> Option<Value<'ctx, P, E>>

Inserts a key-value pair into the object. If the object did not have this key present, None is returned. If the object did have this key present, the value is updated, and the old value is returned.

Performance

This operation is linear in the size of the Vec because it potentially requires iterating through all elements to find a matching key.

pub fn insert_or_get_mut( &mut self, key: impl Into<Key<'ctx, P>>, value: impl Into<Value<'ctx, P, E>>, ) -> &mut Value<'ctx, P, E>

Inserts a key-value pair into the object if the key does not yet exist, otherwise returns a mutable reference to the existing value.

Performance

This operation might be linear in the size of the Vec because it requires iterating through all elements to find a matching key, and might add to the end if not found.

pub fn insert_unchecked( &mut self, key: impl Into<Key<'ctx, P>>, value: impl Into<Value<'ctx, P, E>>, )

pub fn with_key_value( self, key: impl Into<Key<'ctx, P>>, value: impl Into<Value<'ctx, P, E>>, ) -> Self

pub fn insert_named( &mut self, key: Option<String>, value: Value<'ctx, P, E>, ) -> String

pub fn extend<I>(&mut self, iter: I)

where I: IntoIterator<Item = (Key<'ctx, P>, Value<'ctx, P, E>)>,

pub fn insert_unchecked_and_get_mut( &mut self, key: impl Into<Key<'ctx, P>>, value: impl Into<Value<'ctx, P, E>>, ) -> &mut Value<'ctx, P, E>

Inserts a key-value pair into the object and returns the mutable reference of the inserted value.

Note

The key must not exist in the object. If the key already exists, the object will contain multiple keys afterwards.

Performance

This operation is amortized constant time, worst case linear time in the size of the Vec because it potentially requires a reallocation to grow the Vec.

impl<'ctx, P: Property, E: Element<Property = P>> ObjectAsVec<'ctx, P, E>

pub fn into_expanded_boolean_set(self) -> impl Iterator<Item = Key<'ctx, P>>

Trait Implementations

impl<'ctx, P: Clone + Property, E: Clone + Element> Clone for ObjectAsVec<'ctx, P, E>

fn clone(&self) -> ObjectAsVec<'ctx, P, E>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'ctx, P: Debug + Property, E: Debug + Element> Debug for ObjectAsVec<'ctx, P, E>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'ctx, P: Default + Property, E: Default + Element> Default for ObjectAsVec<'ctx, P, E>

fn default() -> ObjectAsVec<'ctx, P, E>

Returns the “default value” for a type.

impl<'ctx, P: Property, E: Element> From<&ObjectAsVec<'ctx, P, E>> for Map<String, Value>

fn from(val: &ObjectAsVec<'ctx, P, E>) -> Self

Converts to this type from the input type.

impl<'ctx, P: Property, E: Element> From<ObjectAsVec<'ctx, P, E>> for Map<String, Value>

fn from(val: ObjectAsVec<'ctx, P, E>) -> Self

Converts to this type from the input type.

impl<'ctx, P: Property, E: Element> From<ObjectAsVec<'ctx, P, E>> for Value<'ctx, P, E>

fn from(val: ObjectAsVec<'ctx, P, E>) -> Self

Converts to this type from the input type.

impl<'ctx, P: Property, E: Element> From<Vec<(Key<'ctx, P>, Value<'ctx, P, E>)>> for ObjectAsVec<'ctx, P, E>

fn from(vec: Vec<(Key<'ctx, P>, Value<'ctx, P, E>)>) -> Self

Converts to this type from the input type.

impl<'ctx, P: Property, E: Element> FromIterator<(Key<'ctx, P>, Value<'ctx, P, E>)> for ObjectAsVec<'ctx, P, E>

fn from_iter<T: IntoIterator<Item = (Key<'ctx, P>, Value<'ctx, P, E>)>>( iter: T, ) -> Self

Creates a value from an iterator.

impl<'ctx, P: Hash + Property, E: Hash + Element> Hash for ObjectAsVec<'ctx, P, E>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'ctx, P: PartialEq + Property, E: PartialEq + Element> PartialEq for ObjectAsVec<'ctx, P, E>

fn eq(&self, other: &ObjectAsVec<'ctx, P, E>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<P: Property, E: Element> Serialize for Map<'_, P, E>

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<'ctx, P: Eq + Property, E: Eq + Element> Eq for ObjectAsVec<'ctx, P, E>

impl<'ctx, P: Property, E: Element> StructuralPartialEq for ObjectAsVec<'ctx, P, E>