Enum json_ld::loader::RemoteDocumentReference

pub enum RemoteDocumentReference<I = Index, M = Location<I, Span>, T = Value<M>> {
    Reference(I),
    Loaded(RemoteDocument<I, M, T>),
}

Variants

Reference(I)

Loaded(RemoteDocument<I, M, T>)

Implementations

impl<I, M, T> RemoteDocumentReference<I, M, T>

pub async fn load_with<L>(
    self,
    vocabulary: &impl Sync + IriVocabulary<Iri = I>,
    loader: &mut L
) -> impl Future<Output = Result<RemoteDocument<I, M, T>, <L as Loader<I, M>>::Error>>where
    L: Loader<I, M>,
    <L as Loader<I, M>>::Output: Into<T>,

pub async fn loaded_with<L>(
    &self,
    vocabulary: &impl Sync + IriVocabulary<Iri = I>,
    loader: &mut L
) -> impl Future<Output = Result<Mown<'_, RemoteDocument<I, M, T>>, <L as Loader<I, M>>::Error>>where
    L: Loader<I, M>,
    I: Clone,
    <L as Loader<I, M>>::Output: Into<T>,

pub async fn load_context_with<L>(
    self,
    vocabulary: &impl Sync + IriVocabulary<Iri = I>,
    loader: &mut L
) -> impl Future<Output = Result<RemoteDocument<I, M, T>, <L as ContextLoader<I, M>>::ContextError>>where
    L: ContextLoader<I, M>,
    <L as ContextLoader<I, M>>::Context: Into<T>,

pub async fn loaded_context_with<L>(
    &self,
    vocabulary: &impl Sync + IriVocabulary<Iri = I>,
    loader: &mut L
) -> impl Future<Output = Result<Mown<'_, RemoteDocument<I, M, T>>, <L as ContextLoader<I, M>>::ContextError>>where
    L: ContextLoader<I, M>,
    I: Clone,
    <L as ContextLoader<I, M>>::Context: Into<T>,

Trait Implementations

impl<I, M, T> Clone for RemoteDocumentReference<I, M, T>where
    I: Clone,
    M: Clone,
    T: Clone,

fn clone(&self) -> RemoteDocumentReference<I, M, T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<I, M> JsonLdProcessor<I, M> for RemoteDocumentReference<I, M, Value<M>>

fn compare_full<'a, B, C, N, L>(
    &'a self,
    other: &'a Self,
    vocabulary: &'a mut N,
    loader: &'a mut L,
    options: Options<I, M, C>,
    warnings: impl 'a + Send + WarningHandler<N, M> + WarningHandler<B, N, M>
) -> BoxFuture<'_, CompareResult<I, M, L>>where
    I: Clone + Eq + Hash + Send + Sync,
    B: 'a + Clone + Eq + Hash + Send + Sync,
    C: 'a + ProcessMeta<I, B, M> + From<Value<M>>,
    N: Send + Sync + VocabularyMut<Iri = I, BlankId = B>,
    M: Clone + Send + Sync,
    L: Loader<I, M> + ContextLoader<I, M> + Send + Sync,
    L::Output: Into<Value<M>>,
    L::Error: Send,
    L::Context: Into<C>,
    L::ContextError: Send,

fn expand_full<'a, B, C, N, L>(
    &'a self,
    vocabulary: &'a mut N,
    loader: &'a mut L,
    options: Options<I, M, C>,
    warnings: impl 'a + Send + WarningHandler<N, M> + WarningHandler<B, N, M>
) -> BoxFuture<'_, ExpandResult<I, B, M, L>>where
    I: Clone + Eq + Hash + Send + Sync,
    B: 'a + Clone + Eq + Hash + Send + Sync,
    C: 'a + ProcessMeta<I, B, M> + From<Value<M>>,
    N: Send + Sync + VocabularyMut<Iri = I, BlankId = B>,
    M: Clone + Send + Sync,
    L: Loader<I, M> + ContextLoader<I, M> + Send + Sync,
    L::Output: Into<Value<M>>,
    L::Error: Send,
    L::Context: Into<C>,
    L::ContextError: Send,

fn compact_full<'a, B, C, N, L>(
    &'a self,
    vocabulary: &'a mut N,
    context: RemoteDocumentReference<I, M, C>,
    loader: &'a mut L,
    options: Options<I, M, C>,
    warnings: impl 'a + Send + WarningHandler<N, M> + WarningHandler<B, N, M>
) -> BoxFuture<'a, CompactResult<I, M, L>>where
    I: Clone + Eq + Hash + Send + Sync,
    B: 'a + Clone + Eq + Hash + Send + Sync,
    C: 'a + ProcessMeta<I, B, M> + From<Value<M>>,
    N: Send + Sync + VocabularyMut<Iri = I, BlankId = B>,
    M: Clone + Send + Sync,
    L: Loader<I, M> + ContextLoader<I, M> + Send + Sync,
    L::Output: Into<Value<M>>,
    L::Error: Send,
    L::Context: Into<C>,
    L::ContextError: Send,

fn flatten_full<'a, B, C, N, L>(
    &'a self,
    vocabulary: &'a mut N,
    generator: &'a mut impl Send + Generator<I, B, M, N>,
    context: Option<RemoteDocumentReference<I, M, C>>,
    loader: &'a mut L,
    options: Options<I, M, C>,
    warnings: impl 'a + Send + WarningHandler<N, M> + WarningHandler<B, N, M>
) -> BoxFuture<'a, Result<MetaValue<M>, FlattenError<I, B, M, <L as Loader<I, M>>::Error, <L as ContextLoader<I, M>>::ContextError>>>where
    I: Clone + Eq + Hash + Send + Sync,
    B: 'a + Clone + Eq + Hash + Send + Sync,
    C: 'a + ProcessMeta<I, B, M> + From<Value<M>>,
    N: Send + Sync + VocabularyMut<Iri = I, BlankId = B>,
    M: Clone + Send + Sync,
    L: Loader<I, M> + ContextLoader<I, M> + Send + Sync,
    L::Output: Into<Value<M>>,
    L::Error: Send,
    L::Context: Into<C>,
    L::ContextError: Send,