Struct json_ld::RemoteDocument

pub struct RemoteDocument<D> { /* private fields */ }

Remote JSON-LD document.

Represent a document located at a given base URL. This is the result of loading a document with Loader::load. It is a simple wrapper that Deref to the underlying document while remembering its base URL.

Example

use static_iref::*;

use async_std::task;
use serde_json::Value;
use json_ld::{
  Loader,
  FsLoader,
  RemoteDocument
};

// Prepare the loader.
let mut loader = FsLoader::<Value>::new(|s| serde_json::from_str(s));
loader.mount(iri!("https://w3c.github.io/json-ld-api"), "json-ld-api");

// Load the remote document.
let url = iri!("https://w3c.github.io/json-ld-api/tests/expand-manifest.jsonld");
let doc: RemoteDocument<Value> = task::block_on(loader.load(url)).unwrap();

Implementations

impl<D> RemoteDocument<D>

pub fn new(doc: D, base_url: IriBuf, source: Id) -> RemoteDocument<D>

Create a new remote document from the document contents and base URL.

pub fn source(&self) -> Id

pub fn into_document(self) -> D

Consume the remote document and return the inner document.

pub fn into_parts(self) -> (D, Id, IriBuf)

Consume the remote document and return the inner document along with its base URL.

Trait Implementations

impl<D: Clone> Clone for RemoteDocument<D>

fn clone(&self) -> RemoteDocument<D>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<D> Deref for RemoteDocument<D>

type Target = D

The resulting type after dereferencing.

fn deref(&self) -> &D

Dereferences the value.

impl<D> DerefMut for RemoteDocument<D>

fn deref_mut(&mut self) -> &mut D

Mutably dereferences the value.

impl<T: Id, D: Document<T>> Document<T> for RemoteDocument<D>

A Remote document is a document.

type Json = D::Json

fn base_url(&self) -> Option<Iri<'_>>

Document location, if any.

fn expand_with<'a, C: 'a + ContextMut<T> + Send + Sync, L: 'a + Loader + Send + Sync>(
    &'a self,
    base_url: Option<Iri<'_>>,
    context: &'a C,
    loader: &'a mut L,
    options: Options
) -> BoxFuture<'a, ExpansionResult<T, Self::Json>> where
    D::Json: JsonExpand,
    C::LocalContext: From<L::Output> + From<Self::Json>,
    L::Output: Into<Self::Json>,
    T: 'a + Send + Sync, 

Expand the document with a custom base URL, initial context, document loader and expansion options.

fn expand<'a, C: 'a + ContextMut<T>, L: Loader>(
    &'a self,
    loader: &'a mut L
) -> BoxFuture<'a, ExpansionResult<T, Self::Json>> where
    Self: Send + Sync,
    Self::Json: JsonExpand,
    C: Send + Sync,
    C::LocalContext: From<L::Output> + From<Self::Json>,
    L: Send + Sync,
    L::Output: Into<Self::Json>,
    T: 'a + Send + Sync, 

Expand the document.

fn compact_with<'a, K: JsonFrom<Self::Json>, C: ContextMutProxy<T>, L: Loader, M1, M2>(
    &'a self,
    base_url: Option<Iri<'a>>,
    context: &'a C,
    loader: &'a mut L,
    options: Options,
    meta_context: M1,
    meta_document: M2
) -> BoxFuture<'a, Result<K, Error>> where
    Self: Sync,
    Self::Json: JsonExpand + JsonSrc,
    T: 'a + Send + Sync,
    K: JsonFrom<<C::Target as Context<T>>::LocalContext>,
    C: AsJson<<C::Target as Context<T>>::LocalContext, K> + Send + Sync,
    <C::Target as Context<T>>::LocalContext: JsonSrc + From<L::Output> + From<Self::Json>,
    C::Target: Send + Sync,
    L: 'a + Send + Sync,
    M1: 'a + Clone + Send + Sync + Fn(Option<&<<C::Target as Context<T>>::LocalContext as Json>::MetaData>) -> K::MetaData,
    M2: 'a + Clone + Send + Sync + Fn(Option<&<Self::Json as Json>::MetaData>) -> K::MetaData,
    L::Output: Into<Self::Json>, 

Compact the document with a custom base URL, context, document loader and options.

fn compact<'a, C: ContextMutProxy<T> + AsJson<Self::Json, Self::Json>, L: Loader>(
    &'a self,
    context: &'a C,
    loader: &'a mut L
) -> BoxFuture<'a, Result<Self::Json, Error>> where
    Self: Sync,
    Self::Json: JsonFrom<Self::Json> + JsonExpand + JsonSrc + From<L::Output>,
    <Self::Json as Json>::MetaData: Default,
    T: 'a + Send + Sync,
    C::Target: Context<T, LocalContext = Self::Json>,
    C: Send + Sync,
    C::Target: Send + Sync,
    L: 'a + Send + Sync,
    L::Output: Into<Self::Json>, 

Compact the document.