![[Jenkins]](/jenkins/static/779cc70e/images/svgs/logo.svg){kind=logo}
Package: ListHandler$MergeResult
ListHandler$MergeResult
| name | instruction | branch | complexity | line | method | ||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ListHandler.MergeResult(int, Resource) |
|
|
|
|
|
||||||||||||||||||||
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 java.util.ArrayList;
18: import java.util.Collection;
19: import java.util.List;
20:
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.Value;
26: import org.openrdf.model.ValueFactory;
27:
28: import cz.cvut.kbss.ontodriver.exception.IntegrityConstraintViolatedException;
29: import cz.cvut.kbss.ontodriver.sesame.connector.Connector;
30: import cz.cvut.kbss.ontodriver.sesame.exceptions.SesameDriverException;
31: import cz.cvut.kbss.ontodriver.descriptor.ListDescriptor;
32: import cz.cvut.kbss.ontodriver.descriptor.ListValueDescriptor;
33: import cz.cvut.kbss.ontodriver.descriptor.ReferencedListDescriptor;
34: import cz.cvut.kbss.ontodriver.descriptor.ReferencedListValueDescriptor;
35: import cz.cvut.kbss.ontodriver.descriptor.SimpleListDescriptor;
36: import cz.cvut.kbss.ontodriver.descriptor.SimpleListValueDescriptor;
37: import cz.cvut.kbss.ontodriver.model.Axiom;
38:
39: /**
40: * Base class for list handlers. </p>
41: *
42: * List handlers are responsible for loading and persisting lists.
43: *
44: * @author ledvima1
45: *
46: * @param <T>
47: * List descriptor type
48: * @param <V>
49: * List value descriptor type
50: */
51: abstract class ListHandler<T extends ListDescriptor, V extends ListValueDescriptor> {
52:
53: protected final Connector connector;
54: protected final ValueFactory vf;
55:
56: ListHandler(Connector connector, ValueFactory vf) {
57: this.connector = connector;
58: this.vf = vf;
59: }
60:
61: /**
62: * Loads axioms representing list described by the specified list
63: * descriptor.
64: *
65: * @return Collection of axioms representing sequence values
66: * @throws SesameDriverException
67: */
68: List<Axiom<NamedResource>> loadList(T listDescriptor) throws SesameDriverException {
69: final List<Axiom<NamedResource>> axioms = new ArrayList<>();
70: final SesameIterator it = createIterator(listDescriptor);
71: while (it.hasNext()) {
72: axioms.add(it.nextAxiom());
73: }
74: return axioms;
75: }
76:
77: abstract SesameIterator createIterator(T listDescriptor) throws SesameDriverException;
78:
79: /**
80: * Persists list values specified by the descriptor. </p>
81: *
82: * The values are saved in the order in which they appear in the descriptor.
83: *
84: * @param listValueDescriptor
85: * Describes values to persist
86: * @throws SesameDriverException
87: */
88: void persistList(V listValueDescriptor) throws SesameDriverException {
89: if (listValueDescriptor.getValues().isEmpty()) {
90: return;
91: }
92: final Collection<Statement> statements = new ArrayList<>(listValueDescriptor.getValues()
93: .size());
94: final URI head = createListHead(listValueDescriptor, statements);
95: statements.addAll(createListRest(head, listValueDescriptor));
96: connector.addStatements(statements);
97: }
98:
99: abstract URI createListHead(V valueDescriptor, Collection<Statement> listStatements) throws SesameDriverException;
100:
101: abstract List<Statement> createListRest(URI head, V valueDescriptor) throws SesameDriverException;
102:
103: /**
104: * Updates list with values specified by the descriptor. </p>
105: *
106: * @param listValueDescriptor
107: * Describes the updated values
108: * @throws SesameDriverException
109: */
110: void updateList(V listValueDescriptor) throws SesameDriverException {
111: if (listValueDescriptor.getValues().isEmpty()) {
112: clearList(listValueDescriptor);
113: } else if (isOldListEmpty(owner(listValueDescriptor), hasList(listValueDescriptor),
114: listValueDescriptor.getListProperty().isInferred(), context(listValueDescriptor))) {
115: persistList(listValueDescriptor);
116: } else {
117: mergeList(listValueDescriptor);
118: }
119: }
120:
121: private boolean isOldListEmpty(Resource owner, URI hasListProperty, boolean includeInferred,
122: URI context) throws SesameDriverException {
123: final Collection<Statement> stmts = connector.findStatements(owner, hasListProperty, null,
124: includeInferred, context);
125: return stmts.isEmpty();
126: }
127:
128: abstract void clearList(V listDescriptor) throws SesameDriverException;
129:
130: private void mergeList(V listDescriptor) throws SesameDriverException {
131: final SesameIterator it = iterator(listDescriptor);
132: final MergeResult mergeResult = mergeWithOriginalList(listDescriptor, it);
133: removeObsoletes(it);
134: assert mergeResult.i > 0;
135: assert mergeResult.previous != null;
136: if (mergeResult.i < listDescriptor.getValues().size()) {
137: appendNewNodes(listDescriptor, mergeResult);
138: }
139: }
140:
141: abstract SesameIterator iterator(V listDescriptor) throws SesameDriverException;
142:
143: abstract MergeResult mergeWithOriginalList(V listDescriptor, SesameIterator it) throws SesameDriverException;
144:
145: abstract void appendNewNodes(V listDescriptor, MergeResult mergeResult) throws SesameDriverException;
146:
147: void removeObsoletes(SesameIterator it) throws SesameDriverException {
148: while (it.hasNext()) {
149: it.nextNode();
150: it.remove();
151: }
152: }
153:
154: Resource extractListNode(Collection<Statement> stmts, URI nodeAssertion)
155: throws SesameDriverException {
156: if (stmts.size() > 1) {
157: throw new IntegrityConstraintViolatedException(
158: "Invalid number of values found for assertion " + nodeAssertion
159: + ". Expected 1, got " + stmts.size());
160: }
161: final Value val = stmts.iterator().next().getObject();
162: if (!(val instanceof Resource)) {
163: throw new IntegrityConstraintViolatedException(
164: "Invalid property value. Expected object property value, got literal.");
165: }
166: return (Resource) val;
167: }
168:
169: URI context(ListDescriptor listDescriptor) {
170: return sesameUri(listDescriptor.getContext());
171: }
172:
173: URI owner(ListDescriptor listDescriptor) {
174: return sesameUri(listDescriptor.getListOwner().getIdentifier());
175: }
176:
177: URI hasList(ListDescriptor listDescriptor) {
178: return sesameUri(listDescriptor.getListProperty().getIdentifier());
179: }
180:
181: URI hasNext(ListDescriptor listDescriptor) {
182: return sesameUri(listDescriptor.getNextNode().getIdentifier());
183: }
184:
185: URI sesameUri(java.net.URI uri) {
186: return SesameUtils.toSesameUri(uri, vf);
187: }
188:
189: /**
190: * Creates handler for simple lists.
191: *
192: * @param connector
193: * Storage connector
194: * @param vf
195: * Sesame value factory
196: * @return List handler
197: */
198: static ListHandler<SimpleListDescriptor, SimpleListValueDescriptor> createForSimpleList(
199: Connector connector, ValueFactory vf) {
200: assert connector != null;
201: assert vf != null;
202:
203: return new SimpleListHandler(connector, vf);
204: }
205:
206: /**
207: * Creates handler for referenced lists.
208: *
209: * @param connector
210: * Storage connector
211: * @param vf
212: * Sesame value factory
213: * @return List handler
214: */
215: static ListHandler<ReferencedListDescriptor, ReferencedListValueDescriptor> createForReferencedList(
216: Connector connector, ValueFactory vf) {
217: assert connector != null;
218: assert vf != null;
219:
220: return new ReferencedListHandler(connector, vf);
221: }
222:
223: static final class MergeResult {
224: protected int i;
225: protected Resource previous;
226: protected MergeResult(int i, Resource node) {
227: this.i = i;
228: this.previous = node;
229: }
230: }
231: }