Package: ElementDescriptor$1

ElementDescriptor$1

name	instruction	branch	complexity	line	method
doDispose()	M: 23 C: 0 0%	M: 2 C: 0 0%	M: 2 C: 0 0%	M: 7 C: 0 0%	M: 1 C: 0 0%
{...}	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%

Coverage

1: /********************************************************************************
2: * Copyright (c) 2011 Eike Stepper (Berlin, Germany) 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: * Eike Stepper - initial API and implementation
13: ********************************************************************************/
14: package org.eclipse.emf.ecp.internal.core.util;
15:
16: import org.eclipse.emf.ecp.core.util.ECPElement;
17: import org.eclipse.emf.ecp.internal.core.Activator;
18: import org.eclipse.emf.ecp.spi.core.util.ECPDisposable;
19: import org.eclipse.emf.ecp.spi.core.util.ECPDisposable.DisposeListener;
20: import org.eclipse.emf.ecp.spi.core.util.InternalDescriptor;
21: import org.eclipse.emf.ecp.spi.core.util.InternalRegistryElement;
22:
23: /**
24: * @author Eike Stepper
25: * @param <ELEMENT>
26: */
27: public abstract class ElementDescriptor<ELEMENT extends ECPElement> extends Element implements
28:         InternalDescriptor<ELEMENT>, DisposeListener {
29:         private final Disposable disposable = new Disposable(this) {
30:                 @Override
31:                 protected void doDispose() {
32:•                        if (resolvedElement instanceof ECPDisposable) {
33:                                 try {
34:                                         ((ECPDisposable) resolvedElement).dispose();
35:                                 } catch (final Exception ex) {
36:                                         Activator.log(ex);
37:                                 }
38:                         }
39:
40:                         resolvedElement = null;
41:                         ElementDescriptor.this.doDispose();
42:                 }
43:         };
44:
45:         private final ElementRegistry<ELEMENT, ?> registry;
46:
47:         private String label;
48:
49:         private String description;
50:
51:         private ELEMENT resolvedElement;
52:
53:         public ElementDescriptor(ElementRegistry<ELEMENT, ?> registry, String name) {
54:                 super(name);
55:                 this.registry = registry;
56:                 label = name;
57:                 description = ""; //$NON-NLS-1$
58:         }
59:
60:         public final ElementRegistry<ELEMENT, ?> getRegistry() {
61:                 return registry;
62:         }
63:
64:         /** {@inheritDoc} */
65:         @Override
66:         public final String getLabel() {
67:                 return label;
68:         }
69:
70:         /** {@inheritDoc} */
71:         @Override
72:         public final void setLabel(String label) {
73:                 this.label = label;
74:         }
75:
76:         /** {@inheritDoc} */
77:         @Override
78:         public final String getDescription() {
79:                 return description;
80:         }
81:
82:         /** {@inheritDoc} */
83:         @Override
84:         public final void setDescription(String description) {
85:                 this.description = description;
86:         }
87:
88:         /** {@inheritDoc} */
89:         @Override
90:         public final boolean isResolved() {
91:                 return resolvedElement != null;
92:         }
93:
94:         /** {@inheritDoc} */
95:         @Override
96:         public final ELEMENT getResolvedElement() {
97:                 boolean resolved = false;
98:                 synchronized (this) {
99:                         if (resolvedElement == null) {
100:                                 try {
101:                                         resolvedElement = resolve();
102:                                         if (resolvedElement instanceof InternalRegistryElement) {
103:                                                 final InternalRegistryElement registryElement = (InternalRegistryElement) resolvedElement;
104:                                                 registryElement.setLabel(getLabel());
105:                                                 registryElement.setDescription(getDescription());
106:                                         }
107:
108:                                         if (resolvedElement instanceof ECPDisposable) {
109:                                                 final ECPDisposable disposable = (ECPDisposable) resolvedElement;
110:                                                 disposable.addDisposeListener(this);
111:                                         }
112:
113:                                         resolvedElement(resolvedElement);
114:                                 } catch (final Throwable t) {
115:                                         throw new Error("Unable to resolve " + this, t); //$NON-NLS-1$
116:                                 }
117:
118:                                 resolved = true;
119:                         }
120:                 }
121:
122:                 if (resolved) {
123:                         registry.descriptorChanged(this, true);
124:                 }
125:
126:                 return resolvedElement;
127:         }
128:
129:         /** {@inheritDoc} */
130:         @Override
131:         public final boolean isDisposed() {
132:                 return disposable.isDisposed();
133:         }
134:
135:         /** {@inheritDoc} */
136:         @Override
137:         public final void dispose() {
138:                 disposable.dispose();
139:         }
140:
141:         /** {@inheritDoc} */
142:         @Override
143:         public final void addDisposeListener(DisposeListener listener) {
144:                 disposable.addDisposeListener(listener);
145:         }
146:
147:         /** {@inheritDoc} */
148:         @Override
149:         public final void removeDisposeListener(DisposeListener listener) {
150:                 disposable.removeDisposeListener(listener);
151:         }
152:
153:         /** {@inheritDoc} */
154:         @Override
155:         public final void disposed(ECPDisposable disposable) {
156:                 if (resolvedElement == disposable) {
157:                         resolvedElement = null;
158:                 }
159:
160:                 registry.descriptorChanged(this, false);
161:         }
162:
163:         protected void doDispose() {
164:                 // Can be overridden in subclasses
165:         }
166:
167:         protected void resolvedElement(ELEMENT element) {
168:                 // Can be overridden in subclasses
169:         }
170:
171:         protected abstract ELEMENT resolve() throws Exception;
172: }