Struct RemoteDocument 

pub struct RemoteDocument<I = Iri<String>, T = Value> {
    pub url: Option<I>,
    pub content_type: Option<MediaTypeBuf>,
    pub context_url: Option<I>,
    pub profile: HashSet<Profile<I>, GxBuildHasher>,
    pub document: T,
}

Remote document.

Stores the content of a loaded remote document along with its original URL.

Fields

url: Option<I>

The final URL of the loaded document, after eventual redirection.

content_type: Option<MediaTypeBuf>

The HTTP Content-Type header value of the loaded document, exclusive of any optional parameters.

context_url: Option<I>

If available, the value of the HTTP Link Header RFC 8288 using the http://www.w3.org/ns/json-ld#context link relation in the response.

If the response’s Content-Type is application/ld+json, the HTTP Link Header is ignored. If multiple HTTP Link Headers using the http://www.w3.org/ns/json-ld#context link relation are found, the loader fails with a multiple context link headers error.

profile: HashSet<Profile<I>, GxBuildHasher>

Profiles advertised by the document’s media type.

document: T

The retrieved document.

Implementations

impl<I, T> RemoteDocument<I, T>

pub fn new( url: Option<I>, content_type: Option<MediaTypeBuf>, document: T, ) -> RemoteDocument<I, T>

Creates a new remote document.

url is the final URL of the loaded document, after eventual redirection. content_type is the HTTP Content-Type header value of the loaded document, exclusive of any optional parameters.

pub fn new_full( url: Option<I>, content_type: Option<MediaTypeBuf>, context_url: Option<I>, profile: HashSet<Profile<I>, GxBuildHasher>, document: T, ) -> RemoteDocument<I, T>

Creates a new remote document.

url is the final URL of the loaded document, after eventual redirection. content_type is the HTTP Content-Type header value of the loaded document, exclusive of any optional parameters. context_url is the value of the HTTP Link Header RFC 8288 using the http://www.w3.org/ns/json-ld#context link relation in the response, if any. profile is the value of any profile parameter retrieved as part of the original contentType.

pub fn map<U>(self, f: impl Fn(T) -> U) -> RemoteDocument<I, U>

Maps the content of the remote document.

pub fn try_map<U, E>( self, f: impl Fn(T) -> Result<U, E>, ) -> Result<RemoteDocument<I, U>, E>

Tries to map the content of the remote document.

Errors

Returns whatever f returns for the contained document.

pub fn map_iris<J>(self, f: impl FnMut(I) -> J) -> RemoteDocument<J, T>

where J: Eq + Hash,

Maps all the IRIs.

pub fn url(&self) -> Option<&I>

Returns a reference to the final URL of the loaded document, after eventual redirection.

pub fn content_type(&self) -> Option<&MediaTypeBuf>

Returns the HTTP Content-Type header value of the loaded document, exclusive of any optional parameters.

pub fn context_url(&self) -> Option<&I>

Returns the value of the HTTP Link Header RFC 8288 using the http://www.w3.org/ns/json-ld#context link relation in the response, if any.

If the response’s Content-Type is application/ld+json, the HTTP Link Header is ignored. If multiple HTTP Link Headers using the http://www.w3.org/ns/json-ld#context link relation are found, the loader fails with a multiple context link headers error.

pub fn document(&self) -> &T

Returns a reference to the content of the document.

pub fn document_mut(&mut self) -> &mut T

Returns a mutable reference to the content of the document.

pub fn into_document(self) -> T

Drops the original URL and returns the content of the document.

pub fn into_url(self) -> Option<I>

Drops the content and returns the original URL of the document.

pub fn set_url(&mut self, url: Option<I>)

Sets the URL of the document.

impl<I> RemoteDocument<I>

pub fn from_value( url: Option<I>, content_type: Option<MediaTypeBuf>, document: impl Into<Value>, ) -> RemoteDocument<I>

Creates a remote document from any value convertible into a jstrict::Value.

With the serde_json feature enabled, this also accepts serde_json::Value thanks to the From<serde_json::Value> implementation provided by jstrict.

impl<I> RemoteDocument<I>

pub fn from_serde_json( url: Option<I>, content_type: Option<MediaTypeBuf>, document: Value, ) -> RemoteDocument<I>

Available on crate feature serde-json only.

Creates a remote document from a serde_json::Value.

pub fn into_serde_json(self) -> RemoteDocument<I, Value>

Available on crate feature serde-json only.

Consumes the document, returning a RemoteDocument<I, serde_json::Value>.

impl<I> RemoteDocument<I>

pub fn from_sonic_rs( url: Option<I>, content_type: Option<MediaTypeBuf>, document: Value, ) -> RemoteDocument<I>

Available on crate feature sonic-rs only.

Creates a remote document from a sonic_rs::Value.

pub fn into_sonic_rs(self) -> RemoteDocument<I, Value>

Available on crate feature sonic-rs only.

Consumes the document, returning a RemoteDocument<I, sonic_rs::Value>.

Trait Implementations

impl<I, B> Borrow<RemoteDocument<I>> for Document<I, B>

fn borrow(&self) -> &RemoteDocument<I>

Immutably borrows from an owned value.

impl<I, T> Clone for RemoteDocument<I, T>

where I: Clone, T: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I, T> Debug for RemoteDocument<I, T>

where I: Debug, T: Debug,

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

Formats the value using the given formatter.

impl<Iri> Expand<Iri> for RemoteDocument<Iri>

A remote document knows where it comes from: its own URL is used as default base URL, so relative IRI references resolve as they would for a consumer fetching the document.

fn default_base_url(&self) -> Option<&Iri>

Returns the base URL the document is expanded against when none is given explicitly, as in Expand::expand and Expand::expand_with.

async fn expand_full<N, L, W>( &self, vocabulary: &mut N, context: Context<Iri, <N as BlankIdVocabulary>::BlankId>, base_url: Option<&Iri>, loader: &L, options: Options, warnings_handler: W, ) -> Result<ExpandedDocument<Iri, <N as BlankIdVocabulary>::BlankId>, Error<<L as Loader>::Error>>

where N: VocabularyMut<Iri = Iri>, Iri: Clone + Eq + Hash, <N as BlankIdVocabulary>::BlankId: Clone + Eq + Hash, L: Loader, W: WarningHandler<N>,

Expands the document, controlling every parameter of the algorithm.

async fn expand_with<'a, N, L>( &'a self, vocabulary: &'a mut N, loader: &'a L, ) -> Result<ExpandedDocument<Iri, <N as BlankIdVocabulary>::BlankId>, Error<<L as Loader>::Error>>

where N: VocabularyMut<Iri = Iri>, Iri: 'a + Clone + Eq + Hash, <N as BlankIdVocabulary>::BlankId: 'a + Clone + Eq + Hash, L: Loader,

Expands the document, interpreting identifiers with the given vocabulary.

async fn expand<'a, L>( &'a self, loader: &'a L, ) -> Result<ExpandedDocument<Iri>, Error<<L as Loader>::Error>>

where (): VocabularyMut<Iri = Iri>, Iri: 'a + Clone + Eq + Hash, L: Loader,

Expands the document, keeping identifiers as IriBuf and BlankIdBuf values instead of interning them in a vocabulary.

impl<I> JsonLdProcessor<I> for RemoteDocument<I>

async fn compare_full<N, L>( &self, other: &Self, vocabulary: &mut N, loader: &L, options: Options<I>, warnings: impl WarningHandler<N> + WarningHandler<N>, ) -> CompareResult<L::Error>

where N: VocabularyMut<Iri = I>, I: Clone + Eq + Hash, N::BlankId: Clone + Eq + Hash, L: Loader,

Compare this document against other with a custom vocabulary using the given options and warnings handler.

async fn expand_full<N, L>( &self, vocabulary: &mut N, loader: &L, options: Options<I>, warnings: impl WarningHandler<N> + WarningHandler<N>, ) -> ExpandResult<I, N::BlankId, L::Error>

where N: VocabularyMut<Iri = I>, I: Clone + Eq + Hash, N::BlankId: Clone + Eq + Hash, L: Loader,

Expand the document with the given vocabulary and loader, using the given options and warning handler.

async fn into_document_full<'a, N, L>( self, vocabulary: &'a mut N, loader: &'a L, options: Options<I>, warnings: impl 'a + WarningHandler<N> + WarningHandler<N>, ) -> IntoDocumentResult<I, N::BlankId, L::Error>

where N: VocabularyMut<Iri = I>, I: 'a + Clone + Eq + Hash, N::BlankId: 'a + Clone + Eq + Hash, L: Loader,

Consumes this JsonLdProcessor, returning its document full.

async fn compact_full<'a, N, L>( &'a self, vocabulary: &'a mut N, context: RemoteContextReference<I>, loader: &'a L, options: Options<I>, warnings: impl 'a + WarningHandler<N> + WarningHandler<N>, ) -> CompactResult<L::Error>

where N: VocabularyMut<Iri = I>, I: Clone + Eq + Hash, N::BlankId: 'a + Clone + Eq + Hash, L: Loader,

Compact the document relative to context with the given vocabulary and loader, using the given options and warning handler.

async fn flatten_full<'a, N, L>( &'a self, vocabulary: &'a mut N, generator: &'a mut impl LocalGenerator, context: Option<RemoteContextReference<I>>, loader: &'a L, options: Options<I>, warnings: impl 'a + WarningHandler<N> + WarningHandler<N>, ) -> FlattenResult<I, N::BlankId, L::Error>

where N: VocabularyMut<Iri = I>, I: Clone + Eq + Hash, N::BlankId: 'a + Clone + Eq + Hash, L: Loader,

Flatten the document with the given vocabulary, generator and loader, using the given options and warning handler.

async fn compare_with_using<'a, N, L>( &'a self, other: &'a Self, vocabulary: &'a mut N, loader: &'a L, options: Options<Iri>, ) -> CompareResult<L::Error>

where N: VocabularyMut<Iri = Iri>, Iri: Clone + Eq + Hash, L: Loader, N::BlankId: 'a + Clone + Eq + Hash,

Compare this document against other with a custom vocabulary using the given options.

async fn compare_with<'a, N, L>( &'a self, other: &'a Self, vocabulary: &'a mut N, loader: &'a L, ) -> CompareResult<L::Error>

where N: VocabularyMut<Iri = Iri>, Iri: Clone + Eq + Hash, L: Loader, N::BlankId: 'a + Clone + Eq + Hash,

Compare this document against other with a custom vocabulary.

async fn compare_using<'a, L>( &'a self, other: &'a Self, loader: &'a L, options: Options<Iri>, ) -> CompareResult<L::Error>

where (): VocabularyMut<Iri = Iri>, Iri: Clone + Eq + Hash, L: Loader,

Compare this document against other using the given options.

async fn compare<'a, L>( &'a self, other: &'a Self, loader: &'a L, ) -> CompareResult<L::Error>

where (): VocabularyMut<Iri = Iri>, Iri: Clone + Eq + Hash, L: Loader,

Compare this document against other with a custom vocabulary.

async fn expand_with_using<'a, N, L>( &'a self, vocabulary: &'a mut N, loader: &'a L, options: Options<Iri>, ) -> ExpandResult<Iri, N::BlankId, L::Error>

where N: VocabularyMut<Iri = Iri>, Iri: Clone + Eq + Hash, L: Loader, N::BlankId: 'a + Clone + Eq + Hash,

Expand the document with the given vocabulary and loader, using the given options.

async fn expand_with<'a, N, L>( &'a self, vocabulary: &'a mut N, loader: &'a L, ) -> ExpandResult<Iri, N::BlankId, L::Error>

where N: VocabularyMut<Iri = Iri>, Iri: Clone + Eq + Hash, L: Loader, N::BlankId: 'a + Clone + Eq + Hash,

Expand the document with the given vocabulary and loader.

async fn expand_using<'a, L>( &'a self, loader: &'a L, options: Options<Iri>, ) -> ExpandResult<Iri, BlankIdBuf, L::Error>

where (): VocabularyMut<Iri = Iri>, Iri: Clone + Eq + Hash, L: Loader,

Expand the document with the given loader using the given options.

async fn expand<'a, L>( &'a self, loader: &'a L, ) -> ExpandResult<Iri, BlankIdBuf, L::Error>

where (): VocabularyMut<Iri = Iri>, Iri: Clone + Eq + Hash, L: Loader,

Expand the document with the given loader.

async fn into_document_with_using<'a, N, L>( self, vocabulary: &'a mut N, loader: &'a L, options: Options<Iri>, ) -> IntoDocumentResult<Iri, N::BlankId, L::Error>

where N: VocabularyMut<Iri = Iri>, Iri: 'a + Clone + Eq + Hash, L: Loader, N::BlankId: 'a + Clone + Eq + Hash,

Consumes this JsonLdProcessor, returning its document with using.

async fn into_document_with<'a, N, L>( self, vocabulary: &'a mut N, loader: &'a L, ) -> IntoDocumentResult<Iri, N::BlankId, L::Error>

where N: VocabularyMut<Iri = Iri>, Iri: 'a + Clone + Eq + Hash, L: Loader, N::BlankId: 'a + Clone + Eq + Hash,

Consumes this JsonLdProcessor, returning its document with.

async fn into_document<'a, L>( self, loader: &'a L, ) -> IntoDocumentResult<Iri, BlankIdBuf, L::Error>

where (): VocabularyMut<Iri = Iri>, Iri: 'a + Clone + Eq + Hash, L: Loader,

Consumes this JsonLdProcessor, returning its document.

async fn compact_with_using<'a, N, L>( &'a self, vocabulary: &'a mut N, context: RemoteContextReference<Iri>, loader: &'a L, options: Options<Iri>, ) -> CompactResult<L::Error>

where N: VocabularyMut<Iri = Iri>, Iri: Clone + Eq + Hash, L: Loader, N::BlankId: 'a + Clone + Eq + Hash,

Compact the document relative to context with the given vocabulary and loader, using the given options.

async fn compact_with<'a, N, L>( &'a self, vocabulary: &'a mut N, context: RemoteContextReference<Iri>, loader: &'a L, ) -> CompactResult<L::Error>

where N: VocabularyMut<Iri = Iri>, Iri: Clone + Eq + Hash, L: Loader, N::BlankId: 'a + Clone + Eq + Hash,

Compact the document relative to context with the given vocabulary and loader.

async fn compact_using<'a, L>( &'a self, context: RemoteContextReference<Iri>, loader: &'a L, options: Options<Iri>, ) -> CompactResult<L::Error>

where (): VocabularyMut<Iri = Iri>, Iri: Clone + Eq + Hash, L: Loader,

Compact the document relative to context with the given loader, using the given options.

async fn compact<'a, L>( &'a self, context: RemoteContextReference<Iri>, loader: &'a L, ) -> CompactResult<L::Error>

where (): VocabularyMut<Iri = Iri>, Iri: Clone + Eq + Hash, L: Loader,

Compact the document relative to context with the given loader.

async fn flatten_with_using<'a, N, L>( &'a self, vocabulary: &'a mut N, generator: &'a mut impl LocalGenerator, loader: &'a L, options: Options<Iri>, ) -> FlattenResult<Iri, N::BlankId, L::Error>

where N: VocabularyMut<Iri = Iri>, Iri: Clone + Eq + Hash, L: Loader, N::BlankId: 'a + Clone + Eq + Hash,

Flatten the document with the given vocabulary, generator and loader, using the given options.

async fn flatten_with<'a, N, L>( &'a self, vocabulary: &'a mut N, generator: &'a mut impl LocalGenerator, loader: &'a L, ) -> FlattenResult<Iri, N::BlankId, L::Error>

where N: VocabularyMut<Iri = Iri>, Iri: Clone + Eq + Hash, L: Loader, N::BlankId: 'a + Clone + Eq + Hash,

Flatten the document with the given vocabulary, generator and loader.

async fn flatten_using<'a, L>( &'a self, generator: &'a mut impl LocalGenerator, loader: &'a L, options: Options<Iri>, ) -> FlattenResult<Iri, BlankIdBuf, L::Error>

where (): VocabularyMut<Iri = Iri>, Iri: Clone + Eq + Hash, L: Loader,

Flatten the document with the given generator, loader and using the given options.

async fn flatten<'a, L>( &'a self, generator: &'a mut impl LocalGenerator, loader: &'a L, ) -> FlattenResult<Iri, BlankIdBuf, L::Error>

where (): VocabularyMut<Iri = Iri>, Iri: Clone + Eq + Hash, L: Loader,

Flatten the document with the given generator and loader.

async fn to_rdf_full<N, G, L>( &self, vocabulary: N, generator: G, loader: &L, options: Options<Iri>, warnings: impl WarningHandler<N> + WarningHandler<N>, ) -> ToRdfResult<N, G, L::Error>

where N: VocabularyMut<Iri = Iri>, Iri: Clone + Eq + Hash, L: Loader, N::BlankId: Clone + Eq + Hash, G: LocalGenerator,

Serializes the document into an RDF dataset with a custom vocabulary using the given options and warnings handler.

async fn to_rdf_with_using<N, G, L>( &self, vocabulary: N, generator: G, loader: &L, options: Options<Iri>, ) -> ToRdfResult<N, G, L::Error>

where N: VocabularyMut<Iri = Iri>, Iri: Clone + Eq + Hash, L: Loader, N::BlankId: Clone + Eq + Hash, G: LocalGenerator,

Serializes the document into an RDF dataset with a custom vocabulary using the given options.

async fn to_rdf_with<N, G, L>( &self, vocabulary: N, generator: G, loader: &L, ) -> ToRdfResult<N, G, L::Error>

where N: VocabularyMut<Iri = Iri>, Iri: Clone + Eq + Hash, L: Loader, N::BlankId: Clone + Eq + Hash, G: LocalGenerator,

Serializes the document into an RDF dataset with a custom vocabulary.

async fn to_rdf_using<G, L>( &self, generator: G, loader: &L, options: Options<Iri>, ) -> ToRdfResult<(), G, L::Error>

where (): VocabularyMut<Iri = Iri>, Iri: Clone + Eq + Hash, L: Loader, G: LocalGenerator,

Serializes the document into an RDF dataset using the given options.

async fn to_rdf<G, L>( &self, generator: G, loader: &L, ) -> ToRdfResult<(), G, L::Error>

where (): VocabularyMut<Iri = Iri>, Iri: Clone + Eq + Hash, L: Loader, G: LocalGenerator,

Serializes the document into an RDF dataset.