Trait json_ld::JsonLdProcessor
source · pub trait JsonLdProcessor<I, M> {
Show 25 methods
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<N, M>,
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;
fn compare_with_using<'a, B, C, N, L>(
&'a self,
other: &'a Self,
vocabulary: &'a mut N,
loader: &'a mut L,
options: Options<I, M, C>
) -> 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 compare_with<'a, B, N, L>(
&'a self,
other: &'a Self,
vocabulary: &'a mut N,
loader: &'a mut L
) -> BoxFuture<'_, CompareResult<I, M, L>>
where
I: Clone + Eq + Hash + Send + Sync,
B: 'a + Clone + Eq + Hash + Send + Sync,
N: Send + Sync + VocabularyMut<Iri = I, BlankId = B>,
M: 'a + Clone + Send + Sync,
L: Loader<I, M> + ContextLoader<I, M> + Send + Sync,
L::Output: Into<Value<M>>,
L::Error: Send,
L::Context: Into<Value<M>>,
L::ContextError: Send,
{ ... }
fn compare_using<'a, B, C, L>(
&'a self,
other: &'a Self,
loader: &'a mut L,
options: Options<I, M, C>
) -> 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>>,
(): 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 compare<'a, B, L>(
&'a self,
other: &'a Self,
loader: &'a mut L
) -> BoxFuture<'_, CompareResult<I, M, L>>
where
I: Clone + Eq + Hash + Send + Sync,
B: 'a + Clone + Eq + Hash + Send + Sync,
(): Send + Sync + VocabularyMut<Iri = I, BlankId = B>,
M: 'a + Clone + Send + Sync,
L: Loader<I, M> + ContextLoader<I, M> + Send + Sync,
L::Output: Into<Value<M>>,
L::Error: Send,
L::Context: Into<Value<M>>,
L::ContextError: Send,
{ ... }
fn expand_with_using<'a, B, C, N, L>(
&'a self,
vocabulary: &'a mut N,
loader: &'a mut L,
options: Options<I, M, C>
) -> 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 expand_with<'a, B, N, L>(
&'a self,
vocabulary: &'a mut N,
loader: &'a mut L
) -> BoxFuture<'_, ExpandResult<I, B, M, L>>
where
I: Clone + Eq + Hash + Send + Sync,
B: 'a + Clone + Eq + Hash + Send + Sync,
N: Send + Sync + VocabularyMut<Iri = I, BlankId = B>,
M: 'a + Clone + Send + Sync,
L: Loader<I, M> + ContextLoader<I, M> + Send + Sync,
L::Output: Into<Value<M>>,
L::Error: Send,
L::Context: Into<Value<M>>,
L::ContextError: Send,
{ ... }
fn expand_using<'a, B, C, L>(
&'a self,
loader: &'a mut L,
options: Options<I, M, C>
) -> 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>>,
(): 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<'a, B, L>(
&'a self,
loader: &'a mut L
) -> BoxFuture<'_, ExpandResult<I, B, M, L>>
where
I: Clone + Eq + Hash + Send + Sync,
B: 'a + Clone + Eq + Hash + Send + Sync,
(): Send + Sync + VocabularyMut<Iri = I, BlankId = B>,
M: 'a + Clone + Send + Sync,
L: Loader<I, M> + ContextLoader<I, M> + Send + Sync,
L::Output: Into<Value<M>>,
L::Error: Send,
L::Context: Into<Value<M>>,
L::ContextError: Send,
{ ... }
fn compact_with_using<'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>
) -> 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 compact_with<'a, B, C, N, L>(
&'a self,
vocabulary: &'a mut N,
context: RemoteDocumentReference<I, M, C>,
loader: &'a mut L
) -> 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 compact_using<'a, B, C, L>(
&'a self,
context: RemoteDocumentReference<I, M, C>,
loader: &'a mut L,
options: Options<I, M, C>
) -> 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>>,
(): 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<'a, B, C, L>(
&'a self,
context: RemoteDocumentReference<I, M, C>,
loader: &'a mut L
) -> 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>>,
(): 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_with_using<'a, B, C, N, L>(
&'a self,
vocabulary: &'a mut N,
generator: &'a mut impl Send + Generator<N, M>,
loader: &'a mut L,
options: Options<I, M, C>
) -> 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,
{ ... }
fn flatten_with<'a, B, N, L>(
&'a self,
vocabulary: &'a mut N,
generator: &'a mut impl Send + Generator<N, M>,
loader: &'a mut L
) -> 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,
N: Send + Sync + VocabularyMut<Iri = I, BlankId = B>,
M: 'a + Clone + Send + Sync,
L: Loader<I, M> + ContextLoader<I, M> + Send + Sync,
L::Output: Into<Value<M>>,
L::Error: Send,
L::Context: Into<Value<M>>,
L::ContextError: Send,
{ ... }
fn flatten_using<'a, B, C, L>(
&'a self,
generator: &'a mut impl Send + Generator<(), M>,
loader: &'a mut L,
options: Options<I, M, C>
) -> 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>>,
(): 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<'a, B, L>(
&'a self,
generator: &'a mut impl Send + Generator<(), M>,
loader: &'a mut L
) -> 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,
(): Send + Sync + VocabularyMut<Iri = I, BlankId = B>,
M: 'a + Clone + Send + Sync,
L: Loader<I, M> + ContextLoader<I, M> + Send + Sync,
L::Output: Into<Value<M>>,
L::Error: Send,
L::Context: Into<Value<M>>,
L::ContextError: Send,
{ ... }
fn to_rdf_full<'a, B, C, N, G, L>(
&'a self,
vocabulary: &'a mut N,
generator: &'a mut G,
loader: &'a mut L,
options: Options<I, M, C>,
warnings: impl 'a + Send + WarningHandler<N, M> + WarningHandler<B, N, M>
) -> BoxFuture<'_, ToRdfResult<'a, N, M, G, L>>
where
I: 'a + 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: 'a + Clone + Send + Sync,
G: Send + Generator<N, M>,
L: Loader<I, M> + ContextLoader<I, M> + Send + Sync,
L::Output: Into<Value<M>>,
L::Error: Send,
L::Context: Into<C>,
L::ContextError: Send,
Self: Sync,
{ ... }
fn to_rdf_with_using<'a, B, C, N, G, L>(
&'a self,
vocabulary: &'a mut N,
generator: &'a mut G,
loader: &'a mut L,
options: Options<I, M, C>
) -> BoxFuture<'_, ToRdfResult<'a, N, M, G, L>>
where
I: 'a + 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: 'a + Clone + Send + Sync,
G: Send + Generator<N, M>,
L: Loader<I, M> + ContextLoader<I, M> + Send + Sync,
L::Output: Into<Value<M>>,
L::Error: Send,
L::Context: Into<C>,
L::ContextError: Send,
Self: Sync,
{ ... }
fn to_rdf_with<'a, B, N, G, L>(
&'a self,
vocabulary: &'a mut N,
generator: &'a mut G,
loader: &'a mut L
) -> BoxFuture<'_, ToRdfResult<'a, N, M, G, L>>
where
I: 'a + Clone + Eq + Hash + Send + Sync,
B: 'a + Clone + Eq + Hash + Send + Sync,
N: Send + Sync + VocabularyMut<Iri = I, BlankId = B>,
M: 'a + Clone + Send + Sync,
G: Send + Generator<N, M>,
L: Loader<I, M> + ContextLoader<I, M> + Send + Sync,
L::Output: Into<Value<M>>,
L::Error: Send,
L::Context: Into<Value<M>>,
L::ContextError: Send,
Self: Sync,
{ ... }
fn to_rdf_using<'a, B, C, G, L>(
&'a self,
generator: &'a mut G,
loader: &'a mut L,
options: Options<I, M, C>
) -> BoxFuture<'_, ToRdfResult<'a, (), M, G, L>>
where
I: 'a + Clone + Eq + Hash + Send + Sync,
B: 'a + Clone + Eq + Hash + Send + Sync,
C: 'a + ProcessMeta<I, B, M> + From<Value<M>>,
(): VocabularyMut<Iri = I, BlankId = B>,
M: 'a + Clone + Send + Sync,
G: Send + Generator<(), M>,
L: Loader<I, M> + ContextLoader<I, M> + Send + Sync,
L::Output: Into<Value<M>>,
L::Error: Send,
L::Context: Into<C>,
L::ContextError: Send,
Self: Sync,
{ ... }
fn to_rdf<'a, B, G, L>(
&'a self,
generator: &'a mut G,
loader: &'a mut L
) -> BoxFuture<'_, ToRdfResult<'a, (), M, G, L>>
where
I: 'a + Clone + Eq + Hash + Send + Sync,
B: 'a + Clone + Eq + Hash + Send + Sync,
(): VocabularyMut<Iri = I, BlankId = B>,
M: 'a + Clone + Send + Sync,
G: Send + Generator<(), M>,
L: Loader<I, M> + ContextLoader<I, M> + Send + Sync,
L::Output: Into<Value<M>>,
L::Error: Send,
L::Context: Into<Value<M>>,
L::ContextError: Send,
Self: Sync,
{ ... }
}
Expand description
Application Programming Interface.
The JsonLdProcessor
interface is the high-level programming structure that
developers use to access the JSON-LD transformation methods.
It is notably implemented for the RemoteDocument<I, M, json_syntax::Value<M>>
and RemoteDocumentReference<I, M, json_syntax::Value<M>>
types.
Methods naming
Each processing function is declined in four variants depending on your needs, with the following suffix convention:
_full
: function with all the possible options. This is the only way to specify a custom warning handler._with
: allows passing a customVocabulary
._using
: allows passing customOptions
._with_using
: allows passing both a customVocabulary
and customOptions
.- no suffix: minimum parameters. No custom vocabulary:
IriBuf
andBlankIdBuf
must be used as IRI and blank node id respectively.
Example
use static_iref::iri;
use json_ld::{JsonLdProcessor, RemoteDocumentReference};
let input = RemoteDocumentReference::iri(iri!("https://example.com/sample.jsonld").to_owned());
// Use `FsLoader` to redirect any URL starting with `https://example.com/` to
// the local `example` directory. No HTTP query.
let mut loader = json_ld::FsLoader::default();
loader.mount(iri!("https://example.com/").to_owned(), "examples");
let expanded = input.expand(&mut loader)
.await
.expect("expansion failed");
Required Methods§
sourcefn 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 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,
Compare this document against other
with a custom vocabulary using the
given options
and warnings handler.
Example
use static_iref::iri;
use json_ld::{JsonLdProcessor, Options, RemoteDocumentReference, warning};
use rdf_types::IriVocabularyMut;
use locspan::Meta;
let mut vocabulary: rdf_types::IndexVocabulary = rdf_types::IndexVocabulary::new();
let iri = vocabulary.insert(iri!("https://example.com/sample.jsonld"));
let input1 = RemoteDocumentReference::iri(iri);
let input2 = RemoteDocumentReference::iri(iri);
// Use `FsLoader` to redirect any URL starting with `https://example.com/` to
// the local `example` directory. No HTTP query.
let mut loader = json_ld::FsLoader::default();
loader.mount(vocabulary.insert(iri!("https://example.com/")), "examples");
assert!(input1.compare_full(
&input2,
&mut vocabulary,
&mut loader,
Options::<_, _>::default(),
warning::PrintWith
).await.expect("comparison failed"));
sourcefn 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 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,
Expand the document with the given vocabulary
and loader
, using
the given options
and warning handler.
On success, the result is an ExpandedDocument
.
Example
use static_iref::iri;
use json_ld::{JsonLdProcessor, Options, RemoteDocumentReference, warning};
use rdf_types::IriVocabularyMut;
// Creates the vocabulary that will map each `rdf_types::vocabulary::Index`
// to an actual `IriBuf`.
let mut vocabulary: rdf_types::IndexVocabulary = rdf_types::IndexVocabulary::new();
let iri_index = vocabulary.insert(iri!("https://example.com/sample.jsonld"));
let input = RemoteDocumentReference::iri(iri_index);
// Use `FsLoader` to redirect any URL starting with `https://example.com/` to
// the local `example` directory. No HTTP query.
let mut loader = json_ld::FsLoader::default();
loader.mount(vocabulary.insert(iri!("https://example.com/")), "examples");
let expanded = input
.expand_full(
&mut vocabulary,
&mut loader,
Options::<_, _>::default(),
warning::PrintWith
)
.await
.expect("expansion failed");
sourcefn 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 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,
Compact the document relative to context
with the given vocabulary
and loader
, using the given options
and warning handler.
On success, the result is an syntax::Value
wrapped inside a
Meta
.
Example
use static_iref::iri;
use json_ld::{JsonLdProcessor, Options, RemoteDocumentReference, warning};
use rdf_types::IriVocabularyMut;
// Creates the vocabulary that will map each `rdf_types::vocabulary::Index`
// to an actual `IriBuf`.
let mut vocabulary: rdf_types::IndexVocabulary = rdf_types::IndexVocabulary::new();
let iri_index = vocabulary.insert(iri!("https://example.com/sample.jsonld"));
let input = RemoteDocumentReference::iri(iri_index);
let context_iri_index = vocabulary.insert(iri!("https://example.com/context.jsonld"));
let context = RemoteDocumentReference::context_iri(context_iri_index);
// Use `FsLoader` to redirect any URL starting with `https://example.com/` to
// the local `example` directory. No HTTP query.
let mut loader = json_ld::FsLoader::default();
loader.mount(vocabulary.insert(iri!("https://example.com/")), "examples");
let compact = input
.compact_full(
&mut vocabulary,
context,
&mut loader,
Options::<_, _>::default(),
warning::PrintWith
)
.await
.expect("compaction failed");
sourcefn flatten_full<'a, B, C, N, L>(
&'a self,
vocabulary: &'a mut N,
generator: &'a mut impl Send + Generator<N, M>,
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,
fn flatten_full<'a, B, C, N, L>(
&'a self,
vocabulary: &'a mut N,
generator: &'a mut impl Send + Generator<N, M>,
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,
Flatten the document with the given vocabulary
, generator
and loader
, using the given options
and warning handler.
An optional context
can be given to compact the document.
Flattening requires assigning an identifier to nested anonymous nodes,
which is why the flattening functions take an rdf_types::MetaGenerator
as parameter. This generator is in charge of creating new fresh identifiers
(with their metadata). The most common generator is
rdf_types::generator::Blank
that creates blank node identifiers.
On success, the result is a
FlattenedDocument
, which is a list of
indexed nodes.
Example
use static_iref::iri;
use json_ld::{JsonLdProcessor, Options, RemoteDocumentReference, warning};
use rdf_types::IriVocabularyMut;
use locspan::{Location, Span};
// Creates the vocabulary that will map each `rdf_types::vocabulary::Index`
// to an actual `IriBuf`.
let mut vocabulary: rdf_types::IndexVocabulary = rdf_types::IndexVocabulary::new();
let iri_index = vocabulary.insert(iri!("https://example.com/sample.jsonld"));
let input = RemoteDocumentReference::iri(iri_index);
// Use `FsLoader` to redirect any URL starting with `https://example.com/` to
// the local `example` directory. No HTTP query.
let mut loader = json_ld::FsLoader::default();
loader.mount(vocabulary.insert(iri!("https://example.com/")), "examples");
let mut generator = rdf_types::generator::Blank::new().with_metadata(
// Each blank id will be associated to the document URL with a dummy span.
Location::new(vocabulary.insert(iri!("https://example.com/")), Span::default())
);
let nodes = input
.flatten_full(
&mut vocabulary,
&mut generator,
None,
&mut loader,
Options::<_, _>::default(),
warning::PrintWith
)
.await
.expect("flattening failed");
Provided Methods§
sourcefn compare_with_using<'a, B, C, N, L>(
&'a self,
other: &'a Self,
vocabulary: &'a mut N,
loader: &'a mut L,
options: Options<I, M, C>
) -> 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 compare_with_using<'a, B, C, N, L>(
&'a self,
other: &'a Self,
vocabulary: &'a mut N,
loader: &'a mut L,
options: Options<I, M, C>
) -> 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,
Compare this document against other
with a custom vocabulary using the
given options
.
Warnings are ignored.
Example
use static_iref::iri;
use json_ld::{JsonLdProcessor, Options, RemoteDocumentReference};
use rdf_types::IriVocabularyMut;
use locspan::Meta;
let mut vocabulary: rdf_types::IndexVocabulary = rdf_types::IndexVocabulary::new();
let iri = vocabulary.insert(iri!("https://example.com/sample.jsonld"));
let input1 = RemoteDocumentReference::iri(iri);
let input2 = RemoteDocumentReference::iri(iri);
// Use `FsLoader` to redirect any URL starting with `https://example.com/` to
// the local `example` directory. No HTTP query.
let mut loader = json_ld::FsLoader::default();
loader.mount(vocabulary.insert(iri!("https://example.com/")), "examples");
assert!(input1.compare_with_using(
&input2,
&mut vocabulary,
&mut loader,
Options::<_, _>::default()
).await.expect("comparison failed"));
sourcefn compare_with<'a, B, N, L>(
&'a self,
other: &'a Self,
vocabulary: &'a mut N,
loader: &'a mut L
) -> BoxFuture<'_, CompareResult<I, M, L>>where
I: Clone + Eq + Hash + Send + Sync,
B: 'a + Clone + Eq + Hash + Send + Sync,
N: Send + Sync + VocabularyMut<Iri = I, BlankId = B>,
M: 'a + Clone + Send + Sync,
L: Loader<I, M> + ContextLoader<I, M> + Send + Sync,
L::Output: Into<Value<M>>,
L::Error: Send,
L::Context: Into<Value<M>>,
L::ContextError: Send,
fn compare_with<'a, B, N, L>(
&'a self,
other: &'a Self,
vocabulary: &'a mut N,
loader: &'a mut L
) -> BoxFuture<'_, CompareResult<I, M, L>>where
I: Clone + Eq + Hash + Send + Sync,
B: 'a + Clone + Eq + Hash + Send + Sync,
N: Send + Sync + VocabularyMut<Iri = I, BlankId = B>,
M: 'a + Clone + Send + Sync,
L: Loader<I, M> + ContextLoader<I, M> + Send + Sync,
L::Output: Into<Value<M>>,
L::Error: Send,
L::Context: Into<Value<M>>,
L::ContextError: Send,
Compare this document against other
with a custom vocabulary.
Default options are used. Warnings are ignored.
Example
use static_iref::iri;
use json_ld::{JsonLdProcessor, Options, RemoteDocumentReference};
use rdf_types::IriVocabularyMut;
use locspan::Meta;
let mut vocabulary: rdf_types::IndexVocabulary = rdf_types::IndexVocabulary::new();
let iri = vocabulary.insert(iri!("https://example.com/sample.jsonld"));
let input1 = RemoteDocumentReference::iri(iri);
let input2 = RemoteDocumentReference::iri(iri);
// Use `FsLoader` to redirect any URL starting with `https://example.com/` to
// the local `example` directory. No HTTP query.
let mut loader = json_ld::FsLoader::default();
loader.mount(vocabulary.insert(iri!("https://example.com/")), "examples");
assert!(input1.compare_with(
&input2,
&mut vocabulary,
&mut loader
).await.expect("comparison failed"));
sourcefn compare_using<'a, B, C, L>(
&'a self,
other: &'a Self,
loader: &'a mut L,
options: Options<I, M, C>
) -> 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>>,
(): 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 compare_using<'a, B, C, L>(
&'a self,
other: &'a Self,
loader: &'a mut L,
options: Options<I, M, C>
) -> 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>>,
(): 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,
Compare this document against other
using the given options
.
Warnings are ignored.
Example
use static_iref::iri;
use json_ld::{JsonLdProcessor, Options, RemoteDocumentReference};
use locspan::Meta;
let iri = iri!("https://example.com/sample.jsonld").to_owned();
let input1 = RemoteDocumentReference::iri(iri.clone());
let input2 = RemoteDocumentReference::iri(iri);
// Use `FsLoader` to redirect any URL starting with `https://example.com/` to
// the local `example` directory. No HTTP query.
let mut loader = json_ld::FsLoader::default();
loader.mount(iri!("https://example.com/").to_owned(), "examples");
assert!(input1.compare_using(
&input2,
&mut loader,
Options::<_, _>::default()
).await.expect("comparison failed"));
sourcefn compare<'a, B, L>(
&'a self,
other: &'a Self,
loader: &'a mut L
) -> BoxFuture<'_, CompareResult<I, M, L>>where
I: Clone + Eq + Hash + Send + Sync,
B: 'a + Clone + Eq + Hash + Send + Sync,
(): Send + Sync + VocabularyMut<Iri = I, BlankId = B>,
M: 'a + Clone + Send + Sync,
L: Loader<I, M> + ContextLoader<I, M> + Send + Sync,
L::Output: Into<Value<M>>,
L::Error: Send,
L::Context: Into<Value<M>>,
L::ContextError: Send,
fn compare<'a, B, L>(
&'a self,
other: &'a Self,
loader: &'a mut L
) -> BoxFuture<'_, CompareResult<I, M, L>>where
I: Clone + Eq + Hash + Send + Sync,
B: 'a + Clone + Eq + Hash + Send + Sync,
(): Send + Sync + VocabularyMut<Iri = I, BlankId = B>,
M: 'a + Clone + Send + Sync,
L: Loader<I, M> + ContextLoader<I, M> + Send + Sync,
L::Output: Into<Value<M>>,
L::Error: Send,
L::Context: Into<Value<M>>,
L::ContextError: Send,
Compare this document against other
with a custom vocabulary.
Default options are used. Warnings are ignored.
Example
use static_iref::iri;
use json_ld::{JsonLdProcessor, Options, RemoteDocumentReference};
use locspan::Meta;
let iri = iri!("https://example.com/sample.jsonld").to_owned();
let input1 = RemoteDocumentReference::iri(iri.clone());
let input2 = RemoteDocumentReference::iri(iri);
// Use `FsLoader` to redirect any URL starting with `https://example.com/` to
// the local `example` directory. No HTTP query.
let mut loader = json_ld::FsLoader::default();
loader.mount(iri!("https://example.com/").to_owned(), "examples");
assert!(input1.compare(
&input2,
&mut loader
).await.expect("comparison failed"));
sourcefn expand_with_using<'a, B, C, N, L>(
&'a self,
vocabulary: &'a mut N,
loader: &'a mut L,
options: Options<I, M, C>
) -> 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 expand_with_using<'a, B, C, N, L>(
&'a self,
vocabulary: &'a mut N,
loader: &'a mut L,
options: Options<I, M, C>
) -> 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,
Expand the document with the given vocabulary
and loader
, using
the given options
.
Warnings are ignored.
On success, the result is an ExpandedDocument
.
Example
use static_iref::iri;
use json_ld::{JsonLdProcessor, Options, RemoteDocumentReference, warning};
use rdf_types::IriVocabularyMut;
// Creates the vocabulary that will map each `rdf_types::vocabulary::Index`
// to an actual `IriBuf`.
let mut vocabulary: rdf_types::IndexVocabulary = rdf_types::IndexVocabulary::new();
let iri_index = vocabulary.insert(iri!("https://example.com/sample.jsonld"));
let input = RemoteDocumentReference::iri(iri_index);
// Use `FsLoader` to redirect any URL starting with `https://example.com/` to
// the local `example` directory. No HTTP query.
let mut loader = json_ld::FsLoader::default();
loader.mount(vocabulary.insert(iri!("https://example.com/")), "examples");
let expanded = input
.expand_with_using(
&mut vocabulary,
&mut loader,
Options::<_, _>::default()
)
.await
.expect("expansion failed");
sourcefn expand_with<'a, B, N, L>(
&'a self,
vocabulary: &'a mut N,
loader: &'a mut L
) -> BoxFuture<'_, ExpandResult<I, B, M, L>>where
I: Clone + Eq + Hash + Send + Sync,
B: 'a + Clone + Eq + Hash + Send + Sync,
N: Send + Sync + VocabularyMut<Iri = I, BlankId = B>,
M: 'a + Clone + Send + Sync,
L: Loader<I, M> + ContextLoader<I, M> + Send + Sync,
L::Output: Into<Value<M>>,
L::Error: Send,
L::Context: Into<Value<M>>,
L::ContextError: Send,
fn expand_with<'a, B, N, L>(
&'a self,
vocabulary: &'a mut N,
loader: &'a mut L
) -> BoxFuture<'_, ExpandResult<I, B, M, L>>where
I: Clone + Eq + Hash + Send + Sync,
B: 'a + Clone + Eq + Hash + Send + Sync,
N: Send + Sync + VocabularyMut<Iri = I, BlankId = B>,
M: 'a + Clone + Send + Sync,
L: Loader<I, M> + ContextLoader<I, M> + Send + Sync,
L::Output: Into<Value<M>>,
L::Error: Send,
L::Context: Into<Value<M>>,
L::ContextError: Send,
Expand the document with the given vocabulary
and loader
.
Default options are used.
Warnings are ignored.
On success, the result is an ExpandedDocument
.
Example
use static_iref::iri;
use json_ld::{JsonLdProcessor, Options, RemoteDocumentReference, warning};
use rdf_types::IriVocabularyMut;
// Creates the vocabulary that will map each `rdf_types::vocabulary::Index`
// to an actual `IriBuf`.
let mut vocabulary: rdf_types::IndexVocabulary = rdf_types::IndexVocabulary::new();
let iri_index = vocabulary.insert(iri!("https://example.com/sample.jsonld"));
let input = RemoteDocumentReference::iri(iri_index);
// Use `FsLoader` to redirect any URL starting with `https://example.com/` to
// the local `example` directory. No HTTP query.
let mut loader = json_ld::FsLoader::default();
loader.mount(vocabulary.insert(iri!("https://example.com/")), "examples");
let expanded = input
.expand_with(
&mut vocabulary,
&mut loader
)
.await
.expect("expansion failed");
sourcefn expand_using<'a, B, C, L>(
&'a self,
loader: &'a mut L,
options: Options<I, M, C>
) -> 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>>,
(): 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_using<'a, B, C, L>(
&'a self,
loader: &'a mut L,
options: Options<I, M, C>
) -> 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>>,
(): 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,
Expand the document with the given loader
using the given options
.
Warnings are ignored.
On success, the result is an ExpandedDocument
.
Example
use static_iref::iri;
use json_ld::{JsonLdProcessor, Options, RemoteDocumentReference, warning};
let iri = iri!("https://example.com/sample.jsonld").to_owned();
let input = RemoteDocumentReference::iri(iri);
// Use `FsLoader` to redirect any URL starting with `https://example.com/` to
// the local `example` directory. No HTTP query.
let mut loader = json_ld::FsLoader::default();
loader.mount(iri!("https://example.com/").to_owned(), "examples");
let expanded = input
.expand_using(
&mut loader,
Options::<_, _>::default()
)
.await
.expect("expansion failed");
sourcefn expand<'a, B, L>(
&'a self,
loader: &'a mut L
) -> BoxFuture<'_, ExpandResult<I, B, M, L>>where
I: Clone + Eq + Hash + Send + Sync,
B: 'a + Clone + Eq + Hash + Send + Sync,
(): Send + Sync + VocabularyMut<Iri = I, BlankId = B>,
M: 'a + Clone + Send + Sync,
L: Loader<I, M> + ContextLoader<I, M> + Send + Sync,
L::Output: Into<Value<M>>,
L::Error: Send,
L::Context: Into<Value<M>>,
L::ContextError: Send,
fn expand<'a, B, L>(
&'a self,
loader: &'a mut L
) -> BoxFuture<'_, ExpandResult<I, B, M, L>>where
I: Clone + Eq + Hash + Send + Sync,
B: 'a + Clone + Eq + Hash + Send + Sync,
(): Send + Sync + VocabularyMut<Iri = I, BlankId = B>,
M: 'a + Clone + Send + Sync,
L: Loader<I, M> + ContextLoader<I, M> + Send + Sync,
L::Output: Into<Value<M>>,
L::Error: Send,
L::Context: Into<Value<M>>,
L::ContextError: Send,
Expand the document with the given loader
.
Default options are used.
Warnings are ignored.
On success, the result is an ExpandedDocument
.
Example
use static_iref::iri;
use json_ld::{JsonLdProcessor, Options, RemoteDocumentReference, warning};
let iri = iri!("https://example.com/sample.jsonld").to_owned();
let input = RemoteDocumentReference::iri(iri);
// Use `FsLoader` to redirect any URL starting with `https://example.com/` to
// the local `example` directory. No HTTP query.
let mut loader = json_ld::FsLoader::default();
loader.mount(iri!("https://example.com/").to_owned(), "examples");
let expanded = input
.expand(&mut loader)
.await
.expect("expansion failed");
sourcefn compact_with_using<'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>
) -> 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 compact_with_using<'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>
) -> 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,
Compact the document relative to context
with the given vocabulary
and loader
, using the given options
.
Warnings are ignored.
On success, the result is an syntax::Value
wrapped inside a
Meta
.
Example
use static_iref::iri;
use json_ld::{JsonLdProcessor, Options, RemoteDocumentReference, warning};
use rdf_types::IriVocabularyMut;
// Creates the vocabulary that will map each `rdf_types::vocabulary::Index`
// to an actual `IriBuf`.
let mut vocabulary: rdf_types::IndexVocabulary = rdf_types::IndexVocabulary::new();
let iri_index = vocabulary.insert(iri!("https://example.com/sample.jsonld"));
let input = RemoteDocumentReference::iri(iri_index);
let context_iri_index = vocabulary.insert(iri!("https://example.com/context.jsonld"));
let context = RemoteDocumentReference::context_iri(context_iri_index);
// Use `FsLoader` to redirect any URL starting with `https://example.com/` to
// the local `example` directory. No HTTP query.
let mut loader = json_ld::FsLoader::default();
loader.mount(vocabulary.insert(iri!("https://example.com/")), "examples");
let compact = input
.compact_with_using(
&mut vocabulary,
context,
&mut loader,
Options::<_, _>::default()
)
.await
.expect("compaction failed");
sourcefn compact_with<'a, B, C, N, L>(
&'a self,
vocabulary: &'a mut N,
context: RemoteDocumentReference<I, M, C>,
loader: &'a mut L
) -> 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 compact_with<'a, B, C, N, L>(
&'a self,
vocabulary: &'a mut N,
context: RemoteDocumentReference<I, M, C>,
loader: &'a mut L
) -> 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,
Compact the document relative to context
with the given vocabulary
and loader
.
Default options are used.
Warnings are ignored.
On success, the result is an syntax::Value
wrapped inside a
Meta
.
Example
use static_iref::iri;
use json_ld::{JsonLdProcessor, Options, RemoteDocumentReference, warning};
use rdf_types::IriVocabularyMut;
// Creates the vocabulary that will map each `rdf_types::vocabulary::Index`
// to an actual `IriBuf`.
let mut vocabulary: rdf_types::IndexVocabulary = rdf_types::IndexVocabulary::new();
let iri_index = vocabulary.insert(iri!("https://example.com/sample.jsonld"));
let input = RemoteDocumentReference::iri(iri_index);
let context_iri_index = vocabulary.insert(iri!("https://example.com/context.jsonld"));
let context = RemoteDocumentReference::context_iri(context_iri_index);
// Use `FsLoader` to redirect any URL starting with `https://example.com/` to
// the local `example` directory. No HTTP query.
let mut loader = json_ld::FsLoader::default();
loader.mount(vocabulary.insert(iri!("https://example.com/")), "examples");
let compact = input
.compact_with(
&mut vocabulary,
context,
&mut loader
)
.await
.expect("compaction failed");
sourcefn compact_using<'a, B, C, L>(
&'a self,
context: RemoteDocumentReference<I, M, C>,
loader: &'a mut L,
options: Options<I, M, C>
) -> 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>>,
(): 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_using<'a, B, C, L>(
&'a self,
context: RemoteDocumentReference<I, M, C>,
loader: &'a mut L,
options: Options<I, M, C>
) -> 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>>,
(): 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,
Compact the document relative to context
with the given loader
,
using the given options
.
Warnings are ignored.
On success, the result is an syntax::Value
wrapped inside a
Meta
.
Example
use static_iref::iri;
use json_ld::{JsonLdProcessor, Options, RemoteDocumentReference, warning};
let iri = iri!("https://example.com/sample.jsonld").to_owned();
let input = RemoteDocumentReference::iri(iri);
let context_iri = iri!("https://example.com/context.jsonld").to_owned();
let context = RemoteDocumentReference::context_iri(context_iri);
// Use `FsLoader` to redirect any URL starting with `https://example.com/` to
// the local `example` directory. No HTTP query.
let mut loader = json_ld::FsLoader::default();
loader.mount(iri!("https://example.com/").to_owned(), "examples");
let compact = input
.compact_using(
context,
&mut loader,
Options::<_, _>::default()
)
.await
.expect("compaction failed");
sourcefn compact<'a, B, C, L>(
&'a self,
context: RemoteDocumentReference<I, M, C>,
loader: &'a mut L
) -> 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>>,
(): 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<'a, B, C, L>(
&'a self,
context: RemoteDocumentReference<I, M, C>,
loader: &'a mut L
) -> 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>>,
(): 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,
Compact the document relative to context
with the given loader
.
Default options are used.
Warnings are ignored.
On success, the result is an syntax::Value
wrapped inside a
Meta
.
Example
use static_iref::iri;
use json_ld::{JsonLdProcessor, Options, RemoteDocumentReference, warning};
let iri = iri!("https://example.com/sample.jsonld").to_owned();
let input = RemoteDocumentReference::iri(iri);
let context_iri = iri!("https://example.com/context.jsonld").to_owned();
let context = RemoteDocumentReference::context_iri(context_iri);
// Use `FsLoader` to redirect any URL starting with `https://example.com/` to
// the local `example` directory. No HTTP query.
let mut loader = json_ld::FsLoader::default();
loader.mount(iri!("https://example.com/").to_owned(), "examples");
let compact = input
.compact(
context,
&mut loader
)
.await
.expect("compaction failed");
sourcefn flatten_with_using<'a, B, C, N, L>(
&'a self,
vocabulary: &'a mut N,
generator: &'a mut impl Send + Generator<N, M>,
loader: &'a mut L,
options: Options<I, M, C>
) -> 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,
fn flatten_with_using<'a, B, C, N, L>(
&'a self,
vocabulary: &'a mut N,
generator: &'a mut impl Send + Generator<N, M>,
loader: &'a mut L,
options: Options<I, M, C>
) -> 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,
Flatten the document with the given vocabulary
, generator
and loader
, using the given options
.
Flattening requires assigning an identifier to nested anonymous nodes,
which is why the flattening functions take an rdf_types::MetaGenerator
as parameter. This generator is in charge of creating new fresh identifiers
(with their metadata). The most common generator is
rdf_types::generator::Blank
that creates blank node identifiers.
Warnings are ignored.
On success, the result is a
FlattenedDocument
, which is a list of
indexed nodes.
Example
use static_iref::iri;
use json_ld::{JsonLdProcessor, Options, RemoteDocumentReference, warning};
use rdf_types::IriVocabularyMut;
use locspan::{Location, Span};
// Creates the vocabulary that will map each `rdf_types::vocabulary::Index`
// to an actual `IriBuf`.
let mut vocabulary: rdf_types::IndexVocabulary = rdf_types::IndexVocabulary::new();
let iri_index = vocabulary.insert(iri!("https://example.com/sample.jsonld"));
let input = RemoteDocumentReference::iri(iri_index);
// Use `FsLoader` to redirect any URL starting with `https://example.com/` to
// the local `example` directory. No HTTP query.
let mut loader = json_ld::FsLoader::default();
loader.mount(vocabulary.insert(iri!("https://example.com/")), "examples");
let mut generator = rdf_types::generator::Blank::new().with_metadata(
// Each blank id will be associated to the document URL with a dummy span.
Location::new(vocabulary.insert(iri!("https://example.com/")), Span::default())
);
let nodes = input
.flatten_with_using(
&mut vocabulary,
&mut generator,
&mut loader,
Options::<_, _>::default()
)
.await
.expect("flattening failed");
sourcefn flatten_with<'a, B, N, L>(
&'a self,
vocabulary: &'a mut N,
generator: &'a mut impl Send + Generator<N, M>,
loader: &'a mut L
) -> 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,
N: Send + Sync + VocabularyMut<Iri = I, BlankId = B>,
M: 'a + Clone + Send + Sync,
L: Loader<I, M> + ContextLoader<I, M> + Send + Sync,
L::Output: Into<Value<M>>,
L::Error: Send,
L::Context: Into<Value<M>>,
L::ContextError: Send,
fn flatten_with<'a, B, N, L>(
&'a self,
vocabulary: &'a mut N,
generator: &'a mut impl Send + Generator<N, M>,
loader: &'a mut L
) -> 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,
N: Send + Sync + VocabularyMut<Iri = I, BlankId = B>,
M: 'a + Clone + Send + Sync,
L: Loader<I, M> + ContextLoader<I, M> + Send + Sync,
L::Output: Into<Value<M>>,
L::Error: Send,
L::Context: Into<Value<M>>,
L::ContextError: Send,
Flatten the document with the given vocabulary
, generator
and loader
.
Flattening requires assigning an identifier to nested anonymous nodes,
which is why the flattening functions take an rdf_types::MetaGenerator
as parameter. This generator is in charge of creating new fresh identifiers
(with their metadata). The most common generator is
rdf_types::generator::Blank
that creates blank node identifiers.
Default options are used.
Warnings are ignored.
On success, the result is a
FlattenedDocument
, which is a list of
indexed nodes.
Example
use static_iref::iri;
use json_ld::{JsonLdProcessor, Options, RemoteDocumentReference, warning};
use rdf_types::IriVocabularyMut;
use locspan::{Location, Span};
// Creates the vocabulary that will map each `rdf_types::vocabulary::Index`
// to an actual `IriBuf`.
let mut vocabulary: rdf_types::IndexVocabulary = rdf_types::IndexVocabulary::new();
let iri_index = vocabulary.insert(iri!("https://example.com/sample.jsonld"));
let input = RemoteDocumentReference::iri(iri_index);
// Use `FsLoader` to redirect any URL starting with `https://example.com/` to
// the local `example` directory. No HTTP query.
let mut loader = json_ld::FsLoader::default();
loader.mount(vocabulary.insert(iri!("https://example.com/")), "examples");
let mut generator = rdf_types::generator::Blank::new().with_metadata(
// Each blank id will be associated to the document URL with a dummy span.
Location::new(vocabulary.insert(iri!("https://example.com/")), Span::default())
);
let nodes = input
.flatten_with(
&mut vocabulary,
&mut generator,
&mut loader
)
.await
.expect("flattening failed");
sourcefn flatten_using<'a, B, C, L>(
&'a self,
generator: &'a mut impl Send + Generator<(), M>,
loader: &'a mut L,
options: Options<I, M, C>
) -> 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>>,
(): 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_using<'a, B, C, L>(
&'a self,
generator: &'a mut impl Send + Generator<(), M>,
loader: &'a mut L,
options: Options<I, M, C>
) -> 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>>,
(): 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,
Flatten the document with the given generator
, loader
and using the
given options
.
Flattening requires assigning an identifier to nested anonymous nodes,
which is why the flattening functions take an rdf_types::MetaGenerator
as parameter. This generator is in charge of creating new fresh identifiers
(with their metadata). The most common generator is
rdf_types::generator::Blank
that creates blank node identifiers.
Warnings are ignored.
On success, the result is a
FlattenedDocument
, which is a list of
indexed nodes.
Example
use static_iref::iri;
use json_ld::{JsonLdProcessor, Options, RemoteDocumentReference, warning};
use locspan::{Location, Span};
let iri = iri!("https://example.com/sample.jsonld").to_owned();
let input = RemoteDocumentReference::iri(iri);
// Use `FsLoader` to redirect any URL starting with `https://example.com/` to
// the local `example` directory. No HTTP query.
let mut loader = json_ld::FsLoader::default();
loader.mount(iri!("https://example.com/").to_owned(), "examples");
let mut generator = rdf_types::generator::Blank::new().with_metadata(
// Each blank id will be associated to the document URL with a dummy span.
Location::new(iri!("https://example.com/").to_owned(), Span::default())
);
let nodes = input
.flatten_using(
&mut generator,
&mut loader,
Options::<_, _>::default()
)
.await
.expect("flattening failed");
sourcefn flatten<'a, B, L>(
&'a self,
generator: &'a mut impl Send + Generator<(), M>,
loader: &'a mut L
) -> 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,
(): Send + Sync + VocabularyMut<Iri = I, BlankId = B>,
M: 'a + Clone + Send + Sync,
L: Loader<I, M> + ContextLoader<I, M> + Send + Sync,
L::Output: Into<Value<M>>,
L::Error: Send,
L::Context: Into<Value<M>>,
L::ContextError: Send,
fn flatten<'a, B, L>(
&'a self,
generator: &'a mut impl Send + Generator<(), M>,
loader: &'a mut L
) -> 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,
(): Send + Sync + VocabularyMut<Iri = I, BlankId = B>,
M: 'a + Clone + Send + Sync,
L: Loader<I, M> + ContextLoader<I, M> + Send + Sync,
L::Output: Into<Value<M>>,
L::Error: Send,
L::Context: Into<Value<M>>,
L::ContextError: Send,
Flatten the document with the given generator
and loader
.
Flattening requires assigning an identifier to nested anonymous nodes,
which is why the flattening functions take an rdf_types::MetaGenerator
as parameter. This generator is in charge of creating new fresh identifiers
(with their metadata). The most common generator is
rdf_types::generator::Blank
that creates blank node identifiers.
Default options are used.
Warnings are ignored.
On success, the result is a
FlattenedDocument
, which is a list of
indexed nodes.
Example
use static_iref::iri;
use json_ld::{JsonLdProcessor, Options, RemoteDocumentReference, warning};
use locspan::{Location, Span};
let iri = iri!("https://example.com/sample.jsonld").to_owned();
let input = RemoteDocumentReference::iri(iri);
// Use `FsLoader` to redirect any URL starting with `https://example.com/` to
// the local `example` directory. No HTTP query.
let mut loader = json_ld::FsLoader::default();
loader.mount(iri!("https://example.com/").to_owned(), "examples");
let mut generator = rdf_types::generator::Blank::new().with_metadata(
// Each blank id will be associated to the document URL with a dummy span.
Location::new(iri!("https://example.com/").to_owned(), Span::default())
);
let nodes = input
.flatten(
&mut generator,
&mut loader
)
.await
.expect("flattening failed");
sourcefn to_rdf_full<'a, B, C, N, G, L>(
&'a self,
vocabulary: &'a mut N,
generator: &'a mut G,
loader: &'a mut L,
options: Options<I, M, C>,
warnings: impl 'a + Send + WarningHandler<N, M> + WarningHandler<B, N, M>
) -> BoxFuture<'_, ToRdfResult<'a, N, M, G, L>>where
I: 'a + 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: 'a + Clone + Send + Sync,
G: Send + Generator<N, M>,
L: Loader<I, M> + ContextLoader<I, M> + Send + Sync,
L::Output: Into<Value<M>>,
L::Error: Send,
L::Context: Into<C>,
L::ContextError: Send,
Self: Sync,
fn to_rdf_full<'a, B, C, N, G, L>(
&'a self,
vocabulary: &'a mut N,
generator: &'a mut G,
loader: &'a mut L,
options: Options<I, M, C>,
warnings: impl 'a + Send + WarningHandler<N, M> + WarningHandler<B, N, M>
) -> BoxFuture<'_, ToRdfResult<'a, N, M, G, L>>where
I: 'a + 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: 'a + Clone + Send + Sync,
G: Send + Generator<N, M>,
L: Loader<I, M> + ContextLoader<I, M> + Send + Sync,
L::Output: Into<Value<M>>,
L::Error: Send,
L::Context: Into<C>,
L::ContextError: Send,
Self: Sync,
Serializes the document into an RDF dataset with a custom vocabulary
using the given options
and warnings handler.
Expands the document and returns a ToRdf
instance from which an
iterator over the RDF quads defined by the document can be accessed
using the ToRdf::quads
method.
The quads will have type rdf::Quads
which borrows the subject,
predicate and graph values from the documents if possible using Cow
.
If you prefer to have quads owning the values directly you can use the
ToRdf::cloned_quads
method or call the rdf::Quads::cloned
method method form the value returned by ToRdf::quads
.
Example
use static_iref::iri;
use json_ld::{JsonLdProcessor, Options, RemoteDocumentReference, warning};
use rdf_types::{IriVocabularyMut, Quad};
use locspan::{Location, Span};
// Creates the vocabulary that will map each `rdf_types::vocabulary::Index`
// to an actual `IriBuf`.
let mut vocabulary: rdf_types::IndexVocabulary = rdf_types::IndexVocabulary::new();
let iri_index = vocabulary.insert(iri!("https://example.com/sample.jsonld"));
let input = RemoteDocumentReference::iri(iri_index);
// Use `FsLoader` to redirect any URL starting with `https://example.com/` to
// the local `example` directory. No HTTP query.
let mut loader = json_ld::FsLoader::default();
loader.mount(vocabulary.insert(iri!("https://example.com/")), "examples");
let mut generator = rdf_types::generator::Blank::new().with_metadata(
// Each blank id will be associated to the document URL with a dummy span.
Location::new(vocabulary.insert(iri!("https://example.com/")), Span::default())
);
let mut rdf = input
.to_rdf_full(
&mut vocabulary,
&mut generator,
&mut loader,
Options::<_, _>::default(),
warning::PrintWith
)
.await
.expect("flattening failed");
for Quad(_s, _p, _o, _g) in rdf.quads() {
// ...
}
sourcefn to_rdf_with_using<'a, B, C, N, G, L>(
&'a self,
vocabulary: &'a mut N,
generator: &'a mut G,
loader: &'a mut L,
options: Options<I, M, C>
) -> BoxFuture<'_, ToRdfResult<'a, N, M, G, L>>where
I: 'a + 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: 'a + Clone + Send + Sync,
G: Send + Generator<N, M>,
L: Loader<I, M> + ContextLoader<I, M> + Send + Sync,
L::Output: Into<Value<M>>,
L::Error: Send,
L::Context: Into<C>,
L::ContextError: Send,
Self: Sync,
fn to_rdf_with_using<'a, B, C, N, G, L>(
&'a self,
vocabulary: &'a mut N,
generator: &'a mut G,
loader: &'a mut L,
options: Options<I, M, C>
) -> BoxFuture<'_, ToRdfResult<'a, N, M, G, L>>where
I: 'a + 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: 'a + Clone + Send + Sync,
G: Send + Generator<N, M>,
L: Loader<I, M> + ContextLoader<I, M> + Send + Sync,
L::Output: Into<Value<M>>,
L::Error: Send,
L::Context: Into<C>,
L::ContextError: Send,
Self: Sync,
Serializes the document into an RDF dataset with a custom vocabulary
using the given options
.
Expands the document and returns a ToRdf
instance from which an
iterator over the RDF quads defined by the document can be accessed
using the ToRdf::quads
method.
The quads will have type rdf::Quads
which borrows the subject,
predicate and graph values from the documents if possible using Cow
.
If you prefer to have quads owning the values directly you can use the
ToRdf::cloned_quads
method or call the rdf::Quads::cloned
method method form the value returned by ToRdf::quads
.
Example
use static_iref::iri;
use json_ld::{JsonLdProcessor, Options, RemoteDocumentReference, warning};
use rdf_types::{IriVocabularyMut, Quad};
use locspan::{Location, Span};
// Creates the vocabulary that will map each `rdf_types::vocabulary::Index`
// to an actual `IriBuf`.
let mut vocabulary: rdf_types::IndexVocabulary = rdf_types::IndexVocabulary::new();
let iri_index = vocabulary.insert(iri!("https://example.com/sample.jsonld"));
let input = RemoteDocumentReference::iri(iri_index);
// Use `FsLoader` to redirect any URL starting with `https://example.com/` to
// the local `example` directory. No HTTP query.
let mut loader = json_ld::FsLoader::default();
loader.mount(vocabulary.insert(iri!("https://example.com/")), "examples");
let mut generator = rdf_types::generator::Blank::new().with_metadata(
// Each blank id will be associated to the document URL with a dummy span.
Location::new(vocabulary.insert(iri!("https://example.com/")), Span::default())
);
let mut rdf = input
.to_rdf_with_using(
&mut vocabulary,
&mut generator,
&mut loader,
Options::<_, _>::default()
)
.await
.expect("flattening failed");
for Quad(_s, _p, _o, _g) in rdf.quads() {
// ...
}
sourcefn to_rdf_with<'a, B, N, G, L>(
&'a self,
vocabulary: &'a mut N,
generator: &'a mut G,
loader: &'a mut L
) -> BoxFuture<'_, ToRdfResult<'a, N, M, G, L>>where
I: 'a + Clone + Eq + Hash + Send + Sync,
B: 'a + Clone + Eq + Hash + Send + Sync,
N: Send + Sync + VocabularyMut<Iri = I, BlankId = B>,
M: 'a + Clone + Send + Sync,
G: Send + Generator<N, M>,
L: Loader<I, M> + ContextLoader<I, M> + Send + Sync,
L::Output: Into<Value<M>>,
L::Error: Send,
L::Context: Into<Value<M>>,
L::ContextError: Send,
Self: Sync,
fn to_rdf_with<'a, B, N, G, L>(
&'a self,
vocabulary: &'a mut N,
generator: &'a mut G,
loader: &'a mut L
) -> BoxFuture<'_, ToRdfResult<'a, N, M, G, L>>where
I: 'a + Clone + Eq + Hash + Send + Sync,
B: 'a + Clone + Eq + Hash + Send + Sync,
N: Send + Sync + VocabularyMut<Iri = I, BlankId = B>,
M: 'a + Clone + Send + Sync,
G: Send + Generator<N, M>,
L: Loader<I, M> + ContextLoader<I, M> + Send + Sync,
L::Output: Into<Value<M>>,
L::Error: Send,
L::Context: Into<Value<M>>,
L::ContextError: Send,
Self: Sync,
Serializes the document into an RDF dataset with a custom vocabulary.
Default options are used.
Expands the document and returns a ToRdf
instance from which an
iterator over the RDF quads defined by the document can be accessed
using the ToRdf::quads
method.
The quads will have type rdf::Quads
which borrows the subject,
predicate and graph values from the documents if possible using Cow
.
If you prefer to have quads owning the values directly you can use the
ToRdf::cloned_quads
method or call the rdf::Quads::cloned
method method form the value returned by ToRdf::quads
.
Example
use static_iref::iri;
use json_ld::{JsonLdProcessor, Options, RemoteDocumentReference, warning};
use rdf_types::{IriVocabularyMut, Quad};
use locspan::{Location, Span};
// Creates the vocabulary that will map each `rdf_types::vocabulary::Index`
// to an actual `IriBuf`.
let mut vocabulary: rdf_types::IndexVocabulary = rdf_types::IndexVocabulary::new();
let iri_index = vocabulary.insert(iri!("https://example.com/sample.jsonld"));
let input = RemoteDocumentReference::iri(iri_index);
// Use `FsLoader` to redirect any URL starting with `https://example.com/` to
// the local `example` directory. No HTTP query.
let mut loader = json_ld::FsLoader::default();
loader.mount(vocabulary.insert(iri!("https://example.com/")), "examples");
let mut generator = rdf_types::generator::Blank::new().with_metadata(
// Each blank id will be associated to the document URL with a dummy span.
Location::new(vocabulary.insert(iri!("https://example.com/")), Span::default())
);
let mut rdf = input
.to_rdf_with(
&mut vocabulary,
&mut generator,
&mut loader
)
.await
.expect("flattening failed");
for Quad(_s, _p, _o, _g) in rdf.quads() {
// ...
}
sourcefn to_rdf_using<'a, B, C, G, L>(
&'a self,
generator: &'a mut G,
loader: &'a mut L,
options: Options<I, M, C>
) -> BoxFuture<'_, ToRdfResult<'a, (), M, G, L>>where
I: 'a + Clone + Eq + Hash + Send + Sync,
B: 'a + Clone + Eq + Hash + Send + Sync,
C: 'a + ProcessMeta<I, B, M> + From<Value<M>>,
(): VocabularyMut<Iri = I, BlankId = B>,
M: 'a + Clone + Send + Sync,
G: Send + Generator<(), M>,
L: Loader<I, M> + ContextLoader<I, M> + Send + Sync,
L::Output: Into<Value<M>>,
L::Error: Send,
L::Context: Into<C>,
L::ContextError: Send,
Self: Sync,
fn to_rdf_using<'a, B, C, G, L>(
&'a self,
generator: &'a mut G,
loader: &'a mut L,
options: Options<I, M, C>
) -> BoxFuture<'_, ToRdfResult<'a, (), M, G, L>>where
I: 'a + Clone + Eq + Hash + Send + Sync,
B: 'a + Clone + Eq + Hash + Send + Sync,
C: 'a + ProcessMeta<I, B, M> + From<Value<M>>,
(): VocabularyMut<Iri = I, BlankId = B>,
M: 'a + Clone + Send + Sync,
G: Send + Generator<(), M>,
L: Loader<I, M> + ContextLoader<I, M> + Send + Sync,
L::Output: Into<Value<M>>,
L::Error: Send,
L::Context: Into<C>,
L::ContextError: Send,
Self: Sync,
Serializes the document into an RDF dataset using the given options
.
Expands the document and returns a ToRdf
instance from which an
iterator over the RDF quads defined by the document can be accessed
using the ToRdf::quads
method.
The quads will have type rdf::Quads
which borrows the subject,
predicate and graph values from the documents if possible using Cow
.
If you prefer to have quads owning the values directly you can use the
ToRdf::cloned_quads
method or call the rdf::Quads::cloned
method method form the value returned by ToRdf::quads
.
Example
use static_iref::iri;
use json_ld::{JsonLdProcessor, Options, RemoteDocumentReference, warning};
use rdf_types::Quad;
use locspan::{Location, Span};
let iri_index = iri!("https://example.com/sample.jsonld").to_owned();
let input = RemoteDocumentReference::iri(iri_index);
// Use `FsLoader` to redirect any URL starting with `https://example.com/` to
// the local `example` directory. No HTTP query.
let mut loader = json_ld::FsLoader::default();
loader.mount(iri!("https://example.com/").to_owned(), "examples");
let mut generator = rdf_types::generator::Blank::new().with_metadata(
// Each blank id will be associated to the document URL with a dummy span.
Location::new(iri!("https://example.com/").to_owned(), Span::default())
);
let mut rdf = input
.to_rdf_using(
&mut generator,
&mut loader,
Options::<_, _>::default()
)
.await
.expect("flattening failed");
for Quad(s, p, o, g) in rdf.quads() {
println!("subject: {}", s);
println!("predicate: {}", p);
println!("object: {}", o);
if let Some(g) = g {
println!("graph: {}", g);
}
}
sourcefn to_rdf<'a, B, G, L>(
&'a self,
generator: &'a mut G,
loader: &'a mut L
) -> BoxFuture<'_, ToRdfResult<'a, (), M, G, L>>where
I: 'a + Clone + Eq + Hash + Send + Sync,
B: 'a + Clone + Eq + Hash + Send + Sync,
(): VocabularyMut<Iri = I, BlankId = B>,
M: 'a + Clone + Send + Sync,
G: Send + Generator<(), M>,
L: Loader<I, M> + ContextLoader<I, M> + Send + Sync,
L::Output: Into<Value<M>>,
L::Error: Send,
L::Context: Into<Value<M>>,
L::ContextError: Send,
Self: Sync,
fn to_rdf<'a, B, G, L>(
&'a self,
generator: &'a mut G,
loader: &'a mut L
) -> BoxFuture<'_, ToRdfResult<'a, (), M, G, L>>where
I: 'a + Clone + Eq + Hash + Send + Sync,
B: 'a + Clone + Eq + Hash + Send + Sync,
(): VocabularyMut<Iri = I, BlankId = B>,
M: 'a + Clone + Send + Sync,
G: Send + Generator<(), M>,
L: Loader<I, M> + ContextLoader<I, M> + Send + Sync,
L::Output: Into<Value<M>>,
L::Error: Send,
L::Context: Into<Value<M>>,
L::ContextError: Send,
Self: Sync,
Serializes the document into an RDF dataset.
Default options are used.
Expands the document and returns a ToRdf
instance from which an
iterator over the RDF quads defined by the document can be accessed
using the ToRdf::quads
method.
The quads will have type rdf::Quads
which borrows the subject,
predicate and graph values from the documents if possible using Cow
.
If you prefer to have quads owning the values directly you can use the
ToRdf::cloned_quads
method or call the rdf::Quads::cloned
method method form the value returned by ToRdf::quads
.
Example
use static_iref::iri;
use json_ld::{JsonLdProcessor, Options, RemoteDocumentReference, warning};
use rdf_types::Quad;
use locspan::{Location, Span};
let iri_index = iri!("https://example.com/sample.jsonld").to_owned();
let input = RemoteDocumentReference::iri(iri_index);
// Use `FsLoader` to redirect any URL starting with `https://example.com/` to
// the local `example` directory. No HTTP query.
let mut loader = json_ld::FsLoader::default();
loader.mount(iri!("https://example.com/").to_owned(), "examples");
let mut generator = rdf_types::generator::Blank::new().with_metadata(
// Each blank id will be associated to the document URL with a dummy span.
Location::new(iri!("https://example.com/").to_owned(), Span::default())
);
let mut rdf = input
.to_rdf(
&mut generator,
&mut loader
)
.await
.expect("flattening failed");
for Quad(s, p, o, g) in rdf.quads() {
println!("subject: {}", s);
println!("predicate: {}", p);
println!("object: {}", o);
if let Some(g) = g {
println!("graph: {}", g);
}
}