jsonld-core 0.25.0

JSON-LD core types and traits
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

use std::{borrow::Borrow, hash::Hash, ops::Deref};

use iri_rs::IriBuf;
use rdfx::BlankIdBuf;

/// Expanded documents.
pub mod expanded;
/// Flattened documents.
pub mod flattened;

pub use expanded::{ExpandedDocument, ExpandedJsonTextError};
pub use flattened::FlattenedDocument;

use crate::RemoteDocument;

/// Remote document paired with its expanded form.
pub type DocumentParts<I, B> = (RemoteDocument<I>, ExpandedDocument<I, B>);

/// JSON-LD document in both compact and expanded form.
#[derive(Debug, Clone)]
pub struct Document<I = IriBuf, B = BlankIdBuf> {
    remote: RemoteDocument<I>,
    expanded: ExpandedDocument<I, B>,
}

impl<I, B> Document<I, B> {
    /// Creates a new `Document`.
    pub fn new(remote: RemoteDocument<I>, expanded: ExpandedDocument<I, B>) -> Self {
        Self { remote, expanded }
    }

    /// Consumes the document, returning its remote (compact) form.
    pub fn into_remote(self) -> RemoteDocument<I> {
        self.remote
    }

    /// Consumes the document, returning its compact form as a JSON value.
    pub fn into_compact(self) -> jsonld_syntax::Value {
        self.remote.into_document()
    }

    /// Consumes the document, returning its expanded form.
    pub fn into_expanded(self) -> ExpandedDocument<I, B> {
        self.expanded
    }

    /// Consumes the document, returning its remote and expanded forms.
    pub fn into_parts(self) -> DocumentParts<I, B> {
        (self.remote, self.expanded)
    }

    /// Returns the remote (compact) form of the document.
    pub fn as_remote(&self) -> &RemoteDocument<I> {
        &self.remote
    }

    /// Returns the compact form of the document as a JSON value.
    pub fn as_compact(&self) -> &jsonld_syntax::Value {
        self.remote.document()
    }

    /// Returns the expanded form of the document.
    pub fn as_expanded(&self) -> &ExpandedDocument<I, B> {
        &self.expanded
    }
}

impl<I, B> Deref for Document<I, B> {
    type Target = ExpandedDocument<I, B>;

    fn deref(&self) -> &Self::Target {
        &self.expanded
    }
}

impl<I, B> Borrow<RemoteDocument<I>> for Document<I, B> {
    fn borrow(&self) -> &RemoteDocument<I> {
        &self.remote
    }
}

impl<I, B> Borrow<jsonld_syntax::Value> for Document<I, B> {
    fn borrow(&self) -> &jsonld_syntax::Value {
        self.remote.document()
    }
}

impl<I, B> Borrow<ExpandedDocument<I, B>> for Document<I, B> {
    fn borrow(&self) -> &ExpandedDocument<I, B> {
        &self.expanded
    }
}

impl<I: Eq + Hash, B: Eq + Hash> PartialEq for Document<I, B> {
    fn eq(&self, other: &Self) -> bool {
        self.expanded.eq(&other.expanded)
    }
}

impl<I: Eq + Hash, B: Eq + Hash> Eq for Document<I, B> {}

#[cfg(feature = "serde")]
impl<I, B> serde::Serialize for Document<I, B> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        self.remote.document().serialize(serializer)
    }
}

// TODO: `Document` lost its `LinkedData` / `LinkedDataGraph` impls when the
// serialization layer moved to `ld_core`; they need to be rewritten against
// `ld_core`'s `Interpretation`-based API.