![[Jenkins]](/jenkins/static/cad58ee1/images/svgs/logo.svg){kind=logo}
Package: UnitOfWorkImpl
UnitOfWorkImpl
| name | instruction | branch | complexity | line | method | ||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| UnitOfWorkImpl(AbstractSession) |
|
|
|
|
|
||||||||||||||||||||
| acquireConnection() |
|
|
|
|
|
||||||||||||||||||||
| acquireUnitOfWork() |
|
|
|
|
|
||||||||||||||||||||
| attributeChanged(Object, Field) |
|
|
|
|
|
||||||||||||||||||||
| calculateChanges() |
|
|
|
|
|
||||||||||||||||||||
| calculateDeletedObjects(UnitOfWorkChangeSet) |
|
|
|
|
|
||||||||||||||||||||
| calculateNewObjects(UnitOfWorkChangeSet) |
|
|
|
|
|
||||||||||||||||||||
| checkForIndirectObjects(Object) |
|
|
|
|
|
||||||||||||||||||||
| clear() |
|
|
|
|
|
||||||||||||||||||||
| cloneLoadedFieldValue(Object, Field, Descriptor, Object) |
|
|
|
|
|
||||||||||||||||||||
| commit() |
|
|
|
|
|
||||||||||||||||||||
| commitToOntology() |
|
|
|
|
|
||||||||||||||||||||
| commitUnitOfWork() |
|
|
|
|
|
||||||||||||||||||||
| contains(Object) |
|
|
|
|
|
||||||||||||||||||||
| containsOriginal(Object) |
|
|
|
|
|
||||||||||||||||||||
| copyChangeSet(ObjectChangeSet, Object, Object, Descriptor) |
|
|
|
|
|
||||||||||||||||||||
| createAndRegisterChangeRecord(Object, FieldSpecification, Descriptor) |
|
|
|
|
|
||||||||||||||||||||
| createIndirectCollection(Object, Object, Field) |
|
|
|
|
|
||||||||||||||||||||
| createMap() |
|
|
|
|
|
||||||||||||||||||||
| deregisterEntityFromPersistenceContext(Object) |
|
|
|
|
|
||||||||||||||||||||
| detachAllManagedInstances() |
|
|
|
|
|
||||||||||||||||||||
| entityType(Class) |
|
|
|
|
|
||||||||||||||||||||
| evictPossiblyUpdatedReferencesFromCache() |
|
|
|
|
|
||||||||||||||||||||
| getCloneBuilder() |
|
|
|
|
|
||||||||||||||||||||
| getCloneForOriginal(Object) |
|
|
|
|
|
||||||||||||||||||||
| getContexts() |
|
|
|
|
|
||||||||||||||||||||
| getDescriptor(Object) |
|
|
|
|
|
||||||||||||||||||||
| getFieldDescriptor(Object, Field, Descriptor) |
|
|
|
|
|
||||||||||||||||||||
| getIdentifier(Object) |
|
|
|
|
|
||||||||||||||||||||
| getInstanceForMerge(URI, EntityType, Descriptor) |
|
|
|
|
|
||||||||||||||||||||
| getLiveObjectCache() |
|
|
|
|
|
||||||||||||||||||||
| getManagedClone(Class, Object, Descriptor) |
|
|
|
|
|
||||||||||||||||||||
| getManagedOriginal(Class, Object, Descriptor) |
|
|
|
|
|
||||||||||||||||||||
| getMetamodel() |
|
|
|
|
|
||||||||||||||||||||
| getNamedQueryManager() |
|
|
|
|
|
||||||||||||||||||||
| getOriginal(Object) |
|
|
|
|
|
||||||||||||||||||||
| getReference(Class, Object, Descriptor) |
|
|
|
|
|
||||||||||||||||||||
| getResultSetMappingManager() |
|
|
|
|
|
||||||||||||||||||||
| getState(Object) |
|
|
|
|
|
||||||||||||||||||||
| getState(Object, Descriptor) |
|
|
|
|
|
||||||||||||||||||||
| getUowChangeSet() |
|
|
|
|
|
||||||||||||||||||||
| hasChanges() |
|
|
|
|
|
||||||||||||||||||||
| isActive() |
|
|
|
|
|
||||||||||||||||||||
| isConsistent(URI) |
|
|
|
|
|
||||||||||||||||||||
| isEntityType(Class) |
|
|
|
|
|
||||||||||||||||||||
| isInCommit() |
|
|
|
|
|
||||||||||||||||||||
| isInRepository(Descriptor, Object) |
|
|
|
|
|
||||||||||||||||||||
| isInTransaction() |
|
|
|
|
|
||||||||||||||||||||
| isIndividualManaged(Object, Object) |
|
|
|
|
|
||||||||||||||||||||
| isLoaded(Object) |
|
|
|
|
|
||||||||||||||||||||
| isLoaded(Object, String) |
|
|
|
|
|
||||||||||||||||||||
| isObjectManaged(Object) |
|
|
|
|
|
||||||||||||||||||||
| isObjectNew(Object) |
|
|
|
|
|
||||||||||||||||||||
| isSameType(Object, Object) |
|
|
|
|
|
||||||||||||||||||||
| lambda$calculateNewObjects$0(Descriptor, Object) |
|
|
|
|
|
||||||||||||||||||||
| lambda$detachAllManagedInstances$1(Object) |
|
|
|
|
|
||||||||||||||||||||
| lambda$detachAllManagedInstances$2(Object) |
|
|
|
|
|
||||||||||||||||||||
| lambda$evictPossiblyUpdatedReferencesFromCache$4(Object, Object) |
|
|
|
|
|
||||||||||||||||||||
| lambda$registerExistingObject$5(Object, Consumer) |
|
|
|
|
|
||||||||||||||||||||
| lambda$validateIntegrityConstraints$3(IntegrityConstraintsValidator, ObjectChangeSet) |
|
|
|
|
|
||||||||||||||||||||
| loadEntityField(Object, Field) |
|
|
|
|
|
||||||||||||||||||||
| mergeChangesIntoParent() |
|
|
|
|
|
||||||||||||||||||||
| mergeDetached(Object, Descriptor) |
|
|
|
|
|
||||||||||||||||||||
| mergeDetachedInternal(Object, Descriptor) |
|
|
|
|
|
||||||||||||||||||||
| postCommit() |
|
|
|
|
|
||||||||||||||||||||
| preventCachingIfReferenceIsNotLoaded(ChangeRecord) |
|
|
|
|
|
||||||||||||||||||||
| putObjectIntoCache(Object, Object, Descriptor) |
|
|
|
|
|
||||||||||||||||||||
| readManagedObject(Class, Object, Descriptor) |
|
|
|
|
|
||||||||||||||||||||
| readObject(Class, Object, Descriptor) |
|
|
|
|
|
||||||||||||||||||||
| readObjectInternal(Class, Object, Descriptor) |
|
|
|
|
|
||||||||||||||||||||
| refreshObject(Object) |
|
|
|
|
|
||||||||||||||||||||
| registerChangeRecord(Object, Object, Descriptor, ChangeRecord) |
|
|
|
|
|
||||||||||||||||||||
| registerClone(Object, Object, Descriptor) |
|
|
|
|
|
||||||||||||||||||||
| registerEntityWithOntologyContext(Object, Descriptor) |
|
|
|
|
|
||||||||||||||||||||
| registerEntityWithPersistenceContext(Object) |
|
|
|
|
|
||||||||||||||||||||
| registerExistingObject(Object, Descriptor) |
|
|
|
|
|
||||||||||||||||||||
| registerExistingObject(Object, Descriptor, List) |
|
|
|
|
|
||||||||||||||||||||
| registerNewObject(Object, Descriptor) |
|
|
|
|
|
||||||||||||||||||||
| registerNewObjectInternal(Object, Descriptor) |
|
|
|
|
|
||||||||||||||||||||
| release() |
|
|
|
|
|
||||||||||||||||||||
| removeIndirectCollections(Object) |
|
|
|
|
|
||||||||||||||||||||
| removeObject(Object) |
|
|
|
|
|
||||||||||||||||||||
| removeObjectFromCache(Object, URI) |
|
|
|
|
|
||||||||||||||||||||
| restoreRemovedObject(Object) |
|
|
|
|
|
||||||||||||||||||||
| revertTransactionalChanges(Object, Descriptor, ObjectChangeSet) |
|
|
|
|
|
||||||||||||||||||||
| rollback() |
|
|
|
|
|
||||||||||||||||||||
| setEntityManager(AbstractEntityManager) |
|
|
|
|
|
||||||||||||||||||||
| setHasChanges() |
|
|
|
|
|
||||||||||||||||||||
| setIndirectObjectIfPresent(Object, Field) |
|
|
|
|
|
||||||||||||||||||||
| setShouldClearAfterCommit(boolean) |
|
|
|
|
|
||||||||||||||||||||
| setUseBackupOntologyForQueryProcessing() |
|
|
|
|
|
||||||||||||||||||||
| setUseTransactionalOntologyForQueryProcessing() |
|
|
|
|
|
||||||||||||||||||||
| shouldReleaseAfterCommit() |
|
|
|
|
|
||||||||||||||||||||
| sparqlQueryFactory() |
|
|
|
|
|
||||||||||||||||||||
| static {...} |
|
|
|
|
|
||||||||||||||||||||
| storageCommit() |
|
|
|
|
|
||||||||||||||||||||
| unregisterEntityFromOntologyContext(Object) |
|
|
|
|
|
||||||||||||||||||||
| unregisterObject(Object) |
|
|
|
|
|
||||||||||||||||||||
| unwrap(Class) |
|
|
|
|
|
||||||||||||||||||||
| useBackupOntologyForQueryProcessing() |
|
|
|
|
|
||||||||||||||||||||
| useTransactionalOntologyForQueryProcessing() |
|
|
|
|
|
||||||||||||||||||||
| validateIntegrityConstraints() |
|
|
|
|
|
||||||||||||||||||||
| verifyCanPersist(Object, Object, EntityType, Descriptor) |
|
|
|
|
|
||||||||||||||||||||
| writeUncommittedChanges() |
|
|
|
|
|
||||||||||||||||||||
Coverage
1: /**
2: * Copyright (C) 2020 Czech Technical University in Prague
3: * <p>
4: * This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public
5: * License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later
6: * version.
7: * <p>
8: * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
9: * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
10: * details. You should have received a copy of the GNU General Public License along with this program. If not, see
11: * <http://www.gnu.org/licenses/>.
12: */
13: package cz.cvut.kbss.jopa.sessions;
14:
15: import cz.cvut.kbss.jopa.adapters.IndirectCollection;
16: import cz.cvut.kbss.jopa.adapters.IndirectWrapper;
17: import cz.cvut.kbss.jopa.exceptions.EntityNotFoundException;
18: import cz.cvut.kbss.jopa.exceptions.OWLEntityExistsException;
19: import cz.cvut.kbss.jopa.exceptions.OWLPersistenceException;
20: import cz.cvut.kbss.jopa.model.AbstractEntityManager;
21: import cz.cvut.kbss.jopa.model.BeanListenerAspect;
22: import cz.cvut.kbss.jopa.model.EntityManagerImpl.State;
23: import cz.cvut.kbss.jopa.model.LoadState;
24: import cz.cvut.kbss.jopa.model.MetamodelImpl;
25: import cz.cvut.kbss.jopa.model.descriptors.Descriptor;
26: import cz.cvut.kbss.jopa.model.lifecycle.PostLoadInvoker;
27: import cz.cvut.kbss.jopa.model.metamodel.EntityType;
28: import cz.cvut.kbss.jopa.model.metamodel.EntityTypeImpl;
29: import cz.cvut.kbss.jopa.model.metamodel.FieldSpecification;
30: import cz.cvut.kbss.jopa.query.NamedQueryManager;
31: import cz.cvut.kbss.jopa.query.ResultSetMappingManager;
32: import cz.cvut.kbss.jopa.query.sparql.SparqlQueryFactory;
33: import cz.cvut.kbss.jopa.sessions.change.ChangeManagerImpl;
34: import cz.cvut.kbss.jopa.sessions.change.ChangeRecordImpl;
35: import cz.cvut.kbss.jopa.sessions.change.ChangeSetFactory;
36: import cz.cvut.kbss.jopa.sessions.descriptor.InstanceDescriptor;
37: import cz.cvut.kbss.jopa.sessions.descriptor.InstanceDescriptorFactory;
38: import cz.cvut.kbss.jopa.sessions.validator.AttributeModificationValidator;
39: import cz.cvut.kbss.jopa.sessions.validator.IntegrityConstraintsValidator;
40: import cz.cvut.kbss.jopa.utils.EntityPropertiesUtils;
41: import cz.cvut.kbss.jopa.utils.ErrorUtils;
42: import cz.cvut.kbss.jopa.utils.Wrapper;
43: import org.aspectj.lang.Aspects;
44:
45: import java.lang.reflect.Field;
46: import java.net.URI;
47: import java.util.*;
48: import java.util.Map.Entry;
49: import java.util.function.Consumer;
50:
51: import static cz.cvut.kbss.jopa.exceptions.OWLEntityExistsException.individualAlreadyManaged;
52: import static cz.cvut.kbss.jopa.utils.EntityPropertiesUtils.getValueAsURI;
53:
54: public class UnitOfWorkImpl extends AbstractSession implements UnitOfWork, ConfigurationHolder, Wrapper {
55:
56: // Read-only!!! It is just the keyset of cloneToOriginals
57: private final Set<Object> cloneMapping;
58: private final Map<Object, Object> cloneToOriginals;
59: private final Map<Object, Object> keysToClones = new HashMap<>();
60: private final Map<Object, Object> deletedObjects;
61: private final Map<Object, Object> newObjectsCloneToOriginal;
62: private final Map<Object, Object> newObjectsKeyToClone = new HashMap<>();
63: private final Map<Object, InstanceDescriptor> instanceDescriptors;
64: private RepositoryMap repoMap;
65:
66: private boolean hasChanges;
67: private boolean hasNew;
68: private boolean hasDeleted;
69: private boolean shouldReleaseAfterCommit;
70: private boolean shouldClearCacheAfterCommit;
71: private boolean useTransactionalOntology;
72:
73: private boolean isActive;
74: private boolean inCommit;
75:
76: private UnitOfWorkChangeSet uowChangeSet = ChangeSetFactory.createUoWChangeSet();
77:
78: private final AbstractSession parent;
79: private AbstractEntityManager entityManager;
80: private final ConnectionWrapper storage;
81:
82: private final MergeManager mergeManager;
83: private final CloneBuilder cloneBuilder;
84: private final ChangeManager changeManager;
85: private final SparqlQueryFactory queryFactory;
86: private final IndirectWrapperHelper indirectWrapperHelper;
87: /**
88: * This is a shortcut for the second level cache.
89: */
90: private final CacheManager cacheManager;
91:
92: public UnitOfWorkImpl(AbstractSession parent) {
93: super(parent.getConfiguration());
94: this.parent = Objects.requireNonNull(parent);
95: this.cloneToOriginals = createMap();
96: this.cloneMapping = cloneToOriginals.keySet();
97: this.deletedObjects = createMap();
98: this.newObjectsCloneToOriginal = createMap();
99: this.instanceDescriptors = new IdentityHashMap<>();
100: this.repoMap = new RepositoryMap();
101: repoMap.initDescriptors();
102: this.cloneBuilder = new CloneBuilderImpl(this);
103: this.indirectWrapperHelper = new IndirectWrapperHelper(this);
104: this.cacheManager = parent.getLiveObjectCache();
105: this.storage = acquireConnection();
106: this.queryFactory = new SparqlQueryFactory(this, storage);
107: this.mergeManager = new MergeManagerImpl(this);
108: this.changeManager = new ChangeManagerImpl(this);
109: this.useTransactionalOntology = true;
110: this.isActive = true;
111: }
112:
113: CloneBuilder getCloneBuilder() {
114: return cloneBuilder;
115: }
116:
117: /**
118: * This method returns null, since we don't support nested Units of Work yet.
119: */
120: @Override
121: public UnitOfWork acquireUnitOfWork() {
122: return null;
123: }
124:
125: @Override
126: protected ConnectionWrapper acquireConnection() {
127: final ConnectionWrapper conn = parent.acquireConnection();
128: conn.setUnitOfWork(this);
129: return conn;
130: }
131:
132: @Override
133: public <T> T readObject(Class<T> cls, Object identifier, Descriptor descriptor) {
134: Objects.requireNonNull(cls, ErrorUtils.getNPXMessageSupplier("cls"));
135: Objects.requireNonNull(identifier, ErrorUtils.getNPXMessageSupplier("primaryKey"));
136: Objects.requireNonNull(descriptor, ErrorUtils.getNPXMessageSupplier("descriptor"));
137:
138: return readObjectInternal(cls, identifier, descriptor);
139: }
140:
141: private <T> T readObjectInternal(Class<T> cls, Object identifier, Descriptor descriptor) {
142:• assert cls != null;
143:• assert identifier != null;
144:• assert descriptor != null;
145: T result = readManagedObject(cls, identifier, descriptor);
146:• if (result != null) {
147: return result;
148: }
149: result = storage.find(new LoadingParameters<>(cls, getValueAsURI(identifier), descriptor));
150:
151:• if (result == null) {
152: return null;
153: }
154: final Object clone = registerExistingObject(result, descriptor,
155: Collections.singletonList(new PostLoadInvoker(getMetamodel())));
156: checkForIndirectObjects(clone);
157: return cls.cast(clone);
158: }
159:
160: private <T> T readManagedObject(Class<T> cls, Object identifier, Descriptor descriptor) {
161: // First try to find the object among new uncommitted objects
162: Object result = newObjectsKeyToClone.get(identifier);
163:• if (result != null && (isInRepository(descriptor, result))) {
164: // The result can be returned, since it is already registered in this UOW
165: return cls.cast(result);
166: }
167: // Object is already managed
168: return getManagedClone(cls, identifier, descriptor);
169: }
170:
171: private <T> T getManagedClone(Class<T> cls, Object identifier, Descriptor descriptor) {
172:• if (!keysToClones.containsKey(identifier)) {
173: return null;
174: }
175: final Object clone = keysToClones.get(identifier);
176:• if (!cls.isAssignableFrom(clone.getClass())) {
177: throw individualAlreadyManaged(identifier);
178: }
179:• return isInRepository(descriptor, clone) && !deletedObjects.containsKey(clone) ? cls.cast(clone) : null;
180: }
181:
182: @Override
183: public <T> T getReference(Class<T> cls, Object identifier, Descriptor descriptor) {
184: Objects.requireNonNull(cls);
185: Objects.requireNonNull(identifier);
186: Objects.requireNonNull(descriptor);
187:
188: final T managedResult = readManagedObject(cls, identifier, descriptor);
189:• if (managedResult != null) {
190: return managedResult;
191: }
192: final T result = storage.getReference(new LoadingParameters<>(cls, getValueAsURI(identifier), descriptor));
193:• if (result == null) {
194: return null;
195: }
196: instanceDescriptors.put(result, InstanceDescriptorFactory.createNotLoaded(result, entityType(cls)));
197: registerEntityWithPersistenceContext(result);
198: registerEntityWithOntologyContext(result, descriptor);
199:• if (getLiveObjectCache().contains(cls, identifier, descriptor)) {
200: cloneToOriginals.put(result, getLiveObjectCache().get(cls, identifier, descriptor));
201: } else {
202: cloneToOriginals.put(result, null);
203: }
204: keysToClones.put(identifier, result);
205: return result;
206: }
207:
208: /**
209: * This method calculates the changes that were to the registered entities and adds these changes into the given
210: * change set for future commit to the ontology.
211: */
212: private void calculateChanges() {
213:• if (hasNew) {
214: calculateNewObjects(uowChangeSet);
215: }
216:• if (hasDeleted) {
217: calculateDeletedObjects(uowChangeSet);
218: }
219: }
220:
221: /**
222: * Create object change sets for the new objects and adds them into our UnitOfWorkChangeSet.
223: *
224: * @param changeSet UnitOfWorkChangeSet
225: */
226: private void calculateNewObjects(UnitOfWorkChangeSet changeSet) {
227:• for (Object clone : newObjectsCloneToOriginal.keySet()) {
228: final Descriptor c = getDescriptor(clone);
229: Object original = newObjectsCloneToOriginal
230: .computeIfAbsent(clone, key -> cloneBuilder.buildClone(key, new CloneConfiguration(c)));
231:• if (original == null) {
232: throw new OWLPersistenceException(
233: "Error while calculating changes for new objects. Original not found.");
234: }
235: newObjectsCloneToOriginal.put(clone, original);
236: changeSet.addNewObjectChangeSet(ChangeSetFactory.createObjectChangeSet(original, clone,
237: c));
238: }
239: }
240:
241: private void calculateDeletedObjects(final UnitOfWorkChangeSet changeSet) {
242:• for (Object clone : deletedObjects.keySet()) {
243: Descriptor descriptor = getDescriptor(clone);
244: changeSet.addDeletedObjectChangeSet(ChangeSetFactory.createDeleteObjectChangeSet(clone, descriptor));
245: changeSet.cancelObjectChanges(getOriginal(clone));
246: }
247: }
248:
249: @Override
250: public void clear() {
251: detachAllManagedInstances();
252: cloneToOriginals.clear();
253: keysToClones.clear();
254: deletedObjects.clear();
255: newObjectsCloneToOriginal.clear();
256: newObjectsKeyToClone.clear();
257: instanceDescriptors.clear();
258: this.hasChanges = false;
259: this.hasDeleted = false;
260: this.hasNew = false;
261: cloneBuilder.reset();
262: this.repoMap = new RepositoryMap();
263: repoMap.initDescriptors();
264: this.uowChangeSet = ChangeSetFactory.createUoWChangeSet();
265: }
266:
267: private void detachAllManagedInstances() {
268: cloneMapping.forEach(instance -> {
269: removeIndirectCollections(instance);
270: deregisterEntityFromPersistenceContext(instance);
271: });
272: newObjectsCloneToOriginal.keySet().forEach(instance -> {
273: removeIndirectCollections(instance);
274: deregisterEntityFromPersistenceContext(instance);
275: });
276: }
277:
278: @Override
279: public boolean contains(Object entity) {
280: Objects.requireNonNull(entity);
281: return isObjectManaged(entity);
282: }
283:
284: @Override
285: public void commit() {
286: LOG.trace("UnitOfWork commit started.");
287:• if (!isActive()) {
288: throw new IllegalStateException("Cannot commit inactive Unit of Work!");
289: }
290: this.inCommit = true;
291: commitUnitOfWork();
292: LOG.trace("UnitOfWork commit finished.");
293: }
294:
295: @Override
296: public void rollback() {
297: LOG.trace("UnitOfWork rollback started.");
298:• if (!isActive()) {
299: throw new IllegalStateException("Cannot rollback inactive Unit of Work!");
300: }
301: storage.rollback();
302: clear();
303: }
304:
305: /**
306: * Commit this Unit of Work.
307: */
308: private void commitUnitOfWork() {
309: commitToOntology();
310: mergeChangesIntoParent();
311: postCommit();
312: }
313:
314: /**
315: * Clean up after the commit.
316: */
317: private void postCommit() {
318: final boolean changes = hasChanges();
319: clear();
320: this.inCommit = false;
321:• if (changes) {
322:• if (shouldClearCacheAfterCommit) {
323: cacheManager.evictAll();
324: this.shouldReleaseAfterCommit = true;
325: } else {
326: cacheManager.evictInferredObjects();
327: }
328: }
329:
330: }
331:
332: /**
333: * If there are any changes, commit them to the ontology.
334: */
335: private void commitToOntology() {
336:• if (this.hasNew || this.hasChanges || this.hasDeleted) {
337: calculateChanges();
338: }
339: validateIntegrityConstraints();
340: storageCommit();
341: }
342:
343: private void validateIntegrityConstraints() {
344: final IntegrityConstraintsValidator validator = IntegrityConstraintsValidator.getValidator();
345:• for (ObjectChangeSet changeSet : uowChangeSet.getNewObjects()) {
346: validator.validate(changeSet.getCloneObject(),
347: entityType((Class<Object>) changeSet.getObjectClass()), false);
348: }
349: uowChangeSet.getExistingObjectsChanges().forEach(changeSet -> validator.validate(changeSet, getMetamodel()));
350: }
351:
352: private static Map<Object, Object> createMap() {
353: return new IdentityHashMap<>();
354: }
355:
356: /**
357: * Gets current state of the specified entity.
358: * <p>
359: * Note that since no repository is specified we can only determine if the entity is managed or removed. Therefore
360: * if the case is different this method returns State#NOT_MANAGED.
361: *
362: * @param entity The entity to check
363: * @return State of the entity
364: */
365: public State getState(Object entity) {
366: Objects.requireNonNull(entity);
367:
368:• if (deletedObjects.containsKey(entity)) {
369: return State.REMOVED;
370:• } else if (newObjectsCloneToOriginal.containsKey(entity)) {
371: return State.MANAGED_NEW;
372:• } else if (cloneMapping.contains(entity)) {
373: return State.MANAGED;
374: } else {
375: return State.NOT_MANAGED;
376: }
377: }
378:
379: /**
380: * Checks the state of the specified entity with regards to the specified repository.
381: *
382: * @param entity Object
383: * @param descriptor Entity descriptor
384: * @return The state of the specified entity
385: */
386: public State getState(Object entity, Descriptor descriptor) {
387: Objects.requireNonNull(entity, ErrorUtils.getNPXMessageSupplier("entity"));
388: Objects.requireNonNull(descriptor, ErrorUtils.getNPXMessageSupplier("descriptor"));
389:
390:• if (deletedObjects.containsKey(entity)) {
391: return State.REMOVED;
392:• } else if (newObjectsCloneToOriginal.containsKey(entity) && isInRepository(descriptor, entity)) {
393: return State.MANAGED_NEW;
394:• } else if (cloneMapping.contains(entity) && isInRepository(descriptor, entity)) {
395: return State.MANAGED;
396: } else {
397: return State.NOT_MANAGED;
398: }
399: }
400:
401: /**
402: * Tries to find the original object for the given clone. It searches the existing objects, new objects and deleted
403: * objects.
404: *
405: * @param clone Object
406: * @return The original object for the given clone
407: */
408: public Object getOriginal(Object clone) {
409:• if (clone == null) {
410: return null;
411: }
412:• return cloneToOriginals.containsKey(clone) ? cloneToOriginals.get(clone) : newObjectsCloneToOriginal.get(clone);
413: }
414:
415: /**
416: * Gets managed original with the specified identifier or {@code null} if there is none matching.
417: * <p>
418: * Descriptor is used to check repository context validity.
419: *
420: * @param cls Return type of the original
421: * @param identifier Instance identifier
422: * @param descriptor Repository descriptor
423: * @return Original object managed by this UoW or {@code null} if this UoW doesn't contain a matching instance
424: */
425: public <T> T getManagedOriginal(Class<T> cls, Object identifier, Descriptor descriptor) {
426: final T clone = getManagedClone(cls, identifier, descriptor);
427:• return clone != null ? cls.cast(cloneToOriginals.get(clone)) : null;
428: }
429:
430: /**
431: * Check if this UnitOfWork contains this original entity. This method is used by the CloneBuilder so it does not
432: * have to clone already managed referenced objects.
433: *
434: * @param entity The original entity.
435: * @return True if the original is managed in this UnitOfWork.
436: */
437: boolean containsOriginal(Object entity) {
438:• return entity != null && cloneToOriginals.containsValue(entity);
439: }
440:
441: /**
442: * Finds clone of the specified original.
443: *
444: * @param original The original object whose clone we are looking for
445: * @return The clone or null, if there is none
446: */
447: public Object getCloneForOriginal(Object original) {
448:• for (Entry<Object, Object> entry : cloneToOriginals.entrySet()) {
449: // We use IdentityMap, so we can use ==
450:• if (entry.getValue() == original) {
451: return entry.getKey();
452: }
453: }
454: return null;
455: }
456:
457: public boolean hasChanges() {
458:• return hasChanges || hasDeleted || hasNew;
459: }
460:
461: void setHasChanges() {
462: this.hasChanges = true;
463: }
464:
465: @Override
466: public CacheManager getLiveObjectCache() {
467: return parent.getLiveObjectCache();
468: }
469:
470: UnitOfWorkChangeSet getUowChangeSet() {
471: return uowChangeSet;
472: }
473:
474: @Override
475: public boolean isActive() {
476: return this.isActive;
477: }
478:
479: /**
480: * Returns true if the given clone represents a newly created object. Otherwise returns false.
481: *
482: * @param clone Object
483: * @return boolean
484: */
485: public boolean isObjectNew(Object clone) {
486:• return clone != null && newObjectsCloneToOriginal.containsKey(clone);
487: }
488:
489: /**
490: * Returns true if the given object is already managed.
491: *
492: * @param entity Object
493: * @return boolean
494: */
495: @Override
496: public boolean isObjectManaged(Object entity) {
497: Objects.requireNonNull(entity);
498:
499:• return cloneMapping.contains(entity) && !deletedObjects.containsKey(entity) ||
500:• newObjectsCloneToOriginal.containsKey(entity);
501: }
502:
503: /**
504: * Persists changed value of the specified field.
505: *
506: * @param entity Entity with changes (the clone)
507: * @param f The field whose value has changed
508: * @throws IllegalStateException If this UoW is not in transaction
509: */
510: public void attributeChanged(Object entity, Field f) {
511:• if (!isInTransaction()) {
512: throw new IllegalStateException("This unit of work is not in a transaction.");
513: }
514: final Descriptor descriptor = getDescriptor(entity);
515: final EntityTypeImpl<Object> et = entityType((Class<Object>) entity.getClass());
516: et.getLifecycleListenerManager().invokePreUpdateCallbacks(entity);
517: storage.merge(entity, f, descriptor);
518: createAndRegisterChangeRecord(entity, et.getFieldSpecification(f.getName()), descriptor);
519: setHasChanges();
520: setIndirectObjectIfPresent(entity, f);
521: et.getLifecycleListenerManager().invokePostUpdateCallbacks(entity);
522: instanceDescriptors.get(entity).setLoaded(et.getFieldSpecification(f.getName()), LoadState.LOADED);
523: }
524:
525: private void createAndRegisterChangeRecord(Object clone, FieldSpecification<?, ?> fieldSpec,
526: Descriptor descriptor) {
527: final Object orig = getOriginal(clone);
528:• if (orig == null) {
529: return;
530: }
531: final ChangeRecord record = new ChangeRecordImpl(fieldSpec,
532: EntityPropertiesUtils.getFieldValue(fieldSpec.getJavaField(), clone));
533: preventCachingIfReferenceIsNotLoaded(record);
534: registerChangeRecord(clone, orig, descriptor, record);
535: }
536:
537: private void preventCachingIfReferenceIsNotLoaded(ChangeRecord changeRecord) {
538: final Object newValue = changeRecord.getNewValue();
539:• if (newValue != null && contains(newValue) && isLoaded(newValue) != LoadState.LOADED) {
540: changeRecord.preventCaching();
541: }
542: }
543:
544: private void registerChangeRecord(Object clone, Object orig, Descriptor descriptor, ChangeRecord record) {
545: ObjectChangeSet chSet = uowChangeSet.getExistingObjectChanges(orig);
546:• if (chSet == null) {
547: chSet = ChangeSetFactory.createObjectChangeSet(orig, clone, descriptor);
548: uowChangeSet.addObjectChangeSet(chSet);
549: }
550: chSet.addChangeRecord(record);
551: }
552:
553: /**
554: * Merge the changes from this Unit of Work's change set into the server session.
555: */
556: private void mergeChangesIntoParent() {
557:• if (hasChanges()) {
558: mergeManager.mergeChangesFromChangeSet(uowChangeSet);
559: }
560: evictPossiblyUpdatedReferencesFromCache();
561: }
562:
563: private void evictPossiblyUpdatedReferencesFromCache() {
564: cloneToOriginals.forEach((clone, orig) -> {
565:• if (orig == null && !deletedObjects.containsKey(clone)) {
566: removeObjectFromCache(clone, getDescriptor(clone).getContext());
567: }
568: });
569: }
570:
571: @Override
572: public <T> T mergeDetached(T entity, Descriptor descriptor) {
573: Objects.requireNonNull(entity, ErrorUtils.getNPXMessageSupplier("entity"));
574: Objects.requireNonNull(descriptor, ErrorUtils.getNPXMessageSupplier("descriptor"));
575:
576: final Object id = getIdentifier(entity);
577:• if (!storage.contains(id, entity.getClass(), descriptor)) {
578: registerNewObject(entity, descriptor);
579: return entity;
580: } else {
581:• if (isIndividualManaged(id, entity) && !isSameType(id, entity)) {
582: throw individualAlreadyManaged(id);
583: }
584: return mergeDetachedInternal(entity, descriptor);
585: }
586: }
587:
588: private boolean isSameType(Object id, Object entity) {
589: final Class<?> mergedType = entity.getClass();
590:• final Object managed = keysToClones.containsKey(id) ? keysToClones.get(id) : newObjectsKeyToClone.get(id);
591:• return managed != null && managed.getClass().isAssignableFrom(mergedType);
592: }
593:
594: private <T> T mergeDetachedInternal(T entity, Descriptor descriptor) {
595:• assert entity != null;
596: final EntityTypeImpl<T> et = (EntityTypeImpl<T>) entityType(entity.getClass());
597: final URI idUri = EntityPropertiesUtils.getIdentifier(entity, et);
598:
599: final Object clone = getInstanceForMerge(idUri, et, descriptor);
600: try {
601: // Merge only the changed attributes
602: final ObjectChangeSet chSet = ChangeSetFactory.createObjectChangeSet(clone, entity, descriptor);
603: changeManager.calculateChanges(chSet);
604:• if (chSet.hasChanges()) {
605: et.getLifecycleListenerManager().invokePreUpdateCallbacks(clone);
606: final DetachedInstanceMerger merger = new DetachedInstanceMerger(this);
607: merger.mergeChangesFromDetachedToManagedInstance(chSet, descriptor);
608:• for (ChangeRecord record : chSet.getChanges()) {
609: AttributeModificationValidator.verifyCanModify(record.getAttribute());
610: preventCachingIfReferenceIsNotLoaded(record);
611: final Field field = record.getAttribute().getJavaField();
612: storage.merge(clone, field, descriptor);
613: }
614: et.getLifecycleListenerManager().invokePostUpdateCallbacks(clone);
615: uowChangeSet.addObjectChangeSet(copyChangeSet(chSet, getOriginal(clone), clone, descriptor));
616: }
617: } catch (OWLEntityExistsException e) {
618: unregisterObject(clone);
619: throw e;
620: }
621:• if (cacheManager.contains(et.getJavaType(), idUri, descriptor)) {
622: cacheManager.evict(et.getJavaType(), idUri, descriptor.getContext());
623: }
624: setHasChanges();
625: checkForIndirectObjects(clone);
626: return et.getJavaType().cast(clone);
627: }
628:
629: private <T> Object getInstanceForMerge(URI identifier, EntityType<T> et, Descriptor descriptor) {
630:• if (keysToClones.containsKey(identifier)) {
631: return keysToClones.get(identifier);
632: }
633: final LoadingParameters<T> params = new LoadingParameters<>(et.getJavaType(), identifier, descriptor, true);
634: T original = storage.find(params);
635:• assert original != null;
636:
637: return registerExistingObject(original, descriptor);
638: }
639:
640: private static ObjectChangeSet copyChangeSet(ObjectChangeSet changeSet, Object original, Object clone,
641: Descriptor descriptor) {
642: final ObjectChangeSet newChangeSet = ChangeSetFactory.createObjectChangeSet(original, clone, descriptor);
643: changeSet.getChanges().forEach(newChangeSet::addChangeRecord);
644: return newChangeSet;
645: }
646:
647: private void registerEntityWithPersistenceContext(Object entity) {
648: Aspects.aspectOf(BeanListenerAspect.class).register(entity, this);
649: }
650:
651: private void deregisterEntityFromPersistenceContext(Object entity) {
652: Aspects.aspectOf(BeanListenerAspect.class).deregister(entity);
653: }
654:
655: @Override
656: public NamedQueryManager getNamedQueryManager() {
657: return parent.getNamedQueryManager();
658: }
659:
660: @Override
661: public ResultSetMappingManager getResultSetMappingManager() {
662: return parent.getResultSetMappingManager();
663: }
664:
665: @Override
666: public Object registerExistingObject(Object entity, Descriptor descriptor) {
667: return registerExistingObject(entity, descriptor, Collections.emptyList());
668: }
669:
670: @Override
671: public Object registerExistingObject(Object entity, Descriptor descriptor, List<Consumer<Object>> postClone) {
672:• if (entity == null) {
673: return null;
674: }
675:• if (cloneToOriginals.containsValue(entity)) {
676: return getCloneForOriginal(entity);
677: }
678: final CloneConfiguration cloneConfig = new CloneConfiguration(descriptor);
679: postClone.forEach(cloneConfig::addPostRegisterHandler);
680: Object clone = cloneBuilder.buildClone(entity, cloneConfig);
681:• assert clone != null;
682: registerClone(clone, entity, descriptor);
683: postClone.forEach(c -> c.accept(clone));
684: return clone;
685: }
686:
687: private void registerClone(Object clone, Object original, Descriptor descriptor) {
688: cloneToOriginals.put(clone, original);
689: final Object identifier = EntityPropertiesUtils.getIdentifier(clone, getMetamodel());
690: keysToClones.put(identifier, clone);
691: instanceDescriptors
692: .put(clone, InstanceDescriptorFactory.create(clone, (EntityType<Object>) entityType(clone.getClass())));
693: registerEntityWithPersistenceContext(clone);
694: registerEntityWithOntologyContext(clone, descriptor);
695: }
696:
697: /**
698: * Release this Unit of Work. Releasing an active Unit of Work with uncommitted changes causes all pending changes
699: * to be discarded.
700: */
701: @Override
702: public void release() {
703: clear();
704: storage.close();
705: this.isActive = false;
706: LOG.debug("UnitOfWork released.");
707: }
708:
709: @Override
710: public <T> void refreshObject(T object) {
711: Objects.requireNonNull(object);
712:• if (!isObjectManaged(object)) {
713: throw new IllegalArgumentException(
714: "Cannot call refresh on an instance not managed by this persistence context.");
715: }
716: final EntityTypeImpl<T> et = entityType((Class<T>) object.getClass());
717: final URI idUri = EntityPropertiesUtils.getIdentifier(object, et);
718: final Descriptor descriptor = getDescriptor(object);
719:
720: final LoadingParameters<T> params = new LoadingParameters<>(et.getJavaType(), idUri, descriptor, true);
721: params.bypassCache();
722: final ConnectionWrapper connection = acquireConnection();
723: try {
724: uowChangeSet.cancelObjectChanges(getOriginal(object));
725: T original = connection.find(params);
726:• if (original == null) {
727: throw new EntityNotFoundException("Entity " + object + " no longer exists in the repository.");
728: }
729: T source = (T) cloneBuilder.buildClone(original, new CloneConfiguration(descriptor));
730: final ObjectChangeSet chSet = ChangeSetFactory.createObjectChangeSet(source, object, descriptor);
731: changeManager.calculateChanges(chSet);
732: new RefreshInstanceMerger(indirectWrapperHelper).mergeChanges(chSet);
733: revertTransactionalChanges(object, descriptor, chSet);
734: registerClone(object, original, descriptor);
735: et.getLifecycleListenerManager().invokePostLoadCallbacks(object);
736: } finally {
737: connection.close();
738: }
739: }
740:
741: private <T> void revertTransactionalChanges(T object, Descriptor descriptor, ObjectChangeSet chSet) {
742:• for (ChangeRecord change : chSet.getChanges()) {
743: storage.merge(object, change.getAttribute().getJavaField(),
744: descriptor.getAttributeDescriptor(change.getAttribute()));
745: }
746: }
747:
748: @Override
749: public void registerNewObject(Object entity, Descriptor descriptor) {
750: Objects.requireNonNull(entity, ErrorUtils.getNPXMessageSupplier("entity"));
751: Objects.requireNonNull(descriptor, ErrorUtils.getNPXMessageSupplier("descriptor"));
752:
753: registerNewObjectInternal(entity, descriptor);
754: }
755:
756: /**
757: * Registers the specified entity for persist in this Unit of Work.
758: *
759: * @param entity The entity to register
760: * @param descriptor Entity descriptor, specifying optionally contexts into which the entity will be persisted
761: */
762: private void registerNewObjectInternal(Object entity, Descriptor descriptor) {
763: final EntityTypeImpl<?> eType = entityType(entity.getClass());
764: eType.getLifecycleListenerManager().invokePrePersistCallbacks(entity);
765: Object id = getIdentifier(entity);
766:• if (id == null) {
767: EntityPropertiesUtils.verifyIdentifierIsGenerated(entity, eType);
768: }
769: verifyCanPersist(id, entity, eType, descriptor);
770: storage.persist(id, entity, descriptor);
771:• if (id == null) {
772: // If the ID was null, extract it from the entity. It is present now
773: id = getIdentifier(entity);
774: }
775:• assert id != null;
776: // Original is null until commit
777: newObjectsCloneToOriginal.put(entity, null);
778: registerEntityWithPersistenceContext(entity);
779: registerEntityWithOntologyContext(entity, descriptor);
780: instanceDescriptors.put(entity, InstanceDescriptorFactory.createAllLoaded(entity, (EntityType<Object>) eType));
781: newObjectsKeyToClone.put(id, entity);
782: checkForIndirectObjects(entity);
783: this.hasNew = true;
784: eType.getLifecycleListenerManager().invokePostPersistCallbacks(entity);
785: }
786:
787: private void verifyCanPersist(Object id, Object instance, EntityType<?> et, Descriptor descriptor) {
788:• if (isIndividualManaged(id, instance) && !instance.getClass().isEnum()) {
789: throw individualAlreadyManaged(id);
790: }
791:• if (storage.contains(id, instance.getClass(), descriptor)) {
792: throw new OWLEntityExistsException(
793: "Individual " + id + " of type " + et.getIRI() + " already exists in storage.");
794: }
795: }
796:
797: private boolean isIndividualManaged(Object identifier, Object entity) {
798:• return keysToClones.containsKey(identifier) ||
799:• newObjectsKeyToClone.containsKey(identifier) && !cloneMapping.contains(entity);
800: }
801:
802: @Override
803: public void removeObject(Object entity) {
804:• assert entity != null;
805:• if (!isObjectManaged(entity)) {
806: throw new IllegalArgumentException(
807: "Cannot remove entity which is not managed in the current persistence context.");
808: }
809: final EntityTypeImpl<?> et = entityType(entity.getClass());
810: et.getLifecycleListenerManager().invokePreRemoveCallbacks(entity);
811: final Object primaryKey = getIdentifier(entity);
812: final Descriptor descriptor = getDescriptor(entity);
813:
814:• if (hasNew && newObjectsCloneToOriginal.containsKey(entity)) {
815: unregisterObject(entity);
816: newObjectsKeyToClone.remove(primaryKey);
817: } else {
818: deletedObjects.put(entity, entity);
819: this.hasDeleted = true;
820: }
821: storage.remove(primaryKey, et.getJavaType(), descriptor);
822: et.getLifecycleListenerManager().invokePostRemoveCallbacks(entity);
823: }
824:
825: @Override
826: public void restoreRemovedObject(Object entity) {
827:• assert deletedObjects.containsKey(entity);
828:
829: deletedObjects.remove(entity);
830: final Object id = getIdentifier(entity);
831: storage.persist(id, entity, getDescriptor(entity));
832: }
833:
834: /**
835: * Remove the registered object from this Unit of Work.
836: *
837: * @param object Clone of the original object
838: */
839: public void unregisterObject(Object object) {
840:• if (object == null) {
841: return;
842: }
843: final Object original = cloneToOriginals.remove(object);
844: keysToClones.remove(EntityPropertiesUtils.getIdentifier(object, getMetamodel()));
845:
846: deletedObjects.remove(object);
847:• if (hasNew) {
848: newObjectsCloneToOriginal.remove(object);
849: }
850:• if (original != null) {
851: cloneBuilder.removeVisited(original, repoMap.getEntityDescriptor(object));
852: }
853: removeIndirectCollections(object);
854: deregisterEntityFromPersistenceContext(object);
855: unregisterEntityFromOntologyContext(object);
856: }
857:
858: @Override
859: public boolean shouldReleaseAfterCommit() {
860: return shouldReleaseAfterCommit;
861: }
862:
863: public void setShouldClearAfterCommit(boolean shouldClearCache) {
864: this.shouldClearCacheAfterCommit = shouldClearCache;
865: }
866:
867: public void setEntityManager(AbstractEntityManager entityManager) {
868: this.entityManager = entityManager;
869: }
870:
871: @Override
872: public void writeUncommittedChanges() {
873:• if (hasChanges()) {
874: commitUnitOfWork();
875: }
876: }
877:
878: @Override
879: public MetamodelImpl getMetamodel() {
880: return parent.getMetamodel();
881: }
882:
883: private <T> EntityTypeImpl<T> entityType(Class<T> cls) {
884: return getMetamodel().entity(cls);
885: }
886:
887: @Override
888: public boolean isEntityType(Class<?> cls) {
889: return parent.isEntityType(cls);
890: }
891:
892: @Override
893: public boolean isInTransaction() {
894:• return entityManager != null && entityManager.getTransaction().isActive();
895: }
896:
897: /**
898: * Returns {@code true} if this UoW is currently committing changes.
899: *
900: * @return Whether this UoW is in the commit phase
901: */
902: public boolean isInCommit() {
903: return inCommit;
904: }
905:
906: @Override
907: public <T> void loadEntityField(T entity, Field field) {
908: Objects.requireNonNull(entity, ErrorUtils.getNPXMessageSupplier("entity"));
909: Objects.requireNonNull(field, ErrorUtils.getNPXMessageSupplier("field"));
910:• assert field.getDeclaringClass().isAssignableFrom(entity.getClass());
911:
912: final Descriptor entityDescriptor = getDescriptor(entity);
913:• if (!instanceDescriptors.containsKey(entity)) {
914: throw new OWLPersistenceException(
915: "Unable to find repository identifier for entity " + entity + ". Is it managed by this UoW?");
916: }
917: final InstanceDescriptor<?> instanceDescriptor = instanceDescriptors.get(entity);
918: final FieldSpecification<?, ?> fieldSpec = entityType((Class<Object>) entity.getClass())
919: .getFieldSpecification(field.getName());
920:• if (instanceDescriptor.isLoaded(fieldSpec) == LoadState.LOADED) {
921: return;
922: }
923:
924: storage.loadFieldValue(entity, field, entityDescriptor);
925: final Object orig = EntityPropertiesUtils.getFieldValue(field, entity);
926: final Object entityOriginal = getOriginal(entity);
927:• if (entityOriginal != null) {
928: EntityPropertiesUtils.setFieldValue(field, entityOriginal, orig);
929: }
930: final Descriptor fieldDescriptor = getFieldDescriptor(entity, field, entityDescriptor);
931: final Object clone = cloneLoadedFieldValue(entity, field, fieldDescriptor, orig);
932: EntityPropertiesUtils.setFieldValue(field, entity, clone);
933: instanceDescriptors.get(entity).setLoaded(fieldSpec, LoadState.LOADED);
934: }
935:
936: private <T> Descriptor getFieldDescriptor(T entity, Field field, Descriptor entityDescriptor) {
937: final EntityType<?> et = entityType(entity.getClass());
938: final FieldSpecification<?, ?> fieldSpec = et.getFieldSpecification(field.getName());
939: return entityDescriptor.getAttributeDescriptor(fieldSpec);
940: }
941:
942: private <T> Object cloneLoadedFieldValue(T entity, Field field, final Descriptor fieldDescriptor,
943: final Object fieldValueOrig) {
944: Object clone;
945:• if (fieldValueOrig == null) {
946: clone = null;
947: } else {
948:• if (isEntityType(field.getType())) {
949: clone = registerExistingObject(fieldValueOrig, fieldDescriptor);
950: putObjectIntoCache(getIdentifier(clone), fieldValueOrig, fieldDescriptor);
951: } else {
952: clone = cloneBuilder.buildClone(entity, field, fieldValueOrig, fieldDescriptor);
953: }
954: }
955: return clone;
956: }
957:
958: @Override
959: public void removeObjectFromCache(Object toRemove, URI context) {
960: Objects.requireNonNull(toRemove, ErrorUtils.getNPXMessageSupplier("toRemove"));
961:
962: cacheManager.evict(toRemove.getClass(), getIdentifier(toRemove), context);
963: }
964:
965: @Override
966: public boolean isConsistent(URI context) {
967: return storage.isConsistent(context);
968: }
969:
970: @Override
971: public List<URI> getContexts() {
972: return storage.getContexts();
973: }
974:
975: @Override
976: public LoadState isLoaded(Object entity, String attributeName) {
977: Objects.requireNonNull(entity);
978: final FieldSpecification<?, ?> fs = entityType(entity.getClass()).getFieldSpecification(attributeName);
979:• return instanceDescriptors.containsKey(entity) ? instanceDescriptors.get(entity).isLoaded(fs) :
980: LoadState.UNKNOWN;
981: }
982:
983: @Override
984: public LoadState isLoaded(Object entity) {
985: Objects.requireNonNull(entity);
986:• return instanceDescriptors.containsKey(entity) ? instanceDescriptors.get(entity).isLoaded() : LoadState.UNKNOWN;
987: }
988:
989: @Override
990: public void setUseTransactionalOntologyForQueryProcessing() {
991: this.useTransactionalOntology = true;
992: }
993:
994: @Override
995: public boolean useTransactionalOntologyForQueryProcessing() {
996: return useTransactionalOntology;
997: }
998:
999: @Override
1000: public void setUseBackupOntologyForQueryProcessing() {
1001: this.useTransactionalOntology = false;
1002: }
1003:
1004: @Override
1005: public boolean useBackupOntologyForQueryProcessing() {
1006:• return !useTransactionalOntology;
1007: }
1008:
1009: public SparqlQueryFactory sparqlQueryFactory() {
1010: return queryFactory;
1011: }
1012:
1013: /**
1014: * Check if the specified entity contains a collection. If so, replace it with its indirect representation so that
1015: * changes in that collection can be tracked.
1016: *
1017: * @param entity The entity to check
1018: */
1019: private void checkForIndirectObjects(Object entity) {
1020:• assert entity != null;
1021: final EntityType<?> et = entityType(entity.getClass());
1022:• for (FieldSpecification<?, ?> fieldSpec : et.getFieldSpecifications()) {
1023: setIndirectObjectIfPresent(entity, fieldSpec.getJavaField());
1024: }
1025: }
1026:
1027: /**
1028: * Create and set indirect collection on the specified entity field.
1029: * <p>
1030: * If the specified field is of Collection type and it is not already an indirect collection, create new one and set
1031: * it as the value of the specified field on the specified entity.
1032: *
1033: * @param entity The entity collection will be set on
1034: * @param field The field to set
1035: * @throws IllegalArgumentException Reflection
1036: */
1037: private void setIndirectObjectIfPresent(Object entity, Field field) {
1038:• assert entity != null;
1039:• assert field != null;
1040:
1041: final Object value = EntityPropertiesUtils.getFieldValue(field, entity);
1042:• if (value instanceof IndirectWrapper) {
1043: return;
1044: }
1045:• if (IndirectWrapperHelper.requiresIndirectWrapper(value)) {
1046: EntityPropertiesUtils
1047: .setFieldValue(field, entity, indirectWrapperHelper.createIndirectWrapper(value, entity, field));
1048: }
1049: }
1050:
1051: /**
1052: * Creates an indirect collection, which wraps the specified collection instance and propagates changes to the
1053: * persistence context.
1054: *
1055: * @param collection Collection to be proxied
1056: * @param owner Collection owner instance
1057: * @param field Field filled with the collection
1058: * @return Indirect collection
1059: */
1060: public Object createIndirectCollection(Object collection, Object owner, Field field) {
1061: return indirectWrapperHelper.createIndirectWrapper(collection, owner, field);
1062: }
1063:
1064: /**
1065: * Remove indirect collection implementations from the specified entity (if present).
1066: *
1067: * @param entity The entity to remove indirect collections from
1068: */
1069: private void removeIndirectCollections(Object entity) {
1070:• assert entity != null;
1071: final EntityType<?> et = entityType(entity.getClass());
1072:• for (FieldSpecification<?, ?> fs : et.getFieldSpecifications()) {
1073: final Object value = EntityPropertiesUtils.getFieldValue(fs.getJavaField(), entity);
1074:• if (value instanceof IndirectCollection) {
1075: IndirectCollection<?> indCol = (IndirectCollection<?>) value;
1076: EntityPropertiesUtils.setFieldValue(fs.getJavaField(), entity, indCol.unwrap());
1077: }
1078: }
1079: }
1080:
1081: void putObjectIntoCache(Object identifier, Object entity, Descriptor descriptor) {
1082: cacheManager.add(identifier, entity, descriptor);
1083: }
1084:
1085: private Object getIdentifier(Object entity) {
1086: return EntityPropertiesUtils.getIdentifier(entity, getMetamodel());
1087: }
1088:
1089: private void unregisterEntityFromOntologyContext(Object entity) {
1090:• assert entity != null;
1091:
1092: final Descriptor descriptor = repoMap.getEntityDescriptor(entity);
1093:• if (descriptor == null) {
1094: throw new OWLPersistenceException("Fatal error, unable to find descriptor for entity " + entity);
1095: }
1096:
1097: repoMap.remove(descriptor, entity);
1098: repoMap.removeEntityToRepository(entity);
1099: }
1100:
1101: private void registerEntityWithOntologyContext(Object entity, Descriptor descriptor) {
1102:• assert descriptor != null;
1103:• assert entity != null;
1104:
1105: repoMap.add(descriptor, entity, null);
1106: repoMap.addEntityToRepository(entity, descriptor);
1107: }
1108:
1109: private boolean isInRepository(Descriptor descriptor, Object entity) {
1110:• assert descriptor != null;
1111:• assert entity != null;
1112:
1113: return repoMap.contains(descriptor, entity);
1114: }
1115:
1116: private Descriptor getDescriptor(Object entity) {
1117:• assert entity != null;
1118:
1119: final Descriptor descriptor = repoMap.getEntityDescriptor(entity);
1120:• if (descriptor == null) {
1121: throw new OWLPersistenceException("Unable to find descriptor of entity " + entity + " in this UoW!");
1122: }
1123: return descriptor;
1124: }
1125:
1126: private void storageCommit() {
1127: try {
1128: storage.commit();
1129: } catch (OWLPersistenceException e) {
1130: entityManager.removeCurrentPersistenceContext();
1131: throw e;
1132: }
1133: }
1134:
1135: @Override
1136: public <T> T unwrap(Class<T> cls) {
1137:• if (cls.isAssignableFrom(getClass())) {
1138: return cls.cast(this);
1139: }
1140: return storage.unwrap(cls);
1141: }
1142: }