Method: removedDefault()

1: /*
2: * JOPA
3: * Copyright (C) 2024 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.jena.connector;
19:
20: import org.apache.jena.query.Dataset;
21: import org.apache.jena.query.DatasetFactory;
22: import org.apache.jena.rdf.model.Model;
23: import org.apache.jena.rdf.model.Property;
24: import org.apache.jena.rdf.model.RDFNode;
25: import org.apache.jena.rdf.model.Resource;
26: import org.apache.jena.rdf.model.Statement;
27:
28: import java.util.ArrayList;
29: import java.util.Collection;
30: import java.util.Collections;
31: import java.util.HashSet;
32: import java.util.Iterator;
33: import java.util.List;
34: import java.util.Set;
35: import java.util.stream.Collectors;
36:
37: /**
38: * Tracks transactional changes.
39: */
40: class LocalModel {
41:
42: private final Dataset added;
43: private final Dataset removed;
44: private final Set<SubjectPredicateContext> removedSubjectPredicateStatements;
45:
46: /**
47: * Whether default graph should be treated as union of all graphs.
48: */
49: private final boolean defaultAsUnion;
50:
51: enum Containment {
52: ADDED, REMOVED, UNKNOWN
53: }
54:
55: LocalModel(boolean defaultAsUnion) {
56: this.added = DatasetFactory.create();
57: this.removed = DatasetFactory.create();
58: this.removedSubjectPredicateStatements = new HashSet<>();
59: this.defaultAsUnion = defaultAsUnion;
60: }
61:
62: Collection<Statement> enhanceStatements(Collection<Statement> statements, Resource subject, Property property,
63: RDFNode value, Collection<String> contexts) {
64: if (contexts.isEmpty()) {
65: return enhanceStatements(statements, subject, property, value, addedDefault(), removedDefault(), null);
66: } else {
67: Collection<Statement> enhanced = statements;
68: for (String ctx : contexts) {
69: enhanced = enhanceStatements(statements, subject, property, value, added.getNamedModel(ctx),
70: removed.getNamedModel(ctx), ctx);
71: }
72: return enhanced;
73: }
74: }
75:
76: private Model addedDefault() {
77: return defaultAsUnion ? added.getUnionModel().union(added.getDefaultModel()) : added.getDefaultModel();
78: }
79:
80: private Model removedDefault() {
81:• return defaultAsUnion ? removed.getUnionModel().union(removed.getDefaultModel()) : removed.getDefaultModel();
82: }
83:
84: private Collection<Statement> enhanceStatements(Collection<Statement> toEnhance, Resource subject,
85: Property property, RDFNode value, Model addedModel,
86: Model removedModel, String context) {
87: final Set<Statement> statements = new HashSet<>(toEnhance);
88: statements.addAll(addedModel.listStatements(subject, property, value).toList());
89: removedModel.listStatements(subject, property, value).toList().forEach(statements::remove);
90: return statements.stream()
91: .filter(s -> removedSubjectPredicateStatements.stream()
92: .noneMatch(spc -> spc.matches(s, context)))
93: .collect(Collectors.toSet());
94: }
95:
96: Containment contains(Resource subject, Property property, RDFNode value, Collection<String> contexts) {
97: if (contexts.isEmpty()) {
98: if (removedDefault().contains(subject, property, value) || removedSubjectPredicateStatements.contains(new SubjectPredicateContext(subject, property, Collections.emptySet()))) {
99: return Containment.REMOVED;
100: } else {
101: return addedDefault().contains(subject, property, value) ? Containment.ADDED :
102: Containment.UNKNOWN;
103: }
104: } else {
105: Containment result = Containment.UNKNOWN;
106: if (removedSubjectPredicateStatements.contains(new SubjectPredicateContext(subject, property, new HashSet<>(contexts)))) {
107: return Containment.REMOVED;
108: }
109: for (String c : contexts) {
110: if (removed.getNamedModel(c).contains(subject, property, value)) {
111: return Containment.REMOVED;
112: } else if (added.getNamedModel(c).contains(subject, property, value)) {
113: result = Containment.ADDED;
114: }
115: }
116: return result;
117: }
118: }
119:
120: void addStatements(List<Statement> statements, String context) {
121: registerStatements(statements, context, added, removed);
122: }
123:
124: private void registerStatements(List<Statement> statements, String context, Dataset addTo, Dataset removeFrom) {
125: if (context != null) {
126: addTo.getNamedModel(context).add(statements);
127: removeFrom.getNamedModel(context).remove(statements);
128: } else {
129: addTo.getDefaultModel().add(statements);
130: removeFrom.getDefaultModel().remove(statements);
131: if (defaultAsUnion) {
132: removeFrom.listNames().forEachRemaining(n -> removeFrom.getNamedModel(n).remove(statements));
133: }
134: }
135: }
136:
137: void removeStatements(List<Statement> statements, String context) {
138: registerStatements(statements, context, removed, added);
139: }
140:
141: void removePropertyValues(Collection<SubjectPredicateContext> toRemove) {
142: removedSubjectPredicateStatements.addAll(toRemove);
143: toRemove.forEach(spc -> {
144: if (spc.getContexts().isEmpty()) {
145: added.getDefaultModel().remove(added.getDefaultModel()
146: .listStatements(spc.getSubject(), spc.getPredicate(), (RDFNode) null));
147: } else {
148: spc.getContexts().forEach(c -> added.getNamedModel(c).remove(added.getNamedModel(c)
149: .listStatements(spc.getSubject(), spc.getPredicate(), (RDFNode) null)));
150: }
151: });
152: }
153:
154: Dataset getAdded() {
155: return added;
156: }
157:
158: Dataset getRemoved() {
159: return removed;
160: }
161:
162: public Set<SubjectPredicateContext> getRemovedSubjectPredicateStatements() {
163: return removedSubjectPredicateStatements;
164: }
165:
166: List<String> getContexts() {
167: final Iterator<String> it = added.listNames();
168: final List<String> contexts = new ArrayList<>();
169: it.forEachRemaining(contexts::add);
170: return contexts;
171: }
172: }