Struct Collection 

pub struct Collection<T: Ord> { /* private fields */ }

The kinds of a collection (e.g. array or object).

A collection contains one or more kinds for known positions within the collection (e.g. indices or fields), and contains a global “unknown” state that applies to all unknown paths.

Implementations

impl Collection<Index>

pub fn largest_known_index(&self) -> Option<usize>

Returns the largest known index, or None if no known indices exist.

pub fn get_positive_index(&self, index: isize) -> Option<usize>

Converts a negative index to a positive index (only if the exact positive index is known).

pub fn min_length(&self) -> usize

The minimum possible length an array could be given the type information.

pub fn exact_length(&self) -> Option<usize>

The exact length of the array, if it can be proven. Otherwise, None.

pub fn remove_shift(&mut self, index: usize)

Removes the known value at the given index and shifts the elements to the left.

impl<T: Ord + Clone> Collection<T>

pub fn from_parts(known: BTreeMap<T, Kind>, unknown: impl Into<Kind>) -> Self

Create a new collection from its parts.

pub fn from_unknown(unknown: impl Into<Kind>) -> Self

Create a new collection with a defined “unknown fields” value, and no known fields.

pub fn empty() -> Self

Create a collection kind of which there are no known and no unknown kinds.

pub fn any() -> Self

Create a collection kind of which the encapsulated values can be any kind.

pub fn json() -> Self

Create a collection kind of which the encapsulated values can be any JSON-compatible kind.

pub fn is_any(&self) -> bool

Check if the collection fields can be of any kind.

This returns false if at least one field kind is known.

pub fn known(&self) -> &BTreeMap<T, Kind>

Get a reference to the “known” elements in the collection.

pub fn known_mut(&mut self) -> &mut BTreeMap<T, Kind>

Get a mutable reference to the “known” elements in the collection.

pub fn unknown_kind(&self) -> Kind

Gets the type of “unknown” elements in the collection. The returned type will always have “undefined” included.

pub fn is_unknown_exact(&self) -> bool

Returns true if the unknown variant is “Exact” (vs “Infinite”). This can be used to determine when to stop recursing into an unknown kind. Once the unknown is infinite, this will return false and all unknowns after that will return the same kind.

pub fn is_empty(&self) -> EmptyState

Returns an enum describing if the collection is empty.

pub fn set_unknown(&mut self, unknown: impl Into<Kind>)

Set all “unknown” collection elements to the given kind.

pub fn with_unknown(self, unknown: impl Into<Kind>) -> Self

Returns a new collection with the unknown set.

pub fn with_known(self, key: impl Into<T>, kind: Kind) -> Self

Returns a new collection that includes the known key.

pub fn anonymize(&mut self)

Given a collection of known and unknown types, merge the known types with the unknown type, and remove a reference to the known types.

That is, given an object with field “foo” as integer, “bar” as bytes and unknown fields as timestamp, after calling this function, the object has no known fields, and all unknown fields are marked as either an integer, bytes or timestamp.

Recursively known fields are left untouched. For example, an object with a field “foo” that has an object with a field “bar” results in a collection of which any field can have an object that has a field “bar”.

pub fn merge(&mut self, other: Self, overwrite: bool)

Merge the other collection into self.

The following merge strategies are applied.

For known fields:

• If a field exists in both collections, their Kinds are merged, or the other fields are used (depending on the configured Strategy).

• If a field exists in one but not the other, the field is merged with the “unknown” of the other if it exists, or just the field is used otherwise.

For unknown fields or indices:

• Both Unknowns are merged, similar to merging two Kinds.

pub fn reduced_kind(&self) -> Kind

Return the reduced Kind of the items within the collection. This only returns the type of defined values in the collection. Accessing a non-existing value can return undefined which is not added to the type here.

impl<T: Ord + Clone + CollectionKey> Collection<T>

pub fn is_superset(&self, other: &Self) -> Result<(), OwnedValuePath>

Check if self is a superset of other.

Meaning, for all known fields in other, if the field also exists in self, then its type needs to be a subset of self, otherwise its type needs to be a subset of self’s unknown.

If self has known fields not defined in other, then other’s unknown must be a superset of those fields defined in self.

Additionally, other’s unknown type needs to be a subset of self’s.

Errors

If the type is not a superset, a path to one field that doesn’t match is returned. This is mostly useful for debugging.

Trait Implementations

impl<T: Clone + Ord> Clone for Collection<T>

fn clone(&self) -> Collection<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Ord> Debug for Collection<T>

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

Formats the value using the given formatter.

impl Display for Collection<Field>

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

Formats the value using the given formatter.

impl Display for Collection<Index>

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

Formats the value using the given formatter.

impl<T: Ord> From<BTreeMap<T, Kind>> for Collection<T>

fn from(known: BTreeMap<T, Kind>) -> Self

Converts to this type from the input type.

impl From<Collection<Field>> for Kind

fn from(collection: Collection<Field>) -> Self

Converts to this type from the input type.

impl From<Collection<Index>> for Kind

fn from(collection: Collection<Index>) -> Self

Converts to this type from the input type.

impl<T: PartialEq + Ord> PartialEq for Collection<T>

fn eq(&self, other: &Collection<T>) -> 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<T: PartialOrd + Ord> PartialOrd for Collection<T>

fn partial_cmp(&self, other: &Collection<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: Eq + Ord> Eq for Collection<T>

impl<T: Ord> StructuralPartialEq for Collection<T>