use std::collections::{HashMap, HashSet};
use crate::sbol2_vocab as v2;
use crate::uri;
use sbol_rdf::Graph;
use sbol_rdf::{Iri, Resource, Term, Triple};
use sbol3::vocab as v3;
pub(super) struct IdentityMap {
rewrites: HashMap<String, String>,
namespaces: HashMap<String, String>,
}
impl IdentityMap {
pub(super) fn build(graph: &Graph) -> Self {
let mut identified: HashSet<String> = HashSet::new();
let mut rewrite_candidates: HashSet<String> = HashSet::new();
let mut owned_by: HashMap<String, String> = HashMap::new();
let mut persistent_identity_of: HashMap<String, String> = HashMap::new();
let mut version_of: HashMap<String, String> = HashMap::new();
for triple in graph.triples() {
let subject = match triple.subject.as_iri() {
Some(iri) => iri.as_str().to_owned(),
None => continue,
};
match triple.predicate.as_str() {
v3::RDF_TYPE => {
if triple
.object
.as_iri()
.is_some_and(|iri| iri.as_str().starts_with(v2::SBOL2_NS))
{
rewrite_candidates.insert(subject.clone());
}
}
v2::SBOL2_PERSISTENT_IDENTITY => {
rewrite_candidates.insert(subject.clone());
if let Some(iri) = triple.object.as_iri() {
persistent_identity_of.insert(subject.clone(), iri.as_str().to_owned());
}
}
v2::SBOL2_VERSION => {
if let Some(lit) = triple.object.as_literal() {
version_of.insert(subject.clone(), lit.value().to_owned());
}
}
v2::SBOL2_DISPLAY_ID => {
rewrite_candidates.insert(subject.clone());
identified.insert(subject.clone());
}
_ => {}
}
if is_sbol2_containment_predicate(triple.predicate.as_str())
&& let Some(child) = triple.object.as_iri()
{
owned_by.insert(child.as_str().to_owned(), subject.clone());
}
if is_sbol2_identity_reference_predicate(triple.predicate.as_str())
&& let Some(iri) = triple.object.as_iri()
{
rewrite_candidates.insert(iri.as_str().to_owned());
}
}
let mut latest: HashMap<String, String> = HashMap::new();
for (subject, pid) in &persistent_identity_of {
let entry = latest.entry(pid.clone()).or_insert_with(|| subject.clone());
let current = version_of.get(subject).map(String::as_str).unwrap_or("");
let best = version_of.get(entry).map(String::as_str).unwrap_or("");
if compare_versions(current, best).is_gt() {
*entry = subject.clone();
}
}
let mut top_info: HashMap<String, TopLevelInfo> = HashMap::new();
for subject in &identified {
if owned_by.contains_key(subject) {
continue;
}
let Some(namespace) = uri::uri_prefix_sbol2(subject) else {
continue;
};
let display_id = uri::display_id_sbol2(subject).unwrap_or("");
top_info.insert(
subject.clone(),
TopLevelInfo {
namespace: namespace.to_owned(),
persistent_identity: format!("{namespace}/{display_id}"),
sbol3: uri::create_sbol3_uri(subject),
},
);
}
let mut rewrites: HashMap<String, String> = HashMap::new();
let mut namespaces: HashMap<String, String> = HashMap::new();
for iri in &rewrite_candidates {
let resolved: &str = latest.get(iri).map(String::as_str).unwrap_or(iri);
let sbol3 = match owning_top_level(resolved, &owned_by, &top_info) {
Some(top) => {
let info = &top_info[&top];
if resolved == top {
info.sbol3.clone()
} else if let Some(relative) =
child_relative_path(resolved, &info.persistent_identity)
{
format!("{}/{}", info.sbol3, relative)
} else {
uri::create_sbol3_uri(resolved)
}
}
None => uri::create_sbol3_uri(resolved),
};
if &sbol3 != iri {
rewrites.insert(iri.clone(), sbol3);
}
}
for (top, info) in &top_info {
let sbol3 = rewrites.get(top).cloned().unwrap_or_else(|| top.clone());
namespaces.insert(sbol3, info.namespace.clone());
}
Self {
rewrites,
namespaces,
}
}
pub(super) fn rewrite_iri<'a>(&'a self, iri: &'a str) -> &'a str {
match self.rewrites.get(iri) {
Some(new) => new.as_str(),
None => iri,
}
}
pub(super) fn add_rewrite(&mut self, from: String, to: String) {
self.rewrites.insert(from, to);
}
pub(super) fn namespace_for(&self, iri: &str) -> Option<&str> {
self.namespaces.get(iri).map(String::as_str)
}
pub(super) fn rewrite_resource(&self, resource: &Resource) -> Resource {
match resource {
Resource::Iri(iri) => {
let new = self.rewrite_iri(iri.as_str());
if new == iri.as_str() {
resource.clone()
} else {
Resource::Iri(Iri::new_unchecked(new))
}
}
_ => resource.clone(),
}
}
pub(super) fn rewrite_term(&self, term: &Term) -> Term {
match term {
Term::Resource(resource) => Term::Resource(self.rewrite_resource(resource)),
_ => term.clone(),
}
}
pub(super) fn rewrite_triple(&self, triple: &Triple) -> Triple {
Triple {
subject: self.rewrite_resource(&triple.subject),
predicate: triple.predicate.clone(),
object: self.rewrite_term(&triple.object),
}
}
}
fn compare_versions(a: &str, b: &str) -> std::cmp::Ordering {
use std::cmp::Ordering;
let a_parts: Vec<&str> = a.trim().split('.').collect();
let b_parts: Vec<&str> = b.trim().split('.').collect();
for i in 0..a_parts.len().max(b_parts.len()) {
let sa = a_parts.get(i).copied().unwrap_or("0");
let sb = b_parts.get(i).copied().unwrap_or("0");
let ord = match (sa.parse::<i64>(), sb.parse::<i64>()) {
(Ok(ia), Ok(ib)) => ia.cmp(&ib),
_ => sa.cmp(sb),
};
if ord != Ordering::Equal {
return ord;
}
}
Ordering::Equal
}
struct TopLevelInfo {
namespace: String,
persistent_identity: String,
sbol3: String,
}
fn is_sbol2_containment_predicate(predicate: &str) -> bool {
matches!(
predicate,
v2::SBOL2_SEQUENCE_ANNOTATION_PROP
| v2::SBOL2_SEQUENCE_CONSTRAINT_PROP
| v2::SBOL2_LOCATION_PROP
| v2::SBOL2_COMPONENT_PROP
| v2::SBOL2_FUNCTIONAL_COMPONENT_PROP
| v2::SBOL2_MODULE_PROP
| v2::SBOL2_INTERACTION_PROP
| v2::SBOL2_PARTICIPATION_PROP
| v2::SBOL2_MAPS_TO_PROP
| v2::SBOL2_VARIABLE_COMPONENT_PROP
)
}
fn owning_top_level(
iri: &str,
owned_by: &HashMap<String, String>,
top_info: &HashMap<String, TopLevelInfo>,
) -> Option<String> {
if top_info.contains_key(iri) {
return Some(iri.to_owned());
}
let mut current = iri.to_owned();
for _ in 0..64 {
let parent = owned_by.get(¤t)?;
if top_info.contains_key(parent) {
return Some(parent.clone());
}
current = parent.clone();
}
None
}
fn child_relative_path(iri: &str, persistent_identity: &str) -> Option<String> {
let rest = iri.strip_prefix(&format!("{persistent_identity}/"))?;
match uri::version_sbol2(iri) {
Some(v) if !v.is_empty() => Some(
rest.strip_suffix(&format!("/{v}"))
.unwrap_or(rest)
.to_owned(),
),
_ => Some(rest.to_owned()),
}
}
fn is_sbol2_identity_reference_predicate(predicate: &str) -> bool {
matches!(
predicate,
v2::SBOL2_BUILT
| v2::SBOL2_SEQUENCE_PROP
| v2::SBOL2_SEQUENCE_ANNOTATION_PROP
| v2::SBOL2_SEQUENCE_CONSTRAINT_PROP
| v2::SBOL2_COMPONENT_PROP
| v2::SBOL2_FUNCTIONAL_COMPONENT_PROP
| v2::SBOL2_MODULE_PROP
| v2::SBOL2_INTERACTION_PROP
| v2::SBOL2_PARTICIPATION_PROP
| v2::SBOL2_LOCATION_PROP
| v2::SBOL2_DEFINITION
| v2::SBOL2_VARIABLE_COMPONENT_PROP
| v2::SBOL2_VARIABLE
| v2::SBOL2_VARIANT
| v2::SBOL2_VARIANT_COLLECTION
| v2::SBOL2_VARIANT_DERIVATION
| v2::SBOL2_MODEL_PROP
| v2::SBOL2_ATTACHMENT_PROP
| v2::SBOL2_SUBJECT
| v2::SBOL2_OBJECT
| v2::SBOL2_PARTICIPANT
| v2::SBOL2_LOCAL
| v2::SBOL2_REMOTE
| v2::SBOL2_MAPS_TO_PROP
| v2::SBOL2_TEMPLATE
| v2::SBOL2_MEMBER
| v2::SBOL2_EXPERIMENTAL_DATA_PROP
)
}