Skip to content

Package: ReferencedListHandler

ReferencedListHandler

nameinstructionbranchcomplexitylinemethod
ReferencedListHandler(Connector, ValueFactory)
M: 0 C: 8
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 3
100%
M: 0 C: 1
100%
appendNewNodes(ReferencedListValueDescriptor, ListHandler.MergeResult)
M: 4 C: 67
94%
M: 1 C: 3
75%
M: 1 C: 2
67%
M: 0 C: 16
100%
M: 0 C: 1
100%
clearList(ReferencedListValueDescriptor)
M: 0 C: 82
100%
M: 0 C: 4
100%
M: 0 C: 3
100%
M: 0 C: 17
100%
M: 0 C: 1
100%
createIterator(ReferencedListDescriptor)
M: 0 C: 9
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 1
100%
M: 0 C: 1
100%
createListHead(ReferencedListValueDescriptor, Collection)
M: 0 C: 52
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 9
100%
M: 0 C: 1
100%
createListNode(URI, URI, URI, URI, URI, Resource, Collection)
M: 0 C: 27
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 4
100%
M: 0 C: 1
100%
createListRest(URI, ReferencedListValueDescriptor)
M: 0 C: 57
100%
M: 0 C: 2
100%
M: 0 C: 2
100%
M: 0 C: 14
100%
M: 0 C: 1
100%
generateSequenceNode(URI, URI)
M: 0 C: 44
100%
M: 0 C: 2
100%
M: 0 C: 2
100%
M: 0 C: 6
100%
M: 0 C: 1
100%
hasContent(ReferencedListDescriptor)
M: 0 C: 6
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 1
100%
M: 0 C: 1
100%
iterator(ReferencedListValueDescriptor)
M: 0 C: 9
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 1
100%
M: 0 C: 1
100%
mergeWithOriginalList(ReferencedListValueDescriptor, SesameIterator)
M: 0 C: 42
100%
M: 0 C: 6
100%
M: 0 C: 4
100%
M: 0 C: 11
100%
M: 0 C: 1
100%
static {...}
M: 0 C: 1
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 1
100%
M: 0 C: 1
100%

Coverage

1: /**
2: * Copyright (C) 2016 Czech Technical University in Prague
3: *
4: * This program is free software: you can redistribute it and/or modify it under
5: * the terms of the GNU General Public License as published by the Free Software
6: * Foundation, either version 3 of the License, or (at your option) any
7: * later version.
8: *
9: * This program is distributed in the hope that it will be useful, but WITHOUT
10: * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11: * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
12: * details. You should have received a copy of the GNU General Public License
13: * along with this program. If not, see <http://www.gnu.org/licenses/>.
14: */
15: package cz.cvut.kbss.ontodriver.sesame;
16:
17: import cz.cvut.kbss.ontodriver.sesame.connector.Connector;
18: import cz.cvut.kbss.ontodriver.sesame.exceptions.SesameDriverException;
19: import cz.cvut.kbss.ontodriver.descriptor.ReferencedListDescriptor;
20: import cz.cvut.kbss.ontodriver.descriptor.ReferencedListValueDescriptor;
21: import cz.cvut.kbss.ontodriver.model.NamedResource;
22: import org.openrdf.model.Resource;
23: import org.openrdf.model.Statement;
24: import org.openrdf.model.URI;
25: import org.openrdf.model.ValueFactory;
26:
27: import java.util.ArrayList;
28: import java.util.Collection;
29: import java.util.Iterator;
30: import java.util.List;
31:
32: public class ReferencedListHandler extends
33:                 ListHandler<ReferencedListDescriptor, ReferencedListValueDescriptor> {
34:
35:         private int sequenceCounter = 0;
36:
37:         ReferencedListHandler(Connector connector, ValueFactory vf) {
38:                 super(connector, vf);
39:         }
40:
41:         @Override
42:         SesameIterator createIterator(ReferencedListDescriptor listDescriptor) throws SesameDriverException {
43:                 return new ReferencedListIterator(listDescriptor, connector, vf);
44:         }
45:
46:         URI createListHead(ReferencedListValueDescriptor listValueDescriptor,
47:                         Collection<Statement> statements) throws SesameDriverException {
48:                 final URI owner = owner(listValueDescriptor);
49:                 final URI hasList = hasList(listValueDescriptor);
50:                 final URI hasContent = hasContent(listValueDescriptor);
51:                 final URI context = context(listValueDescriptor);
52:                 final URI nodeUri = generateSequenceNode(owner, context);
53:                 statements.add(vf.createStatement(owner, hasList, nodeUri, context));
54:                 final URI nodeContent = sesameUri(listValueDescriptor.getValues().get(0).getIdentifier());
55:                 statements.add(vf.createStatement(nodeUri, hasContent, nodeContent, context));
56:                 return nodeUri;
57:         }
58:
59:         private URI hasContent(ReferencedListDescriptor listDescriptor) {
60:                 return sesameUri(listDescriptor.getNodeContent().getIdentifier());
61:         }
62:
63:         private URI generateSequenceNode(URI owner, URI context) throws SesameDriverException {
64:                 final String uriBase = owner.stringValue();
65:                 boolean unique;
66:                 URI node;
67:                 do {
68:                         node = vf.createURI(uriBase + "-SEQ_" + sequenceCounter++);
69:                         final Collection<Statement> stmts = connector.findStatements(node, null, null, false,
70:                                         context);
71:                         unique = stmts.isEmpty();
72:•                } while (!unique);
73:                 return node;
74:         }
75:
76:         List<Statement> createListRest(URI headNode,
77:                         ReferencedListValueDescriptor listValueDescriptor) throws SesameDriverException {
78:                 final URI owner = owner(listValueDescriptor);
79:                 final URI hasNext = hasNext(listValueDescriptor);
80:                 final URI hasContent = hasContent(listValueDescriptor);
81:                 final URI context = context(listValueDescriptor);
82:                 URI previous = headNode;
83:                 final List<Statement> statements = new ArrayList<>(
84:                                 listValueDescriptor.getValues().size() * 2);
85:                 final Iterator<NamedResource> it = listValueDescriptor.getValues().iterator();
86:                 // Skip the first element, it is already in the head
87:                 it.next();
88:•                while (it.hasNext()) {
89:                         final URI content = sesameUri(it.next().getIdentifier());
90:                         previous = createListNode(owner, hasNext, hasContent, content, context, previous, statements);
91:                 }
92:                 return statements;
93:         }
94:
95:         private URI createListNode(URI owner, URI hasNext, URI hasContent, URI content, URI context, Resource previous, Collection<Statement> statements) throws SesameDriverException {
96:                 final URI node = generateSequenceNode(owner, context);
97:                 statements.add(vf.createStatement(previous, hasNext, node, context));
98:                 statements.add(vf.createStatement(node, hasContent, content, context));
99:                 return node;
100:         }
101:
102:         @Override
103:         void clearList(ReferencedListValueDescriptor listDescriptor) throws SesameDriverException {
104:                 final URI hasNext = hasNext(listDescriptor);
105:                 final URI hasContent = hasContent(listDescriptor);
106:                 final boolean includeInferred = listDescriptor.getListProperty().isInferred();
107:                 final URI context = context(listDescriptor);
108:                 Resource previous = owner(listDescriptor);
109:                 URI currentProperty = hasList(listDescriptor);
110:                 final Collection<Statement> toRemove = new ArrayList<>();
111:                 Collection<Statement> next;
112:                 do {
113:                         next = connector.findStatements(previous, currentProperty, null, includeInferred,
114:                                         context);
115:•                        if (!next.isEmpty()) {
116:                                 final Resource node = extractListNode(next, currentProperty);
117:                                 toRemove.addAll(next);
118:                                 toRemove.addAll(connector.findStatements(node, hasContent, null, includeInferred,
119:                                                 context));
120:                                 previous = node;
121:                         }
122:                         currentProperty = hasNext;
123:•                } while (!next.isEmpty());
124:                 connector.removeStatements(toRemove);
125:         }
126:
127:         @Override
128:         SesameIterator iterator(ReferencedListValueDescriptor listDescriptor) throws SesameDriverException {
129:                 return new ReferencedListIterator(listDescriptor, connector, vf);
130:         }
131:
132:         @Override
133:         MergeResult mergeWithOriginalList(ReferencedListValueDescriptor listDescriptor, SesameIterator it) throws SesameDriverException {
134:                 int i = 0;
135:                 Resource node = null;
136:•                while (it.hasNext() && i < listDescriptor.getValues().size()) {
137:                         node = it.nextNode();
138:                         final Resource content = it.currentContent();
139:                         final NamedResource newNode = listDescriptor.getValues().get(i);
140:•                        if (!content.stringValue().equals(newNode.getIdentifier().toString())) {
141:                                 it.replaceCurrentWith(newNode);
142:                         }
143:                         i++;
144:                 }
145:                 return new MergeResult(i, node);
146:         }
147:
148:         @Override
149:         void appendNewNodes(ReferencedListValueDescriptor listDescriptor, MergeResult mergeResult) throws SesameDriverException {
150:                 int i = mergeResult.i;
151:                 Resource previous = mergeResult.previous;
152:                 final URI owner = owner(listDescriptor);
153:                 final URI hasNext = hasNext(listDescriptor);
154:                 final URI hasContent = hasContent(listDescriptor);
155:                 final URI context = context(listDescriptor);
156:•                assert i > 0;
157:                 final Collection<Statement> toAdd = new ArrayList<>(
158:                                 (listDescriptor.getValues().size() - i) * 2);
159:•                while (i < listDescriptor.getValues().size()) {
160:                         final URI content = sesameUri(listDescriptor.getValues().get(i).getIdentifier());
161:                         previous = createListNode(owner, hasNext, hasContent, content, context, previous, toAdd);
162:                         i++;
163:                 }
164:                 connector.addStatements(toAdd);
165:         }
166: }