Struct List

pub struct List<T, B> { /* private fields */ }

List object.

Implementations

impl<T, B> List<T, B>

pub fn new(objects: Vec<IndexedObject<T, B>>) -> Self

Creates a new list object.

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn entry(&self) -> &[IndexedObject<T, B>]

Returns a reference to the “@list” entry of the list object.

Alias for as_slice.

pub fn entry_mut(&mut self) -> &mut Vec<IndexedObject<T, B>>

pub fn as_slice(&self) -> &[IndexedObject<T, B>]

pub fn as_mut_slice(&mut self) -> &mut [IndexedObject<T, B>]

pub fn into_entry(self) -> Vec<IndexedObject<T, B>>

pub fn push(&mut self, object: IndexedObject<T, B>)

pub fn pop(&mut self) -> Option<IndexedObject<T, B>>

pub fn iter(&self) -> Iter<'_, IndexedObject<T, B>>

pub fn iter_mut(&mut self) -> IterMut<'_, IndexedObject<T, B>>

pub fn canonicalize_with(&mut self, buffer: &mut Buffer)

Puts this list object literals into canonical form using the given buffer.

The buffer is used to compute the canonical form of numbers.

pub fn canonicalize(&mut self)

Puts this list object literals into canonical form.

pub fn map_ids<U, C>( self, map_iri: impl FnMut(T) -> U, map_id: impl FnMut(Id<T, B>) -> Id<U, C>, ) -> List<U, C>

where U: Eq + Hash, C: Eq + Hash,

Map the identifiers present in this list (recursively).

Trait Implementations

impl<T, B> Any<T, B> for List<T, B>

fn as_ref(&self) -> Ref<'_, T, B>

fn id(&self) -> Option<&Id<T, B>>

fn language<'a>(&'a self) -> Option<&'a LenientLangTag>

where T: 'a, B: 'a,

fn is_value(&self) -> bool

fn is_node(&self) -> bool

fn is_graph(&self) -> bool

fn is_list(&self) -> bool

impl<T: Clone, B: Clone> Clone for List<T, B>

fn clone(&self) -> List<T, B>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug, B: Debug> Debug for List<T, B>

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

Formats the value using the given formatter.

impl<T: Hash, B: Hash> Hash for List<T, B>

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<'a, T, B> IntoIterator for &'a List<T, B>

type Item = &'a Indexed<Object<T, B>>

The type of the elements being iterated over.

type IntoIter = Iter<'a, Indexed<Object<T, B>>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T, B> IntoIterator for &'a mut List<T, B>

type Item = &'a mut Indexed<Object<T, B>>

The type of the elements being iterated over.

type IntoIter = IterMut<'a, Indexed<Object<T, B>>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T, B> IntoIterator for List<T, B>

type Item = Indexed<Object<T, B>>

The type of the elements being iterated over.

type IntoIter = IntoIter<Indexed<Object<T, B>>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T, B, N: Vocabulary<Iri = T, BlankId = B>> IntoJsonWithContext<N> for List<T, B>

fn into_json_with(self, vocabulary: &N) -> Value

impl<T, B, V, I: Interpretation> LinkedData<I, V> for List<T, B>

where T: LinkedDataResource<I, V> + LinkedDataSubject<I, V>, B: LinkedDataResource<I, V> + LinkedDataSubject<I, V>, V: IriVocabularyMut + Vocabulary<Iri = T>,

fn visit<S>(&self, visitor: S) -> Result<S::Ok, S::Error>

where S: Visitor<I, V>,

Visit the RDF dataset represented by this type.

impl<T, B, V, I: Interpretation> LinkedDataGraph<I, V> for List<T, B>

where T: LinkedDataResource<I, V> + LinkedDataSubject<I, V>, B: LinkedDataResource<I, V> + LinkedDataSubject<I, V>, V: IriVocabularyMut + Vocabulary<Iri = T>,

fn visit_graph<S>(&self, visitor: S) -> Result<S::Ok, S::Error>

where S: GraphVisitor<I, V>,

impl<T, B, V, I: Interpretation> LinkedDataPredicateObjects<I, V> for List<T, B>

where T: LinkedDataResource<I, V> + LinkedDataSubject<I, V>, B: LinkedDataResource<I, V> + LinkedDataSubject<I, V>, V: IriVocabularyMut + Vocabulary<Iri = T>,

fn visit_objects<S>(&self, visitor: S) -> Result<S::Ok, S::Error>

where S: PredicateObjectsVisitor<I, V>,

impl<T, B, V: Vocabulary, I: Interpretation> LinkedDataResource<I, V> for List<T, B>

fn interpretation( &self, _vocabulary: &mut V, _interpretation: &mut I, ) -> ResourceInterpretation<'_, I, V>

fn lexical_representation<'a>( &'a self, vocabulary: &'a mut V, interpretation: &'a mut I, ) -> Option<CowRdfTerm<'a, V>>

where I: ReverseTermInterpretation<Iri = <V as IriVocabulary>::Iri, BlankId = <V as BlankIdVocabulary>::BlankId, Literal = <V as LiteralVocabulary>::Literal>,

fn reference_interpretation( &self, vocabulary: &mut V, interpretation: &mut I, ) -> ResourceInterpretation<'_, I, V>

impl<T, B, V, I: Interpretation> LinkedDataSubject<I, V> for List<T, B>

where T: LinkedDataResource<I, V> + LinkedDataSubject<I, V>, B: LinkedDataResource<I, V> + LinkedDataSubject<I, V>, V: IriVocabularyMut + Vocabulary<Iri = T>,

fn visit_subject<S>(&self, visitor: S) -> Result<S::Ok, S::Error>

where S: SubjectVisitor<I, V>,

impl<T: Eq + Hash, B: Eq + Hash> MappedEq for List<T, B>

type BlankId = B

fn mapped_eq<'a, 'b, F: Clone + Fn(&'a B) -> &'b B>( &'a self, other: &Self, f: F, ) -> bool

where B: 'a + 'b,

Structural equality with mapped blank identifiers.

impl<T, B> PartialEq for List<T, B>

where T: Eq + Hash, B: Eq + Hash,

fn eq(&self, other: &Self) -> 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, B> Relabel<T, B> for List<T, B>

fn relabel_with<N: Vocabulary<Iri = T, BlankId = B>, G: Generator<N>>( &mut self, vocabulary: &mut N, generator: &mut G, relabeling: &mut HashMap<B, Subject<T, B>>, )

where T: Clone + Eq + Hash, B: Clone + Eq + Hash,

fn relabel<G: Generator>( &mut self, generator: &mut G, relabeling: &mut HashMap<B, ValidId<T, B>>, )

where T: Clone + Eq + Hash, B: Clone + Eq + Hash, (): Vocabulary<Iri = T, BlankId = B>,

impl<T, B> Eq for List<T, B>

where T: Eq + Hash, B: Eq + Hash,