jsonld-syntax 0.24.0

JSON-LD syntax
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

//! Syntax of JSON-LD contexts.
//!
//! This crate provides the Rust types mirroring the JSON-LD grammar of a
//! `@context`: context definitions, term definitions, keywords, container
//! mappings, language tags and text directions. Each of them can be built
//! from a JSON value with [`TryFromJson`], converted back with [`IntoJson`],
//! and pretty-printed with the [`Print`] trait re-exported from `jstrict`.
//!
//! Interpreting a context — resolving remote references, expanding terms into
//! IRIs, compacting IRIs back into terms — is the job of the sibling
//! `jsonld-context-processing`, `jsonld-expansion` and `jsonld-compaction`
//! crates.
// On docs.rs, label every feature-gated item with the feature that unlocks it.
// `doc(auto_cfg)` is still nightly-gated, and `docsrs` is set by docs.rs itself
// (see `rustdoc-args` in Cargo.toml), so stable builds are unaffected.
#![cfg_attr(docsrs, feature(doc_cfg))]
#![cfg_attr(docsrs, doc(auto_cfg))]
mod compact_iri;
mod compare;
/// Container mappings: the values a `@container` entry may take.
pub mod container;
/// Contexts, their definitions and term definitions.
pub mod context;
mod direction;
mod error;
mod expandable;
pub mod hash;
pub mod intern;
mod into_json;
mod keyword;
mod lang;
pub mod native_stack;
mod nullable;
mod print_ld;
mod try_from_json;
mod utils;

pub use compact_iri::*;
pub use compare::*;
pub use container::{Container, ContainerKind};
pub use context::{Context, ContextDocument, ContextEntry};
pub use direction::*;
pub use error::*;
pub use expandable::*;
pub use into_json::*;
pub use jstrict::{
    BorrowUnordered,
    Kind,
    Number,
    NumberBuf,
    Object,
    Parse,
    Print,
    String,
    Unordered,
    UnorderedEq,
    UnorderedHash,
    UnorderedPartialEq,
    Value,
    object,
    parse,
    print,
};
pub use keyword::*;
pub use lang::*;
pub use nullable::*;
pub use try_from_json::*;

#[cfg(feature = "serde")]
pub use jstrict::{from_value, to_value};

#[derive(Clone, Copy, Debug)]
/// Error raised when a JSON value has the wrong kind.
pub struct Unexpected(jstrict::Kind, &'static [jstrict::Kind]);

impl Unexpected {
    /// Returns the kind of the value that was found.
    #[must_use]
    pub fn found(&self) -> jstrict::Kind {
        self.0
    }

    /// Returns the kinds that were expected instead.
    #[must_use]
    pub fn expected(&self) -> &'static [jstrict::Kind] {
        self.1
    }
}

impl std::fmt::Display for Unexpected {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "unexpected {}, expected ", self.0)?;
        for (i, kind) in self.1.iter().enumerate() {
            if i > 0 {
                f.write_str(" or ")?;
            }
            write!(f, "{kind}")?;
        }
        Ok(())
    }
}

impl std::error::Error for Unexpected {}