Struct List

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

List object.

Implementations

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

pub fn new(objects: Vec<Indexed<Object<T, B>>>) -> List<T, B>

Creates a new list object.

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn entry(&self) -> &[Indexed<Object<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<Indexed<Object<T, B>>>

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

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

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

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

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

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

pub fn iter_mut(&mut self) -> IterMut<'_, Indexed<Object<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, B> Clone for List<T, B>

where T: Clone, B: Clone,

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, B> Debug for List<T, B>

where T: Debug, B: Debug,

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

Formats the value using the given formatter.

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

where T: Hash, B: Hash,

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

where __H: Hasher,

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) -> <&'a List<T, B> as IntoIterator>::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) -> <&'a mut List<T, B> as IntoIterator>::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) -> <List<T, B> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<T, B, N> IntoJsonWithContext<N> for List<T, B>

where N: Vocabulary<Iri = T, BlankId = B>,

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

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

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

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

where S: Visitor<I, V>,

Visit the RDF dataset represented by this type.

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

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

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

where S: GraphVisitor<I, V>,

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

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

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

where S: PredicateObjectsVisitor<I, V>,

impl<T, B, V, I> LinkedDataResource<I, V> for List<T, B>

where V: Vocabulary, I: Interpretation,

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> LinkedDataSubject<I, V> for List<T, B>

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

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

where S: SubjectVisitor<I, V>,

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

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

type BlankId = B

fn mapped_eq<'a, 'b, F>(&'a self, other: &List<T, B>, f: F) -> bool

where F: Clone + Fn(&'a B) -> &'b B, 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: &List<T, B>) -> 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, G>( &mut self, vocabulary: &mut N, generator: &mut G, relabeling: &mut HashMap<B, Id<T, B>>, )

where N: Vocabulary<Iri = T, BlankId = B>, G: Generator<N>, T: Clone + Eq + Hash, B: Clone + Eq + Hash,

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

where G: Generator, 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,