rdftk_core 0.5.6

This crate provides the core RDF data model; concrete implementations for Statements and Literals, along with a Resource type that provides a builder-like experience for models.
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
115

use rdftk_iri::{Name, NameParser, QName};
use std::fmt::{Display, Formatter};
use std::str::FromStr;
use unique_id::sequence::SequenceGenerator as IDGenerator;
use unique_id::Generator;

// ------------------------------------------------------------------------------------------------
// Public Types
// ------------------------------------------------------------------------------------------------

///
/// A String wrapper for blank nodes.
///
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct BlankNode(String);

// ------------------------------------------------------------------------------------------------
// Public Values
// ------------------------------------------------------------------------------------------------

///
/// The reserved namespace value used to identify a serialized blank node.
///
pub const BLANK_NODE_NAMESPACE: &str = "_";

///
/// The reserved prefix value used to identify a serialized blank node.
///
pub const BLANK_NODE_PREFIX: &str = "_:";

// ------------------------------------------------------------------------------------------------
// Implementations
// ------------------------------------------------------------------------------------------------

impl Display for BlankNode {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.0)
    }
}

impl FromStr for BlankNode {
    type Err = crate::error::Error;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        if BlankNode::is_valid_str(s) {
            Ok(Self(s.into()))
        } else {
            Err(crate::error::Error::InvalidBlankNodeName { name: s.into() })
        }
    }
}

impl From<BlankNode> for String {
    fn from(v: BlankNode) -> Self {
        v.0
    }
}

impl From<Name> for BlankNode {
    fn from(v: Name) -> Self {
        Self(v.into())
    }
}

impl From<&Name> for BlankNode {
    fn from(v: &Name) -> Self {
        Self(v.into())
    }
}

impl From<&BlankNode> for String {
    fn from(v: &BlankNode) -> Self {
        v.0.clone()
    }
}

impl AsRef<str> for BlankNode {
    fn as_ref(&self) -> &str {
        self.0.as_str()
    }
}

impl BlankNode {
    ///
    /// Construct a new blank node with a generated identifier.
    ///
    pub fn generate() -> Self {
        Self(format!("B{}", IDGenerator.next_id()))
    }

    ///
    /// Returns `true` if the string is a valid blank node identifier, else
    /// `false`. Note that this function will accept simple names, or those
    /// with the reserved prefix `"_:"`.
    ///
    pub fn is_valid_str<S>(s: S) -> bool
    where
        S: AsRef<str>,
    {
        let s: &str = s.as_ref();
        NameParser::BlankNode.is_valid_str(if let Some(s) = s.strip_prefix(BLANK_NODE_PREFIX) {
            s
        } else {
            s
        })
    }

    ///
    /// Return a qualified version of the blank node, i.e. with the reserved
    /// namespace value `"_"`.
    ///
    pub fn to_qname(&self) -> QName {
        QName::new_blank(Name::new_unchecked(&self.0)).unwrap()
    }
}