Package: IndirectWrapperHelper

IndirectWrapperHelper

name	instruction	branch	complexity	line	method
IndirectWrapperHelper(UnitOfWorkImpl)	M: 0 C: 6 100%	M: 0 C: 0 100%	M: 0 C: 1 100%	M: 0 C: 3 100%	M: 0 C: 1 100%
createIndirectWrapper(Object, Object, Field)	M: 17 C: 56 77%	M: 2 C: 8 80%	M: 2 C: 4 67%	M: 1 C: 9 90%	M: 0 C: 1 100%
requiresIndirectWrapper(Object)	M: 0 C: 13 100%	M: 0 C: 6 100%	M: 0 C: 4 100%	M: 0 C: 1 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: package cz.cvut.kbss.jopa.sessions;
2:
3: import cz.cvut.kbss.jopa.adapters.IndirectList;
4: import cz.cvut.kbss.jopa.adapters.IndirectMap;
5: import cz.cvut.kbss.jopa.adapters.IndirectMultilingualString;
6: import cz.cvut.kbss.jopa.adapters.IndirectSet;
7: import cz.cvut.kbss.jopa.model.MultilingualString;
8:
9: import java.lang.reflect.Field;
10: import java.util.Collection;
11: import java.util.List;
12: import java.util.Map;
13: import java.util.Set;
14:
15: /**
16: * Helper for dealing with indirect wrappers (mainly collections, multilingual strings).
17: * <p>
18: * Indirect wrappers are used to ensure that changes to the wrapped instances are propagated into the persistence
19: * context during transactions.
20: */
21: class IndirectWrapperHelper {
22:
23: private final UnitOfWorkImpl uow;
24:
25: IndirectWrapperHelper(UnitOfWorkImpl uow) {
26: this.uow = uow;
27: }
28:
29: /**
30: * Creates an indirect wrapper for the specified {@code wrapped} object.
31: *
32: * @param wrapped The object to wrap
33: * @param owner Instance owning the wrapped object. Necessary to associate the changes with the correct subject
34: * @param field Field filled with the wrapped object
35: * @return A suitable indirect wrapper
36: */
37: Object createIndirectWrapper(Object wrapped, Object owner, Field field) {
38:• assert requiresIndirectWrapper(wrapped);
39:• if (wrapped instanceof List) {
40: return new IndirectList<>(owner, field, uow, (List<?>) wrapped);
41:• } else if (wrapped instanceof Set) {
42: return new IndirectSet<>(owner, field, uow, (Set<?>) wrapped);
43:• } else if (wrapped instanceof Map) {
44: return new IndirectMap<>(owner, field, uow, (Map<?, ?>) wrapped);
45:• } else if (wrapped instanceof MultilingualString) {
46: return new IndirectMultilingualString(owner, field, uow, (MultilingualString) wrapped);
47: } else {
48: throw new UnsupportedOperationException("Unsupported wrapped type " + wrapped.getClass());
49: }
50: }
51:
52: /**
53: * Checks whether the specified object is of a type requiring an indirect wrapper.
54: *
55: * @param target Target object to check
56: * @return {@code true} if an indirect wrapper is used for the specified target
57: */
58: static boolean requiresIndirectWrapper(Object target) {
59:• return target instanceof Collection || target instanceof MultilingualString || target instanceof Map;
60: }
61: }