.

publish/src/rdf/conversion.rs

@@ -1,6 +1,5 @@
 use oxigraph::model::{NamedNode, Quad, Term};
 use oxigraph::model::vocab::{rdf, xsd};
-use oxilangtag::LanguageTag;
 
 pub fn quad_into_term(quad: Quad) -> Term {
     quad.object
@@ -61,4 +60,8 @@ pub fn term_to_u64(term: &Term) -> Option<u64> {
         let value: u64 = literal.value().parse().expect("Failed to parse u64 from ontology. It ought to be a non-negative integer.");
         Some(value)
     } else { None }
+}
+
+pub fn term_into_u64(term: Term) -> Option<u64> {
+    term_to_u64(&term)
 }

publish/src/rdf/ontology.rs

@@ -8,11 +8,8 @@ use std::collections::{BTreeMap, HashMap, HashSet};
 use std::fmt::Display;
 use std::path::{Path, PathBuf};
 use std::sync::LazyLock;
-use iced::widget::sensor::Key;
 use oxigraph::store::Store;
-use oxilangtag::LanguageTag;
-use tracing::{debug, debug_span};
-use crate::rdf::{conversion, language, materialize};
+use crate::rdf::conversion;
 use crate::rdf::language::LanguageCondition;
 
 static PREFIXES: LazyLock<BTreeMap<String, String>> = LazyLock::new(|| {
@@ -78,49 +75,11 @@ impl OntologyBuilder {
         materialize::super_classes(&mut store)?;
         debug_span!("Optimize Ontology").in_scope(|| store.optimize())?;*/
 
-        let mut entities: HashMap<NamedNode, Entity> = HashMap::new();
-        // All Entities have exactly one catalog ID.
-        /*for quad in store.quads_for_pattern(None, Some(gl::CATALOG_ID), None, None)
-            .filter_map(Result::ok) {
-            let label = store.quads_for_pattern(Some(quad.subject.as_ref().into()), Some(rdfs::LABEL), None, None)
-                .filter_map(Result::ok)
-                .map(conversion::quad_into_term)
-                .filter(|term| conversion::language_matches(term, &conversion::english()))
-                .filter_map(conversion::term_into_string)
-                .next();
-
-            let comment = store.quads_for_pattern(Some(quad.subject.as_ref().into()), Some(rdfs::COMMENT), None, None)
-                .filter_map(Result::ok)
-                .map(conversion::quad_into_term)
-                .filter(|term| conversion::language_matches(term, &conversion::english()))
-                .filter_map(conversion::term_into_string)
-                .next();
-
-            if let Some(catalog_id) = conversion::term_to_u64(&quad.object) &&
-                let NamedOrBlankNode::NamedNode(subject) = quad.subject &&
-                let Some(label) = label {
-                let mut properties = HashSet::new();
-                for quad in store.quads_for_pattern(Some(subject.as_ref().into()), Some(gl::ASSOCIATED_PROPERTY), None, None)
-                    .filter_map(Result::ok) {
-                    if let Term::NamedNode(property) = quad.object {
-                        properties.insert(property);
-                    }
-                }
-                entities.insert(subject, Entity {
-                    label,
-                    comment,
-                    catalog_id,
-                    properties,
-                });
-            }
-        }*/
-
         let mut indexed_by = HashMap::new();
         for quad in store.quads_for_pattern(None, Some(gl::INDEXED_BY_FIELD), None, None)
             .filter_map(Result::ok) {
             if let NamedOrBlankNode::NamedNode(subject) = quad.subject
-                && let Term::NamedNode(field) = quad.object
-            {
+                && let Term::NamedNode(field) = quad.object {
                 indexed_by.insert(subject, field);
             }
         }
@@ -128,8 +87,6 @@ impl OntologyBuilder {
         Ok(Ontology {
             store,
             prefixes,
-            entities,
-            indexed_by,
         })
     }
 }
@@ -174,12 +131,6 @@ pub struct IndexField {
 pub struct Ontology {
     store: Store,
     prefixes: HashMap<String, String>,
-
-    // NamedIndividual of class Entity -> Rust Type
-    entities: HashMap<NamedNode, Entity>,
-
-    // Property -> NamedIndividual of class IndexField
-    indexed_by: HashMap<NamedNode, NamedNode>,
 }
 
 impl Ontology {
@@ -235,6 +186,14 @@ WHERE {{
         Ok(results)
     }
 
+    pub fn catalog_id(&self, class: &NamedNode) -> Option<u64> {
+        self.store.quads_for_pattern(Some(class.into()), Some(gl::CATALOG_ID), None, None)
+            .filter_map(Result::ok)
+            .map(conversion::quad_into_term)
+            .filter_map(conversion::term_into_u64)
+            .next()
+    }
+
     pub fn fields_for_class(&self, class: &NamedNode, language: &LanguageCondition) -> error::Result<Vec<IndexField>> {
         let language_filter = language.to_filter_expression("label");
         let query = format!(r#"SELECT DISTINCT ?name ?label {{
@@ -288,12 +247,6 @@ WHERE {{
             .map(|base| NamedNode::new_unchecked(format!("{base}{name}")))
     }
 
-    pub fn catalog_id(&self, class: &NamedNode) -> Option<u64> {
-        self.entities
-            .get(class)
-            .map(|entity| entity.catalog_id)
-    }
-
     pub fn info(&self, iri: &NamedNode, language: &LanguageCondition) -> LabeledIri {
         let label = self.store.quads_for_pattern(Some(iri.as_ref().into()), Some(rdfs::LABEL), None, None)
             .filter_map(Result::ok)
@@ -309,14 +262,6 @@ WHERE {{
         }
     }
 
-    pub fn labeled_entity(&self, class: &NamedNode) -> Option<LabeledIri> {
-        self.entities.get(class)
-            .map(|entity| LabeledIri {
-                iri: class.to_owned(),
-                label: entity.label.to_owned(),
-            })
-    }
-
     pub fn labeled_entities(&self, language: &LanguageCondition) -> impl Iterator<Item = LabeledIri> {
         self.store.quads_for_pattern(None, Some(rdf::TYPE), Some(gl::ENTITY.into()), None)
             .filter_map(Result::ok)