Package: ContainingEClassStrategy

ContainingEClassStrategy

name	instruction	branch	complexity	line	method
ContainingEClassStrategy()	M: 0 C: 13 100%	M: 0 C: 0 100%	M: 0 C: 1 100%	M: 0 C: 3 100%	M: 0 C: 1 100%
deregister(ChangeObserver)	M: 0 C: 39 100%	M: 1 C: 5 83%	M: 1 C: 3 75%	M: 0 C: 9 100%	M: 0 C: 1 100%
getAllObservers()	M: 0 C: 7 100%	M: 0 C: 0 100%	M: 0 C: 1 100%	M: 0 C: 1 100%	M: 0 C: 1 100%
getEClassFromNotification(Notification)	M: 0 C: 21 100%	M: 0 C: 2 100%	M: 0 C: 2 100%	M: 0 C: 6 100%	M: 0 C: 1 100%
getObservers(Notification)	M: 0 C: 56 100%	M: 0 C: 6 100%	M: 0 C: 4 100%	M: 0 C: 10 100%	M: 0 C: 1 100%
register(ChangeObserver, EClass)	M: 0 C: 43 100%	M: 2 C: 2 50%	M: 2 C: 1 33%	M: 0 C: 7 100%	M: 0 C: 1 100%

Coverage

1: /*******************************************************************************
2: * Copyright (c) 2011-2015 EclipseSource Muenchen GmbH and others.
3: *
4: * All rights reserved. This program and the accompanying materials
5: * are made available under the terms of the Eclipse Public License 2.0
6: * which accompanies this distribution, and is available at
7: * https://www.eclipse.org/legal/epl-2.0/
8: *
9: * SPDX-License-Identifier: EPL-2.0
10: *
11: * Contributors:
12: * jfaltermeier - initial API and implementation
13: ******************************************************************************/
14: package org.eclipse.emf.ecp.changebroker.internal;
15:
16: import java.util.LinkedHashMap;
17: import java.util.LinkedHashSet;
18: import java.util.Map;
19: import java.util.Set;
20:
21: import org.eclipse.emf.common.notify.Notification;
22: import org.eclipse.emf.ecore.EClass;
23: import org.eclipse.emf.ecore.EObject;
24: import org.eclipse.emf.ecp.changebroker.spi.ChangeObserver;
25:
26: /**
27: * @author jfaltermeier
28: *
29: */
30: public class ContainingEClassStrategy implements Strategy {
31:         private final Map<EClass, Set<ChangeObserver>> registry = new LinkedHashMap<EClass, Set<ChangeObserver>>();
32:         private final Map<ChangeObserver, Set<EClass>> observerToKey = new LinkedHashMap<ChangeObserver, Set<EClass>>();
33:
34:         /**
35:          * Registers an observer.
36:          *
37:          * @param observer the observer
38:          * @param eClass the containing eclass
39:          */
40:         public void register(ChangeObserver observer, EClass eClass) {
41:•                if (!registry.containsKey(eClass)) {
42:                         registry.put(eClass, new LinkedHashSet<ChangeObserver>());
43:                 }
44:                 registry.get(eClass).add(observer);
45:
46:•                if (!observerToKey.containsKey(observer)) {
47:                         observerToKey.put(observer, new LinkedHashSet<EClass>());
48:                 }
49:                 observerToKey.get(observer).add(eClass);
50:         }
51:
52:         @Override
53:         public Set<ChangeObserver> getObservers(Notification notification) {
54:                 final Set<ChangeObserver> observers = new LinkedHashSet<ChangeObserver>();
55:                 final Set<EClass> allEClasses = getEClassFromNotification(notification);
56:•                for (final EClass eClass : allEClasses) {
57:                         final Set<EClass> eClassesToCheck = new LinkedHashSet<EClass>(eClass.getESuperTypes());
58:                         eClassesToCheck.add(eClass);
59:•                        for (final EClass eClassToCheck : eClassesToCheck) {
60:•                                if (!registry.containsKey(eClassToCheck)) {
61:                                         continue;
62:                                 }
63:                                 observers.addAll(registry.get(eClassToCheck));
64:                         }
65:                 }
66:                 return observers;
67:         }
68:
69:         private Set<EClass> getEClassFromNotification(Notification notification) {
70:                 final Set<EClass> allEClasses = new LinkedHashSet<EClass>();
71:                 EObject notifier = (EObject) notification.getNotifier();
72:•                while (notifier != null) {
73:                         allEClasses.add(notifier.eClass());
74:                         notifier = notifier.eContainer();
75:                 }
76:                 return allEClasses;
77:         }
78:
79:         /**
80:          *
81:          * {@inheritDoc}
82:          *
83:          * @see org.eclipse.emf.ecp.changebroker.internal.Strategy#deregister(ChangeObserver)
84:          */
85:         @Override
86:         public void deregister(ChangeObserver observer) {
87:                 final Set<EClass> keys = observerToKey.remove(observer);
88:•                if (keys == null) {
89:                         return;
90:                 }
91:•                for (final EClass eClass : keys) {
92:                         final Set<ChangeObserver> set = registry.get(eClass);
93:                         set.remove(observer);
94:•                        if (set.isEmpty()) {
95:                                 registry.remove(eClass);
96:                         }
97:                 }
98:         }
99:
100:         /**
101:          * {@inheritDoc}
102:          *
103:          * @see org.eclipse.emf.ecp.changebroker.internal.Strategy#getAllObservers()
104:          */
105:         @Override
106:         public Set<ChangeObserver> getAllObservers() {
107:                 return new LinkedHashSet<ChangeObserver>(observerToKey.keySet());
108:         }
109: }