Skip to content

Package: RuleServiceHelperImpl$1

RuleServiceHelperImpl$1

nameinstructionbranchcomplexitylinemethod
checkCurrentState(VElement)
M: 0 C: 3
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 1
100%
M: 0 C: 1
100%
{...}
M: 0 C: 6
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 1
100%
M: 0 C: 1
100%

Coverage

1: /*******************************************************************************
2: * Copyright (c) 2011-2013 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: * Edgar Mueller - initial API and implementation
13: ******************************************************************************/
14: package org.eclipse.emf.ecp.view.internal.rule;
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.ecore.EObject;
22: import org.eclipse.emf.ecore.EStructuralFeature;
23: import org.eclipse.emf.ecore.EStructuralFeature.Setting;
24: import org.eclipse.emf.ecp.common.spi.UniqueSetting;
25: import org.eclipse.emf.ecp.view.spi.context.ViewModelContext;
26: import org.eclipse.emf.ecp.view.spi.context.ViewModelService;
27: import org.eclipse.emf.ecp.view.spi.model.VElement;
28: import org.eclipse.emf.ecp.view.spi.rule.RuleServiceHelper;
29:
30: /**
31: * @author emueller
32: *
33: */
34: public class RuleServiceHelperImpl implements ViewModelService, RuleServiceHelper {
35:
36:         /**
37:          * A predicate that is used to determine the set of {@link VElement}s
38:          * if {@link RuleServiceHelperImpl#getInvolvedEObjects(Setting, Object, Class)} is called.
39:          */
40:         private interface RenderablePredicate {
41:                 boolean checkCurrentState(VElement renderable);
42:         }
43:
44:         private ViewModelContext context;
45:
46:         /**
47:          * @return
48:          */
49:         private RenderablePredicate createDisabledRenderablePredicate() {
50:                 return new RenderablePredicate() {
51:                         @Override
52:                         public boolean checkCurrentState(VElement renderable) {
53:                                 return renderable.isEnabled();
54:                         }
55:                 };
56:         }
57:
58:         /**
59:          * @return
60:          */
61:         private RenderablePredicate createHiddenRenderablePredicate() {
62:                 return new RenderablePredicate() {
63:                         @Override
64:                         public boolean checkCurrentState(VElement renderable) {
65:                                 return renderable.isVisible();
66:                         }
67:
68:                 };
69:         }
70:
71:         @SuppressWarnings("unchecked")
72:         private <T extends VElement> Set<T> collectFalseValues(Class<T> cls,
73:                 final Map<VElement, Boolean> renderableToStateMapping, RenderablePredicate renderablePredicate) {
74:
75:                 final Set<T> result = new LinkedHashSet<T>();
76:
77:                 for (final Map.Entry<VElement, Boolean> entry : renderableToStateMapping.entrySet()) {
78:
79:                         final VElement renderable = entry.getKey();
80:                         final Boolean newState = entry.getValue();
81:                         if (newState) {
82:                                 continue;
83:                         }
84:                         if (renderablePredicate.checkCurrentState(renderable) == newState) {
85:                                 continue;
86:                         }
87:                         if (cls.isInstance(renderable)) {
88:                                 result.add((T) renderable);
89:                         } else {
90:                                 EObject parent = renderable.eContainer();
91:                                 while (parent != null) {
92:                                         if (cls.isInstance(parent)) {
93:                                                 result.add((T) parent);
94:                                                 break;
95:                                         }
96:                                         parent = parent.eContainer();
97:                                 }
98:                         }
99:
100:                 }
101:
102:                 return result;
103:         }
104:
105:         /**
106:          * {@inheritDoc}
107:          *
108:          * @see org.eclipse.emf.ecp.view.spi.context.ViewModelService#instantiate(org.eclipse.emf.ecp.view.spi.context.ViewModelContext)
109:          */
110:         @Override
111:         public void instantiate(ViewModelContext context) {
112:                 this.context = context;
113:         }
114:
115:         /**
116:          * {@inheritDoc}
117:          *
118:          * @see org.eclipse.emf.ecp.view.spi.context.ViewModelService#dispose()
119:          */
120:         @Override
121:         public void dispose() {
122:
123:         }
124:
125:         /**
126:          * {@inheritDoc}
127:          *
128:          * @see org.eclipse.emf.ecp.view.spi.context.ViewModelService#getPriority()
129:          */
130:         @Override
131:         public int getPriority() {
132:                 return 2;
133:         }
134:
135:         /**
136:          * {@inheritDoc}
137:          *
138:          * @see org.eclipse.emf.ecp.view.spi.rule.RuleServiceHelper#getInvolvedEObjects(org.eclipse.emf.ecore.EStructuralFeature.Setting,
139:          * java.lang.Object, java.lang.Class)
140:          */
141:         @Override
142:         public <T extends VElement> Set<T> getInvolvedEObjects(Setting setting, Object newValue, Class<T> renderableClass) {
143:                 final Map<Setting, Object> newValues = new LinkedHashMap<EStructuralFeature.Setting, Object>();
144:                 newValues.put(setting, newValue);
145:
146:                 final Map<VElement, Boolean> disabledRenderables = context.getService(RuleService.class)
147:                         .getDisabledRenderables(newValues, UniqueSetting.createSetting(setting));
148:                 final Map<VElement, Boolean> hiddenRenderables = context.getService(RuleService.class)
149:                         .getHiddenRenderables(newValues, UniqueSetting.createSetting(setting));
150:
151:                 final Set<T> result = new LinkedHashSet<T>();
152:                 result.addAll(collectFalseValues(renderableClass, disabledRenderables, createDisabledRenderablePredicate()));
153:                 result.addAll(collectFalseValues(renderableClass, hiddenRenderables, createHiddenRenderablePredicate()));
154:                 return result;
155:         }
156: }