Skip to content

Package: ECPValidationResultServiceImpl

ECPValidationResultServiceImpl

nameinstructionbranchcomplexitylinemethod
ECPValidationResultServiceImpl()
M: 0 C: 18
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 5
100%
M: 0 C: 1
100%
addToClassifierToListenerMap(EClassifier, ECPValidationResultService.ECPValidationResultServiceListener)
M: 0 C: 22
100%
M: 0 C: 2
100%
M: 0 C: 2
100%
M: 0 C: 4
100%
M: 0 C: 1
100%
deregister(ECPValidationResultService.ECPValidationResultServiceListener)
M: 0 C: 9
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 3
100%
M: 0 C: 1
100%
extractClassifier(Set, Diagnostic)
M: 1 C: 22
96%
M: 2 C: 2
50%
M: 2 C: 1
33%
M: 1 C: 4
80%
M: 0 C: 1
100%
notifyListener(Object, Set)
M: 0 C: 30
100%
M: 0 C: 4
100%
M: 0 C: 3
100%
M: 0 C: 7
100%
M: 0 C: 1
100%
notifyListenerFromSet(Object, Set)
M: 0 C: 13
100%
M: 0 C: 2
100%
M: 0 C: 2
100%
M: 0 C: 4
100%
M: 0 C: 1
100%
register(ECPValidationResultService.ECPValidationResultServiceListener)
M: 0 C: 9
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 3
100%
M: 0 C: 1
100%
register(ECPValidationResultService.ECPValidationResultServiceListener, Set)
M: 12 C: 69
85%
M: 1 C: 7
88%
M: 1 C: 4
80%
M: 2 C: 14
88%
M: 0 C: 1
100%
removeFromSpecificMap(ECPValidationResultService.ECPValidationResultServiceListener)
M: 0 C: 37
100%
M: 0 C: 4
100%
M: 0 C: 3
100%
M: 0 C: 7
100%
M: 0 C: 1
100%
setResult(Diagnostic)
M: 0 C: 13
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 4
100%
M: 0 C: 1
100%
setResult(Diagnostic[])
M: 0 C: 29
100%
M: 0 C: 2
100%
M: 0 C: 2
100%
M: 0 C: 5
100%
M: 0 C: 1
100%
setResult(List)
M: 0 C: 24
100%
M: 0 C: 2
100%
M: 0 C: 2
100%
M: 0 C: 5
100%
M: 0 C: 1
100%

Coverage

1: /*******************************************************************************
2: * Copyright (c) 2011-2014 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: * Johannes Faltermeier - initial API and implementation
13: ******************************************************************************/
14: package org.eclipse.emf.ecp.internal.ui.validation;
15:
16: import java.util.Iterator;
17: import java.util.LinkedHashMap;
18: import java.util.LinkedHashSet;
19: import java.util.List;
20: import java.util.Map;
21: import java.util.Set;
22:
23: import org.eclipse.emf.common.util.Diagnostic;
24: import org.eclipse.emf.ecore.EClassifier;
25: import org.eclipse.emf.ecore.EObject;
26: import org.eclipse.emf.ecp.ui.validation.ECPValidationResultService;
27:
28: /**
29: * Default implementation of the {@link ECPValidationResultService}.
30: *
31: * @author jfaltermeier
32: *
33: */
34: public class ECPValidationResultServiceImpl implements ECPValidationResultService {
35:
36:         private final Set<ECPValidationResultServiceListener> listener;
37:         private final Map<EClassifier, Set<ECPValidationResultServiceListener>> classifierToListenerMap;
38:         private final Map<ECPValidationResultServiceListener, Set<EClassifier>> listenerToClassifierMap;
39:
40:         /**
41:          * Constructor.
42:          */
43:         public ECPValidationResultServiceImpl() {
44:                 listener = new LinkedHashSet<ECPValidationResultService.ECPValidationResultServiceListener>();
45:                 classifierToListenerMap = new LinkedHashMap<EClassifier, Set<ECPValidationResultServiceListener>>();
46:                 listenerToClassifierMap = new LinkedHashMap<ECPValidationResultService.ECPValidationResultServiceListener, Set<EClassifier>>();
47:         }
48:
49:         /**
50:          * {@inheritDoc}
51:          *
52:          * @see org.eclipse.emf.ecp.ui.validation.ECPValidationResultService#setResult(org.eclipse.emf.common.util.Diagnostic[])
53:          */
54:         @Override
55:         public void setResult(Diagnostic[] diagnostic) {
56:                 final Set<EClassifier> classifiers = new LinkedHashSet<EClassifier>();
57:•                for (final Diagnostic d : diagnostic) {
58:                         extractClassifier(classifiers, d);
59:                 }
60:                 notifyListener(diagnostic, classifiers);
61:         }
62:
63:         /**
64:          * {@inheritDoc}
65:          *
66:          * @see org.eclipse.emf.ecp.ui.validation.ECPValidationResultService#setResult(org.eclipse.emf.common.util.Diagnostic)
67:          */
68:         @Override
69:         public void setResult(Diagnostic diagnostic) {
70:                 final Set<EClassifier> classifiers = new LinkedHashSet<EClassifier>();
71:                 extractClassifier(classifiers, diagnostic);
72:                 notifyListener(diagnostic, classifiers);
73:         }
74:
75:         /**
76:          * {@inheritDoc}
77:          *
78:          * @see org.eclipse.emf.ecp.ui.validation.ECPValidationResultService#setResult(java.util.List)
79:          */
80:         @Override
81:         public void setResult(List<Diagnostic> diagnostic) {
82:                 final Set<EClassifier> classifiers = new LinkedHashSet<EClassifier>();
83:•                for (final Diagnostic d : diagnostic) {
84:                         extractClassifier(classifiers, d);
85:                 }
86:                 notifyListener(diagnostic, classifiers);
87:         }
88:
89:         /**
90:          * @param classifiers
91:          * @param d
92:          */
93:         private void extractClassifier(final Set<EClassifier> classifiers, final Diagnostic d) {
94:•                if (d.getData().size() == 0 || !(d.getData().get(0) instanceof EObject)) {
95:                         return;
96:                 }
97:                 final EObject object = (EObject) d.getData().get(0);
98:                 classifiers.add(object.eClass());
99:         }
100:
101:         private void notifyListener(Object diagnostic, Set<EClassifier> classifiers) {
102:                 notifyListenerFromSet(diagnostic, listener);
103:
104:•                for (final EClassifier c : classifiers) {
105:                         final Set<ECPValidationResultServiceListener> set = classifierToListenerMap.get(c);
106:•                        if (set == null) {
107:                                 continue;
108:                         }
109:                         notifyListenerFromSet(diagnostic, set);
110:                 }
111:         }
112:
113:         private void notifyListenerFromSet(Object diagnostic, Set<ECPValidationResultServiceListener> listener) {
114:                 final Iterator<ECPValidationResultServiceListener> iterator = listener.iterator();
115:•                while (iterator.hasNext()) {
116:                         iterator.next().resultChanged(diagnostic);
117:                 }
118:         }
119:
120:         /**
121:          * {@inheritDoc}
122:          *
123:          * @see org.eclipse.emf.ecp.ui.validation.ECPValidationResultService#register(org.eclipse.emf.ecp.ui.validation.ECPValidationResultService.ECPValidationResultServiceListener)
124:          */
125:         @Override
126:         public void register(ECPValidationResultServiceListener listener) {
127:                 /* Register for all results. */
128:                 this.listener.add(listener);
129:                 removeFromSpecificMap(listener);
130:         }
131:
132:         /**
133:          * {@inheritDoc}
134:          *
135:          * @see org.eclipse.emf.ecp.ui.validation.ECPValidationResultService#register(org.eclipse.emf.ecp.ui.validation.ECPValidationResultService.ECPValidationResultServiceListener,
136:          * java.util.Set)
137:          */
138:         @Override
139:         public void register(ECPValidationResultServiceListener listener, Set<EClassifier> classifiersOfInterest) {
140:                 /* remove from list for all notifications */
141:                 this.listener.remove(listener);
142:
143:                 /* Add to new */
144:•                final Set<EClassifier> currentlyRegisteredClassifiers = listenerToClassifierMap.containsKey(listener)
145:                         ? listenerToClassifierMap
146:                                 .get(listener)
147:                         : new LinkedHashSet<EClassifier>();
148:
149:                 final Set<EClassifier> classifiersToRemove = new LinkedHashSet<EClassifier>();
150:•                for (final EClassifier classifier : currentlyRegisteredClassifiers) {
151:•                        if (!classifiersOfInterest.contains(classifier)) {
152:                                 classifiersToRemove.add(classifier);
153:                                 classifierToListenerMap.get(classifier).remove(listener);
154:                         }
155:                 }
156:                 currentlyRegisteredClassifiers.removeAll(classifiersToRemove);
157:•                for (final EClassifier classifier : classifiersOfInterest) {
158:                         currentlyRegisteredClassifiers.add(classifier);
159:                         addToClassifierToListenerMap(classifier, listener);
160:                 }
161:                 listenerToClassifierMap.put(listener, currentlyRegisteredClassifiers);
162:         }
163:
164:         private void addToClassifierToListenerMap(EClassifier classifier, ECPValidationResultServiceListener listener) {
165:•                if (!classifierToListenerMap.containsKey(classifier)) {
166:                         classifierToListenerMap.put(classifier, new LinkedHashSet<ECPValidationResultServiceListener>());
167:                 }
168:                 classifierToListenerMap.get(classifier).add(listener);
169:         }
170:
171:         /**
172:          * @param listener
173:          */
174:         private void removeFromSpecificMap(ECPValidationResultServiceListener listener) {
175:                 /* Check if listener was registered for some classifiers. If so unregister. */
176:•                if (!listenerToClassifierMap.containsKey(listener)) {
177:                         return;
178:                 }
179:                 final Set<EClassifier> classifiers = listenerToClassifierMap.get(listener);
180:•                for (final EClassifier c : classifiers) {
181:                         classifierToListenerMap.get(c).remove(listener);
182:                 }
183:                 listenerToClassifierMap.remove(listener);
184:         }
185:
186:         /**
187:          * {@inheritDoc}
188:          *
189:          * @see org.eclipse.emf.ecp.ui.validation.ECPValidationResultService#deregister(org.eclipse.emf.ecp.ui.validation.ECPValidationResultService.ECPValidationResultServiceListener)
190:          */
191:         @Override
192:         public void deregister(ECPValidationResultServiceListener listener) {
193:                 this.listener.remove(listener);
194:                 removeFromSpecificMap(listener);
195:         }
196:
197: }