perf(rdf): make id issuer return references

amimart · amimart · commit 64a227fd76d6 · 2024-03-26T12:10:26.000+01:00
diff --git a/contracts/okp4-cognitarium/src/contract.rs b/contracts/okp4-cognitarium/src/contract.rs
@@ -298,15 +298,15 @@ pub mod query {
             .map(|t| TripleConstructTemplate {
                 subject: match t.subject {
                     VarOrNode::Node(Node::BlankNode(n)) => {
-                        VarOrNode::Node(Node::BlankNode(id_issuer.get_str_or_issue(n)))
+                        VarOrNode::Node(Node::BlankNode(id_issuer.get_str_or_issue(n).to_string()))
                     }
                     _ => t.subject,
                 },
                 predicate: t.predicate,
                 object: match t.object {
-                    VarOrNodeOrLiteral::Node(Node::BlankNode(n)) => {
-                        VarOrNodeOrLiteral::Node(Node::BlankNode(id_issuer.get_str_or_issue(n)))
-                    }
+                    VarOrNodeOrLiteral::Node(Node::BlankNode(n)) => VarOrNodeOrLiteral::Node(
+                        Node::BlankNode(id_issuer.get_str_or_issue(n).to_string()),
+                    ),
                     _ => t.object,
                 },
             })
diff --git a/contracts/okp4-cognitarium/src/querier/engine.rs b/contracts/okp4-cognitarium/src/querier/engine.rs
@@ -902,9 +902,9 @@ impl AtomTemplate {
             &mut |value| {
                 Ok(match value {
                     Subject::Named(n) => rdf::Subject::NamedNode(n.as_iri(resolve_ns_fn)?),
-                    Subject::Blank(n) => {
-                        rdf::Subject::BlankNode(id_issuer.get_str_or_issue(n.to_string()))
-                    }
+                    Subject::Blank(n) => rdf::Subject::BlankNode(
+                        id_issuer.get_str_or_issue(n.to_string()).to_string(),
+                    ),
                 })
             },
             "subject",
@@ -945,7 +945,7 @@ impl AtomTemplate {
                 Ok(match value {
                     Object::Named(n) => rdf::Value::NamedNode(n.as_iri(resolve_ns_fn)?),
                     Object::Blank(n) => {
-                        rdf::Value::BlankNode(id_issuer.get_str_or_issue(n.to_string()))
+                        rdf::Value::BlankNode(id_issuer.get_str_or_issue(n.to_string()).to_string())
                     }
                     Object::Literal(l) => match l {
                         state::Literal::Simple { value } => rdf::Value::LiteralSimple(value),
diff --git a/contracts/okp4-cognitarium/src/querier/variable.rs b/contracts/okp4-cognitarium/src/querier/variable.rs
@@ -59,7 +59,7 @@ impl ResolvedVariable {
                     value: IRI::Full(iri),
                 })?,
                 Subject::Blank(blank) => Value::BlankNode {
-                    value: id_issuer.get_str_or_issue(blank.to_string()),
+                    value: id_issuer.get_str_or_issue(blank.to_string()).to_string(),
                 },
             },
             ResolvedVariable::Predicate(predicate) => {
@@ -72,7 +72,7 @@ impl ResolvedVariable {
                     value: IRI::Full(named.as_iri(ns_fn)?),
                 },
                 Object::Blank(blank) => Value::BlankNode {
-                    value: id_issuer.get_str_or_issue(blank.to_string()),
+                    value: id_issuer.get_str_or_issue(blank.to_string()).to_string(),
                 },
                 Object::Literal(literal) => match literal {
                     Literal::Simple { value } => Value::Literal {
diff --git a/packages/okp4-rdf/src/normalize.rs b/packages/okp4-rdf/src/normalize.rs
@@ -233,7 +233,7 @@ impl<'a> Normalizer<'a> {
                         if !issuer.issued(&related) {
                             recursion_list.push(related.clone());
                         }
-                        path.push_str(&issuer.get_str_or_issue(related));
+                        path.push_str(issuer.get_str_or_issue(related));
                     }
                 }
 
@@ -245,7 +245,7 @@ impl<'a> Normalizer<'a> {
                 for related in recursion_list {
                     let (result, mut issuer) = self.compute_n_degree_hash(&mut issuer, &related)?;
                     path.push_str("_:");
-                    path.push_str(&issuer.get_str_or_issue(related));
+                    path.push_str(issuer.get_str_or_issue(related));
                     path.push('<');
                     path.push_str(&result);
                     path.push('>');
@@ -347,25 +347,26 @@ impl IdentifierIssuer {
         }
     }
 
-    pub fn get_or_issue(&mut self, identifier: String) -> (u128, String) {
-        match self.issued.entry(identifier.clone()) {
-            Entry::Occupied(e) => e.get().clone(),
+    pub fn get_or_issue(&mut self, identifier: String) -> (u128, &str) {
+        let res = match self.issued.entry(identifier.clone()) {
+            Entry::Occupied(e) => e.into_mut(),
             Entry::Vacant(e) => {
                 let n = self.counter;
                 let str = format!("{}{}", self.prefix, n);
                 self.counter += 1;
 
                 self.issue_log.push(identifier);
-                e.insert((n, str)).clone()
+                e.insert((n, str))
             }
-        }
+        };
+        (res.0, res.1.as_str())
     }
 
     pub fn get_n_or_issue(&mut self, identifier: String) -> u128 {
         self.get_or_issue(identifier).0
     }
 
-    pub fn get_str_or_issue(&mut self, identifier: String) -> String {
+    pub fn get_str_or_issue(&mut self, identifier: String) -> &str {
         self.get_or_issue(identifier).1
     }
 

Original file line number	Diff line number	Diff line change
`@@ -233,7 +233,7 @@ impl<'a> Normalizer<'a> {`
`233`	`233`	`if !issuer.issued(&related) {`
`234`	`234`	`recursion_list.push(related.clone());`
`235`	`235`	`}`
`236`		`- path.push_str(&issuer.get_str_or_issue(related));`
	`236`	`+ path.push_str(issuer.get_str_or_issue(related));`
`237`	`237`	`}`
`238`	`238`	`}`
`239`	`239`
`@@ -245,7 +245,7 @@ impl<'a> Normalizer<'a> {`
`245`	`245`	`for related in recursion_list {`
`246`	`246`	`let (result, mut issuer) = self.compute_n_degree_hash(&mut issuer, &related)?;`
`247`	`247`	`path.push_str("_:");`
`248`		`- path.push_str(&issuer.get_str_or_issue(related));`
	`248`	`+ path.push_str(issuer.get_str_or_issue(related));`
`249`	`249`	`path.push('<');`
`250`	`250`	`path.push_str(&result);`
`251`	`251`	`path.push('>');`
`@@ -347,25 +347,26 @@ impl IdentifierIssuer {`
`347`	`347`	`}`
`348`	`348`	`}`
`349`	`349`
`350`		`- pub fn get_or_issue(&mut self, identifier: String) -> (u128, String) {`
`351`		`- match self.issued.entry(identifier.clone()) {`
`352`		`- Entry::Occupied(e) => e.get().clone(),`
	`350`	`+ pub fn get_or_issue(&mut self, identifier: String) -> (u128, &str) {`
	`351`	`+ let res = match self.issued.entry(identifier.clone()) {`
	`352`	`+ Entry::Occupied(e) => e.into_mut(),`
`353`	`353`	`Entry::Vacant(e) => {`
`354`	`354`	`let n = self.counter;`
`355`	`355`	`let str = format!("{}{}", self.prefix, n);`
`356`	`356`	`self.counter += 1;`
`357`	`357`
`358`	`358`	`self.issue_log.push(identifier);`
`359`		`- e.insert((n, str)).clone()`
	`359`	`+ e.insert((n, str))`
`360`	`360`	`}`
`361`		`- }`
	`361`	`+ };`
	`362`	`+ (res.0, res.1.as_str())`
`362`	`363`	`}`
`363`	`364`
`364`	`365`	`pub fn get_n_or_issue(&mut self, identifier: String) -> u128 {`
`365`	`366`	`self.get_or_issue(identifier).0`
`366`	`367`	`}`
`367`	`368`
`368`		`- pub fn get_str_or_issue(&mut self, identifier: String) -> String {`
	`369`	`+ pub fn get_str_or_issue(&mut self, identifier: String) -> &str {`
`369`	`370`	`self.get_or_issue(identifier).1`
`370`	`371`	`}`
`371`	`372`