blob: a4cb34b033221fd2fa875fd39115742635da9af4 (
plain) (
blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
|
/*****************************************************************************
* Copyright (c) 2014 CEA LIST.
*
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License 2.0
* which accompanies this distribution, and is available at
* https://www.eclipse.org/legal/epl-2.0/
*
* SPDX-License-Identifier: EPL-2.0
*
* Contributors:
* CEA LIST - Initial API and implementation
*
*****************************************************************************/
package org.eclipse.papyrus.infra.types.core.registries;
import java.util.HashMap;
import java.util.Map;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.Platform;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.gmf.runtime.emf.type.core.IContainerDescriptor;
import org.eclipse.gmf.runtime.emf.type.core.IElementMatcher;
import org.eclipse.papyrus.infra.types.AbstractMatcherConfiguration;
import org.eclipse.papyrus.infra.types.ContainerConfiguration;
import org.eclipse.papyrus.infra.types.core.Activator;
import org.eclipse.papyrus.infra.types.core.IConfiguredContainerDescriptor;
import org.eclipse.papyrus.infra.types.core.extensionpoints.IContainerConfigurationKindExtensionPoint;
import org.eclipse.papyrus.infra.types.core.factories.IContainerFactory;
/**
* Registry that manages all possible containerConfiguration
*/
public class ContainerConfigurationTypeRegistry {
private volatile static ContainerConfigurationTypeRegistry registry;
protected Map<String, IContainerFactory<? extends ContainerConfiguration>> containerConfigurationTypeToFactory = null;
private ContainerConfigurationTypeRegistry() {
super();
}
/**
* returns the singleton instance of this registry
*
* @return the singleton instance of this registry
*/
public static synchronized ContainerConfigurationTypeRegistry getInstance() {
if (registry == null) {
registry = new ContainerConfigurationTypeRegistry();
registry.init();
}
return registry;
}
/**
* Inits the registry.
*/
protected void init() {
containerConfigurationTypeToFactory = new HashMap<String, IContainerFactory<? extends ContainerConfiguration>>();
IConfigurationElement[] elements = Platform.getExtensionRegistry().getConfigurationElementsFor(IContainerConfigurationKindExtensionPoint.EXTENSION_POINT_ID);
for (IConfigurationElement configurationElement : elements) {
String configurationClass = configurationElement.getAttribute(IContainerConfigurationKindExtensionPoint.CONFIGURATION_CLASS);
try {
Object factoryClass = configurationElement.createExecutableExtension(IContainerConfigurationKindExtensionPoint.FACTORY_CLASS);
if (factoryClass instanceof IContainerFactory) {
containerConfigurationTypeToFactory.put(configurationClass, (IContainerFactory<?>) factoryClass);
}
} catch (CoreException e) {
Activator.log.error(e);
}
}
}
protected <T extends ContainerConfiguration> IContainerFactory<T> getFactory(ContainerConfiguration containerConfiguration) {
String containerConfigurationType = containerConfiguration.eClass().getInstanceTypeName();
// We assume here that the right factory is registered for the right ContainerConfiguration
@SuppressWarnings("unchecked")
IContainerFactory<T> factory = (IContainerFactory<T>) containerConfigurationTypeToFactory.get(containerConfigurationType);
return factory;
}
public <T extends ContainerConfiguration> IContainerDescriptor getContainerDescriptor(T containerConfiguration) {
if (containerConfiguration == null) {
return null;
} else {
IContainerFactory<T> factory = getFactory(containerConfiguration);
IConfiguredContainerDescriptor<T> containerDescriptor;
if (factory == null) {
// Provide default interpretation
containerDescriptor = new DefaultContainerDescriptor<T>(containerConfiguration);
} else {
containerDescriptor = factory.createContainerDescriptor(containerConfiguration);
}
containerDescriptor.init(containerConfiguration);
return containerDescriptor;
}
}
public class DefaultContainerDescriptor<T extends ContainerConfiguration> implements IConfiguredContainerDescriptor<T> {
protected ContainerConfiguration containerConfiguration;
protected IElementMatcher matcher;
protected EReference[] references;
public DefaultContainerDescriptor(ContainerConfiguration containerConfiguration) {
AbstractMatcherConfiguration matcherConfiguration = containerConfiguration.getContainerMatcherConfiguration();
matcher = MatcherConfigurationTypeRegistry.getInstance().getMatcher(matcherConfiguration);
EList<EReference> eContainmentFeatures = containerConfiguration.getEContainmentFeatures();
references = eContainmentFeatures.toArray(new EReference[] {});
}
public IElementMatcher getMatcher() {
return matcher;
}
public EReference[] getContainmentFeatures() {
return references;
}
public void init(ContainerConfiguration containerConfiguration) {
this.containerConfiguration = containerConfiguration;
}
}
}
|
