![[Jenkins]](/ecp/static/e8bbdb94/images/svgs/logo.svg){kind=logo}
Package: ECPProviderRegistryImpl$ProviderParser
ECPProviderRegistryImpl$ProviderParser
| name | instruction | branch | complexity | line | method | ||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ECPProviderRegistryImpl.ProviderParser(ECPProviderRegistryImpl) |
|
|
|
|
|
||||||||||||||||||||
| createElement(String, IConfigurationElement) |
|
|
|
|
|
||||||||||||||||||||
Coverage
1: /*******************************************************************************
2: * Copyright (c) 2011-2012 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: * Eike Stepper - initial API and implementation
13: * Eugen Neufeld - JavaDoc
14: *******************************************************************************/
15:
16: package org.eclipse.emf.ecp.internal.core;
17:
18: import java.util.Collection;
19: import java.util.Collections;
20: import java.util.Iterator;
21: import java.util.Set;
22:
23: import org.eclipse.core.runtime.IConfigurationElement;
24: import org.eclipse.emf.common.notify.Notifier;
25: import org.eclipse.emf.common.util.EList;
26: import org.eclipse.emf.ecore.EObject;
27: import org.eclipse.emf.ecore.EPackage;
28: import org.eclipse.emf.ecore.EReference;
29: import org.eclipse.emf.ecp.core.ECPProvider;
30: import org.eclipse.emf.ecp.core.ECPProviderRegistry;
31: import org.eclipse.emf.ecp.core.util.ECPContainer;
32: import org.eclipse.emf.ecp.core.util.ECPProviderAware;
33: import org.eclipse.emf.ecp.core.util.ECPUtil;
34: import org.eclipse.emf.ecp.core.util.observer.ECPObserver;
35: import org.eclipse.emf.ecp.core.util.observer.ECPProvidersChangedObserver;
36: import org.eclipse.emf.ecp.internal.core.util.ElementRegistry;
37: import org.eclipse.emf.ecp.internal.core.util.ExtensionParser;
38: import org.eclipse.emf.ecp.internal.core.util.ExtensionParser.ExtensionDescriptor;
39: import org.eclipse.emf.ecp.spi.core.InternalProject;
40: import org.eclipse.emf.ecp.spi.core.InternalProvider;
41: import org.eclipse.emf.ecp.spi.core.InternalRepository;
42: import org.eclipse.emf.ecp.spi.core.ProviderChangeListener;
43: import org.eclipse.emf.ecp.spi.core.util.AdapterProvider;
44: import org.eclipse.emf.ecp.spi.core.util.InternalChildrenList;
45: import org.eclipse.emf.edit.domain.EditingDomain;
46: import org.eclipse.net4j.util.AdapterUtil;
47:
48: /**
49: * This class manages {@link ECPProvider}.
50: *
51: * @author Eike Stepper
52: * @author Eugen Neufeld
53: */
54: public final class ECPProviderRegistryImpl extends ElementRegistry<InternalProvider, ECPObserver> implements
55: ECPProviderRegistry {
56:
57: private final ProviderParser extensionParser = new ProviderParser();
58:
59: /**
60: * Should not be called directly, use service instead.
61: */
62: public ECPProviderRegistryImpl() {
63:
64: }
65:
66: /**
67: * Gets a provider from an adaptabel object.
68: *
69: * @param adaptable the adaptabel Object
70: * @return The {@link InternalProvider}
71: */
72: public InternalProvider getProvider(Object adaptable) {
73: if (adaptable instanceof ECPProviderAware) {
74: final ECPProviderAware providerAware = (ECPProviderAware) adaptable;
75: return (InternalProvider) providerAware.getProvider();
76: }
77: return AdapterUtil.adapt(adaptable, InternalProvider.class);
78: }
79:
80: /** {@inheritDoc} **/
81: @Override
82: public InternalProvider getProvider(String name) {
83: return getElement(name);
84: }
85:
86: /** {@inheritDoc} **/
87: @Override
88: public Collection<ECPProvider> getProviders() {
89: return (Collection) getElements();
90: }
91:
92: /** {@inheritDoc} **/
93: @Override
94: public void addProvider(ECPProvider provider) {
95: changeElements(null, Collections.singleton((InternalProvider) provider));
96: }
97:
98: /** {@inheritDoc} **/
99: @Override
100: public void removeProvider(String name) {
101: changeElements(Collections.singleton(name), null);
102: }
103:
104: // @Override
105: // protected InternalProvider[] createElementArray(int size) {
106: // return new InternalProvider[size];
107: // }
108:
109: /** {@inheritDoc} **/
110: @Override
111: protected void notifyObservers(Collection<InternalProvider> oldProviders, Collection<InternalProvider> newProviders)
112: throws Exception {
113: ECPUtil.getECPObserverBus().notify(ECPProvidersChangedObserver.class)
114: .providersChanged((Collection) oldProviders, (Collection) newProviders);
115: }
116:
117: @Override
118: protected void elementsChanged(Collection<InternalProvider> oldElements, Collection<InternalProvider> newElements) {
119: super.elementsChanged(oldElements, newElements);
120: }
121:
122: @Override
123: protected void doActivate() throws Exception {
124: super.doActivate();
125: extensionParser.activate();
126: }
127:
128: @Override
129: protected void doDeactivate() throws Exception {
130: extensionParser.deactivate();
131: super.doDeactivate();
132: }
133:
134: /**
135: * @author Eike Stepper
136: */
137: private final class ProviderParser extends ExtensionParser<InternalProvider> {
138: private static final String EXTENSION_POINT_NAME = "providers"; //$NON-NLS-1$
139:
140: ProviderParser() {
141: super(ECPProviderRegistryImpl.this, Activator.PLUGIN_ID, EXTENSION_POINT_NAME);
142: }
143:
144: @Override
145: protected InternalProvider createElement(String name, IConfigurationElement configurationElement) {
146: final ProviderDescriptor descriptor = new ProviderDescriptor(name, configurationElement);
147: descriptor.setLabel(configurationElement.getDeclaringExtension().getLabel());
148: descriptor.setDescription(configurationElement.getAttribute("description")); //$NON-NLS-1$
149: return descriptor;
150: }
151: }
152:
153: /**
154: * @author Eike Stepper
155: */
156: private final class ProviderDescriptor extends ExtensionDescriptor<InternalProvider> implements InternalProvider {
157: private AdapterProvider uiProvider;
158:
159: ProviderDescriptor(String name, IConfigurationElement configurationElement) {
160: super(ECPProviderRegistryImpl.this, name, TYPE, configurationElement);
161: }
162:
163: /** {@inheritDoc} */
164: @Override
165: public ECPProvider getProvider() {
166: return this;
167: }
168:
169: /** {@inheritDoc} */
170: @Override
171: public AdapterProvider getUIProvider() {
172: return uiProvider;
173: }
174:
175: /** {@inheritDoc} */
176: @Override
177: public void setUIProvider(AdapterProvider uiProvider) {
178: this.uiProvider = uiProvider;
179: if (isResolved()) {
180: getResolvedElement().setUIProvider(uiProvider);
181: }
182: }
183:
184: /** {@inheritDoc} */
185: @Override
186: public <T> T getAdapter(Object adaptable, Class<T> adapterType) {
187: return getResolvedElement().getAdapter(adaptable, adapterType);
188: }
189:
190: /** {@inheritDoc} */
191: @Override
192: public Object getAdapter(@SuppressWarnings("rawtypes") Class adapterType) {
193: return getResolvedElement().getAdapter(adapterType);
194: }
195:
196: /** {@inheritDoc} */
197: @Override
198: public Set<InternalProject> getOpenProjects() {
199: return getResolvedElement().getOpenProjects();
200: }
201:
202: /** {@inheritDoc} */
203: @Override
204: public EditingDomain createEditingDomain(InternalProject project) {
205: return getResolvedElement().createEditingDomain(project);
206: }
207:
208: /** {@inheritDoc} */
209: @Override
210: public boolean hasCreateRepositorySupport() {
211: return getResolvedElement().hasCreateRepositorySupport();
212: }
213:
214: /** {@inheritDoc} */
215: @Override
216: public boolean isSlow(Object parent) {
217: return getResolvedElement().isSlow(parent);
218: }
219:
220: /** {@inheritDoc} */
221: @Override
222: public ECPContainer getModelContext(Object element) {
223: return getResolvedElement().getModelContext(element);
224: }
225:
226: /** {@inheritDoc} */
227: @Override
228: public void fillChildren(ECPContainer context, Object parent, InternalChildrenList childrenList) {
229: getResolvedElement().fillChildren(context, parent, childrenList);
230: }
231:
232: /** {@inheritDoc} */
233: @Override
234: public void handleLifecycle(ECPContainer context, LifecycleEvent event) {
235: getResolvedElement().handleLifecycle(context, event);
236: }
237:
238: /** {@inheritDoc} */
239: @Override
240: protected void resolvedElement(InternalProvider provider) {
241: super.resolvedElement(provider);
242: provider.setLabel(getLabel());
243: provider.setDescription(getDescription());
244: provider.setUIProvider(uiProvider);
245: }
246:
247: /** {@inheritDoc} */
248: @Override
249: protected void doDispose() {
250: uiProvider = null;
251: super.doDispose();
252: }
253:
254: /** {@inheritDoc} */
255: @Override
256: public boolean hasCreateProjectWithoutRepositorySupport() {
257: return getResolvedElement().hasCreateProjectWithoutRepositorySupport();
258: }
259:
260: /** {@inheritDoc} */
261: @Override
262: public EList<? extends Object> getElements(InternalProject project) {
263: return getResolvedElement().getElements(project);
264: }
265:
266: /** {@inheritDoc} */
267: @Override
268: public Iterator<EObject> getLinkElements(InternalProject project, EObject modelElement, EReference eReference) {
269: return getResolvedElement().getLinkElements(project, modelElement, eReference);
270: }
271:
272: /** {@inheritDoc} */
273: @Override
274: public Set<EPackage> getUnsupportedEPackages(Collection<EPackage> ePackages, InternalRepository repository) {
275: return getResolvedElement().getUnsupportedEPackages(ePackages, repository);
276: }
277:
278: /** {@inheritDoc} */
279: @Override
280: public void doSave(InternalProject project) {
281: getResolvedElement().doSave(project);
282: }
283:
284: /** {@inheritDoc} */
285: @Override
286: public boolean isDirty(InternalProject project) {
287: return getResolvedElement().isDirty(project);
288: }
289:
290: /** {@inheritDoc} */
291: @Override
292: public void delete(InternalProject project, Collection<Object> objects) {
293: getResolvedElement().delete(project, objects);
294: }
295:
296: /** {@inheritDoc} */
297: @Override
298: public void cloneProject(InternalProject projectToClone, InternalProject targetProject) {
299: getResolvedElement().cloneProject(projectToClone, targetProject);
300: }
301:
302: /** {@inheritDoc} */
303: @Override
304: public boolean modelExists(InternalProject project) {
305: return getResolvedElement().modelExists(project);
306: }
307:
308: /** {@inheritDoc} */
309: @Override
310: public Notifier getRoot(InternalProject project) {
311: return getResolvedElement().getRoot(project);
312: }
313:
314: /** {@inheritDoc} */
315: @Override
316: public boolean contains(InternalProject project, Object object) {
317: return getResolvedElement().contains(project, object);
318: }
319:
320: /**
321: * {@inheritDoc}
322: *
323: * @see org.eclipse.emf.ecp.spi.core.InternalProvider#isThreadSafe()
324: */
325: @Override
326: public boolean isThreadSafe() {
327: return getResolvedElement().isThreadSafe();
328: }
329:
330: /**
331: * {@inheritDoc}
332: *
333: * @see org.eclipse.emf.ecp.spi.core.InternalProvider#registerChangeListener(org.eclipse.emf.ecp.spi.core.ProviderChangeListener)
334: */
335: @Override
336: public void registerChangeListener(ProviderChangeListener listener) {
337: getResolvedElement().registerChangeListener(listener);
338:
339: }
340:
341: /**
342: * {@inheritDoc}
343: *
344: * @see org.eclipse.emf.ecp.spi.core.InternalProvider#unregisterChangeListener(org.eclipse.emf.ecp.spi.core.ProviderChangeListener)
345: */
346: @Override
347: public void unregisterChangeListener(ProviderChangeListener listener) {
348: getResolvedElement().unregisterChangeListener(listener);
349:
350: }
351: }
352: }