![[Jenkins]](/jenkins/static/17afa8e7/images/svgs/logo.svg){kind=logo}
Package: ReferencedListHandler
ReferencedListHandler
| name | instruction | branch | complexity | line | method | ||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ReferencedListHandler(Connector, ValueFactory) |
|
|
|
|
|
||||||||||||||||||||
| appendNewNodes(ReferencedListValueDescriptor, ListHandler.MergeResult) |
|
|
|
|
|
||||||||||||||||||||
| clearList(ReferencedListValueDescriptor) |
|
|
|
|
|
||||||||||||||||||||
| createListHead(ReferencedListValueDescriptor, Collection) |
|
|
|
|
|
||||||||||||||||||||
| createListNode(IRI, IRI, IRI, Collection, IRI, Resource, Collection) |
|
|
|
|
|
||||||||||||||||||||
| createListRest(IRI, ReferencedListValueDescriptor) |
|
|
|
|
|
||||||||||||||||||||
| generateSequenceNode(IRI, IRI) |
|
|
|
|
|
||||||||||||||||||||
| hasContent(ReferencedListDescriptor) |
|
|
|
|
|
||||||||||||||||||||
| lambda$createListHead$0(Collection, IRI, IRI, IRI, Value) |
|
|
|
|
|
||||||||||||||||||||
| lambda$createListNode$1(Collection, IRI, IRI, IRI, Value) |
|
|
|
|
|
||||||||||||||||||||
| loadList(ReferencedListDescriptor) |
|
|
|
|
|
||||||||||||||||||||
| mergeList(ReferencedListValueDescriptor) |
|
|
|
|
|
||||||||||||||||||||
| mergeWithOriginalList(ReferencedListValueDescriptor, ListIterator) |
|
|
|
|
|
||||||||||||||||||||
| static {...} |
|
|
|
|
|
||||||||||||||||||||
| toRdf4jValue(Assertion, Object) |
|
|
|
|
|
||||||||||||||||||||
Coverage
1: /*
2: * JOPA
3: * Copyright (C) 2023 Czech Technical University in Prague
4: *
5: * This library is free software; you can redistribute it and/or
6: * modify it under the terms of the GNU Lesser General Public
7: * License as published by the Free Software Foundation; either
8: * version 3.0 of the License, or (at your option) any later version.
9: *
10: * This library is distributed in the hope that it will be useful,
11: * but WITHOUT ANY WARRANTY; without even the implied warranty of
12: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13: * Lesser General Public License for more details.
14: *
15: * You should have received a copy of the GNU Lesser General Public
16: * License along with this library.
17: */
18: package cz.cvut.kbss.ontodriver.rdf4j.list;
19:
20: import cz.cvut.kbss.ontodriver.descriptor.ReferencedListDescriptor;
21: import cz.cvut.kbss.ontodriver.descriptor.ReferencedListValueDescriptor;
22: import cz.cvut.kbss.ontodriver.model.Assertion;
23: import cz.cvut.kbss.ontodriver.model.Axiom;
24: import cz.cvut.kbss.ontodriver.rdf4j.connector.Connector;
25: import cz.cvut.kbss.ontodriver.rdf4j.exception.Rdf4jDriverException;
26: import cz.cvut.kbss.ontodriver.rdf4j.util.ValueConverter;
27: import org.eclipse.rdf4j.model.IRI;
28: import org.eclipse.rdf4j.model.Resource;
29: import org.eclipse.rdf4j.model.Statement;
30: import org.eclipse.rdf4j.model.Value;
31: import org.eclipse.rdf4j.model.ValueFactory;
32:
33: import java.util.ArrayList;
34: import java.util.Collection;
35: import java.util.Collections;
36: import java.util.Iterator;
37: import java.util.List;
38: import java.util.Set;
39:
40: public class ReferencedListHandler extends ListHandler<ReferencedListValueDescriptor<?>> {
41:
42: private int sequenceCounter = 0;
43:
44: private final ValueConverter valueConverter;
45:
46: public ReferencedListHandler(Connector connector, ValueFactory vf) {
47: super(connector, vf);
48: this.valueConverter = new ValueConverter(vf);
49: }
50:
51: /**
52: * Loads axioms representing list described by the specified list descriptor.
53: *
54: * @return Collection of axioms representing sequence values
55: * @throws Rdf4jDriverException When storage access error occurs
56: */
57: public List<Axiom<?>> loadList(ReferencedListDescriptor listDescriptor) throws Rdf4jDriverException {
58: final List<Axiom<?>> axioms = new ArrayList<>();
59: final ListIterator<?> it = new ReferencedListIterator<>(listDescriptor, connector, vf);
60:• while (it.hasNext()) {
61: axioms.add(it.nextAxiom());
62: }
63: return axioms;
64: }
65:
66: protected IRI createListHead(ReferencedListValueDescriptor<?> listValueDescriptor,
67: Collection<Statement> statements) throws Rdf4jDriverException {
68: final IRI owner = owner(listValueDescriptor);
69: final IRI hasList = hasList(listValueDescriptor);
70: final IRI hasContent = hasContent(listValueDescriptor);
71: final IRI context = context(listValueDescriptor);
72: final IRI nodeUri = generateSequenceNode(owner, context);
73: statements.add(vf.createStatement(owner, hasList, nodeUri, context));
74: final Collection<Value> nodeContent = toRdf4jValue(listValueDescriptor.getNodeContent(), listValueDescriptor.getValues()
75: .get(0));
76: nodeContent.forEach(item -> statements.add(vf.createStatement(nodeUri, hasContent, item, context)));
77: return nodeUri;
78: }
79:
80: private IRI hasContent(ReferencedListDescriptor listDescriptor) {
81: return toRdf4jIri(listDescriptor.getNodeContent().getIdentifier());
82: }
83:
84: private Collection<Value> toRdf4jValue(Assertion a, Object value) throws Rdf4jDriverException {
85: return new ReferencedListHelper(valueConverter).toRdf4jValue(a, value);
86: }
87:
88: private IRI generateSequenceNode(IRI owner, IRI context) throws Rdf4jDriverException {
89: final String uriBase = owner.stringValue();
90: boolean unique;
91: IRI node;
92: do {
93: node = vf.createIRI(uriBase + "-SEQ_" + sequenceCounter++);
94: final Collection<Statement> stmts = connector.findStatements(node, null, null, false,
95:• context != null ? Collections.singleton(context) : Collections.emptySet());
96: unique = stmts.isEmpty();
97:• } while (!unique);
98: return node;
99: }
100:
101: protected List<Statement> createListRest(IRI headNode, ReferencedListValueDescriptor<?> listValueDescriptor)
102: throws Rdf4jDriverException {
103: final IRI owner = owner(listValueDescriptor);
104: final IRI hasNext = hasNext(listValueDescriptor);
105: final IRI hasContent = hasContent(listValueDescriptor);
106: final IRI context = context(listValueDescriptor);
107: IRI previous = headNode;
108: final List<Statement> statements = new ArrayList<>(listValueDescriptor.getValues().size() * 2);
109: final Iterator<?> it = listValueDescriptor.getValues().iterator();
110: // Skip the first element, it is already in the head
111: it.next();
112:• while (it.hasNext()) {
113: final Collection<Value> content = toRdf4jValue(listValueDescriptor.getNodeContent(), it.next());
114: previous = createListNode(owner, hasNext, hasContent, content, context, previous, statements);
115: }
116: return statements;
117: }
118:
119: private IRI createListNode(IRI owner, IRI hasNext, IRI hasContent, Collection<Value> content, IRI context,
120: Resource previous,
121: Collection<Statement> statements) throws Rdf4jDriverException {
122: final IRI node = generateSequenceNode(owner, context);
123: statements.add(vf.createStatement(previous, hasNext, node, context));
124: content.forEach(item -> statements.add(vf.createStatement(node, hasContent, item, context)));
125: return node;
126: }
127:
128: @Override
129: protected void clearList(ReferencedListValueDescriptor<?> listDescriptor) throws Rdf4jDriverException {
130: final IRI hasNext = hasNext(listDescriptor);
131: final IRI hasContent = hasContent(listDescriptor);
132: final boolean includeInferred = listDescriptor.getListProperty().isInferred();
133: final Set<IRI> context = contexts(listDescriptor);
134: Resource previous = owner(listDescriptor);
135: IRI currentProperty = hasList(listDescriptor);
136: final Collection<Statement> toRemove = new ArrayList<>();
137: Collection<Statement> next;
138: do {
139: next = connector.findStatements(previous, currentProperty, null, includeInferred, context);
140:• if (!next.isEmpty()) {
141: final Resource node = extractListNode(next, currentProperty);
142: toRemove.addAll(next);
143: toRemove.addAll(connector.findStatements(node, hasContent, null, includeInferred, context));
144: previous = node;
145: }
146: currentProperty = hasNext;
147:• } while (!next.isEmpty());
148: connector.removeStatements(toRemove);
149: }
150:
151: protected void mergeList(ReferencedListValueDescriptor<?> listDescriptor) throws Rdf4jDriverException {
152: final ListIterator<Object> it = new ReferencedListIterator<>(listDescriptor, connector, vf);
153: final ListHandler.MergeResult mergeResult = mergeWithOriginalList((ReferencedListValueDescriptor<Object>) listDescriptor, it);
154: removeObsoletes(it);
155:• assert mergeResult.i > 0;
156:• assert mergeResult.previous != null;
157:• if (mergeResult.i < listDescriptor.getValues().size()) {
158: appendNewNodes(listDescriptor, mergeResult);
159: }
160: }
161:
162: <V> MergeResult mergeWithOriginalList(ReferencedListValueDescriptor<V> listDescriptor, ListIterator<V> it)
163: throws Rdf4jDriverException {
164: int i = 0;
165: Resource node = null;
166:• while (it.hasNext() && i < listDescriptor.getValues().size()) {
167: node = it.nextNode();
168: final V content = it.currentContent();
169: final V newNode = listDescriptor.getValues().get(i);
170:• if (!content.equals(newNode)) {
171: it.replaceCurrentWith(newNode);
172: }
173: i++;
174: }
175: return new MergeResult(i, node);
176: }
177:
178: <V> void appendNewNodes(ReferencedListValueDescriptor<V> listDescriptor, MergeResult mergeResult)
179: throws Rdf4jDriverException {
180: int i = mergeResult.i;
181: Resource previous = mergeResult.previous;
182: final IRI owner = owner(listDescriptor);
183: final IRI hasNext = hasNext(listDescriptor);
184: final IRI hasContent = hasContent(listDescriptor);
185: final IRI context = context(listDescriptor);
186:• assert i > 0;
187: final Collection<Statement> toAdd = new ArrayList<>((listDescriptor.getValues().size() - i) * 2);
188:• while (i < listDescriptor.getValues().size()) {
189: final Collection<Value> content = toRdf4jValue(listDescriptor.getNodeContent(), listDescriptor.getValues()
190: .get(i));
191: previous = createListNode(owner, hasNext, hasContent, content, context, previous, toAdd);
192: i++;
193: }
194: connector.addStatements(toAdd);
195: }
196: }