Skip to main content

sbol_core/
object.rs

1//! Version-neutral field-structs shared by the parsed-object representation:
2//! the identity-level and top-level metadata every SBOL object carries
3//! regardless of model version, and the [`Object`] value that binds an
4//! identity to its RDF types, properties, and parsed metadata.
5
6use std::collections::{BTreeMap, BTreeSet};
7
8use sbol_rdf::{Iri, Literal, Resource, Term};
9
10/// Shared fields on Identified objects.
11#[derive(Clone, Debug, Default, PartialEq, Eq)]
12pub struct Identified {
13    pub display_id: Option<String>,
14    pub name: Option<String>,
15    pub description: Option<String>,
16    pub derived_from: Vec<Resource>,
17    pub generated_by: Vec<Resource>,
18    pub measures: Vec<Resource>,
19    pub attachments: Vec<Resource>,
20}
21
22/// Shared fields on TopLevel objects.
23#[derive(Clone, Debug, PartialEq, Eq)]
24pub struct TopLevel {
25    pub namespace: Option<Iri>,
26}
27
28/// An SBOL or SBOL extension object.
29///
30/// An `Object` binds an identity to its RDF types, its raw property map, and
31/// the version-neutral [`Identified`]/[`TopLevel`] metadata parsed from those
32/// properties. Extension and annotation triples are retained inside
33/// `properties` alongside the recognized SBOL predicates.
34#[derive(Clone, Debug, PartialEq, Eq)]
35#[non_exhaustive]
36pub struct Object {
37    identity: Resource,
38    rdf_types: BTreeSet<Iri>,
39    properties: BTreeMap<Iri, Vec<Term>>,
40    identified: Identified,
41    top_level: Option<TopLevel>,
42}
43
44impl Object {
45    /// Assemble an `Object` from its parsed parts.
46    pub fn from_parts(
47        identity: Resource,
48        rdf_types: BTreeSet<Iri>,
49        properties: BTreeMap<Iri, Vec<Term>>,
50        identified: Identified,
51        top_level: Option<TopLevel>,
52    ) -> Self {
53        Self {
54            identity,
55            rdf_types,
56            properties,
57            identified,
58            top_level,
59        }
60    }
61
62    pub fn identity(&self) -> &Resource {
63        &self.identity
64    }
65
66    pub fn rdf_types(&self) -> &BTreeSet<Iri> {
67        &self.rdf_types
68    }
69
70    pub fn properties(&self) -> &BTreeMap<Iri, Vec<Term>> {
71        &self.properties
72    }
73
74    pub fn identified(&self) -> &Identified {
75        &self.identified
76    }
77
78    pub fn top_level(&self) -> Option<&TopLevel> {
79        self.top_level.as_ref()
80    }
81
82    pub fn is_top_level(&self) -> bool {
83        self.top_level.is_some()
84    }
85
86    pub fn values(&self, predicate: &str) -> &[Term] {
87        terms_for(&self.properties, predicate)
88    }
89
90    pub fn resources(&self, predicate: &str) -> impl Iterator<Item = &Resource> {
91        self.values(predicate).iter().filter_map(Term::as_resource)
92    }
93
94    pub fn iris(&self, predicate: &str) -> impl Iterator<Item = &Iri> {
95        self.values(predicate).iter().filter_map(Term::as_iri)
96    }
97
98    pub fn literals(&self, predicate: &str) -> impl Iterator<Item = &Literal> {
99        self.values(predicate).iter().filter_map(Term::as_literal)
100    }
101
102    pub fn first_resource(&self, predicate: &str) -> Option<&Resource> {
103        self.resources(predicate).next()
104    }
105
106    pub fn first_iri(&self, predicate: &str) -> Option<&Iri> {
107        self.iris(predicate).next()
108    }
109
110    pub fn first_literal_value(&self, predicate: &str) -> Option<&str> {
111        self.literals(predicate).next().map(Literal::value)
112    }
113}
114
115fn terms_for<'a>(properties: &'a BTreeMap<Iri, Vec<Term>>, predicate: &str) -> &'a [Term] {
116    properties
117        .get(&Iri::new_unchecked(predicate))
118        .map_or(&[], Vec::as_slice)
119}