| /** |
| * |
| * Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) |
| * |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation |
| */ |
| package org.eclipse.osbp.dsl.metadata.service; |
| |
| import java.net.URL; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Dictionary; |
| import java.util.Enumeration; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Locale; |
| import java.util.Map; |
| import java.util.MissingResourceException; |
| import java.util.Properties; |
| import java.util.ResourceBundle; |
| import java.util.Set; |
| |
| import javax.inject.Inject; |
| |
| import org.eclipse.emf.common.util.URI; |
| import org.eclipse.emf.ecore.EClass; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.ecore.EPackage; |
| import org.eclipse.osbp.dsl.semantic.common.types.LTypedPackage; |
| import org.eclipse.osbp.dsl.semantic.dto.LDto; |
| import org.eclipse.osbp.dsl.xtext.types.bundles.BundleSpaceTypeProvider; |
| import org.eclipse.osbp.preferences.ProductConfiguration; |
| import org.eclipse.osbp.runtime.common.extender.IExtenderConstants; |
| import org.eclipse.osbp.ui.api.metadata.IDSLMetadataService; |
| import org.eclipse.osbp.xtext.builder.metadata.services.AbstractBuilderParticipant; |
| import org.eclipse.osbp.xtext.builder.metadata.services.IBuilderParticipant; |
| import org.eclipse.osbp.xtext.builder.metadata.services.IMetadataBuilderService; |
| import org.eclipse.osbp.xtext.chart.Chart; |
| import org.eclipse.osbp.xtext.chart.ChartDSLPackage; |
| import org.eclipse.osbp.xtext.chart.ChartPackage; |
| import org.eclipse.osbp.xtext.datamartdsl.DatamartDefinition; |
| import org.eclipse.osbp.xtext.datamartdsl.DatamartPackage; |
| import org.eclipse.osbp.xtext.dialogdsl.Dialog; |
| import org.eclipse.osbp.xtext.dialogdsl.DialogDSLPackage; |
| import org.eclipse.osbp.xtext.dialogdsl.DialogPackage; |
| import org.eclipse.osbp.xtext.i18n.I18NKeyGenerator; |
| import org.eclipse.osbp.xtext.organizationdsl.Organization; |
| import org.eclipse.osbp.xtext.perspective.Perspective; |
| import org.eclipse.osbp.xtext.perspective.PerspectiveDslPackage; |
| import org.eclipse.osbp.xtext.perspective.PerspectivePackage; |
| import org.eclipse.osbp.xtext.reportdsl.Report; |
| import org.eclipse.osbp.xtext.reportdsl.ReportDSLPackage; |
| import org.eclipse.osbp.xtext.reportdsl.ReportPackage; |
| import org.eclipse.osbp.xtext.table.Table; |
| import org.eclipse.osbp.xtext.table.TableDSLPackage; |
| import org.eclipse.osbp.xtext.table.TableGrid; |
| import org.eclipse.osbp.xtext.table.TablePackage; |
| import org.eclipse.osbp.xtext.topologydsl.Topology; |
| import org.eclipse.osbp.xtext.topologydsl.TopologyDSLPackage; |
| import org.eclipse.osbp.xtext.topologydsl.TopologyPackage; |
| import org.eclipse.xtext.common.types.JvmDeclaredType; |
| import org.eclipse.xtext.resource.IEObjectDescription; |
| import org.eclipse.xtext.util.Pair; |
| import org.eclipse.xtext.util.Tuples; |
| import org.osgi.framework.Bundle; |
| import org.osgi.framework.ServiceRegistration; |
| import org.osgi.framework.wiring.BundleWiring; |
| import org.osgi.service.component.ComponentContext; |
| import org.osgi.service.component.annotations.Activate; |
| import org.osgi.service.component.annotations.Component; |
| import org.osgi.service.component.annotations.Deactivate; |
| import org.slf4j.Logger; |
| import org.slf4j.LoggerFactory; |
| |
| /** |
| * The Class DSLBuilderParticipant. |
| */ |
| @SuppressWarnings("restriction") |
| @Component(service = { IBuilderParticipant.class }, property = { "service.ranking:Integer=1000" }) |
| public class DSLBuilderParticipant extends AbstractBuilderParticipant { |
| |
| /** The Constant log. */ |
| private final static Logger log = LoggerFactory.getLogger(DSLBuilderParticipant.class); |
| |
| /** The metadata builder service. */ |
| @Inject |
| private IMetadataBuilderService metadataBuilderService; |
| |
| /** The context. */ |
| private ComponentContext context; |
| |
| /** The dsl service register. */ |
| private ServiceRegistration<IDSLMetadataService> dslServiceRegister; |
| |
| /** The dsl bundles. */ |
| private Map<String, List<Bundle>> dslBundles = new HashMap<String, List<Bundle>>(); |
| |
| /** The translations. */ |
| private HashMap<String, Properties> translations = new HashMap<>(); |
| |
| /** |
| * Activate. |
| * |
| * @param context |
| * the context |
| */ |
| @Activate |
| protected void activate(ComponentContext context) { |
| this.context = context; |
| } |
| |
| /** |
| * Deactivate. |
| * |
| * @param context |
| * the context |
| */ |
| @Deactivate |
| protected void deactivate(ComponentContext context) { |
| metadataBuilderService.removeFromBundleSpace(context.getBundleContext().getBundle()); |
| this.context = null; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.osbp.xtext.builder.metadata.services.AbstractBuilderParticipant |
| * #getModels(org.osgi.framework.Bundle) |
| */ |
| @Override |
| public List<URL> getModels(Bundle suspect) { |
| List<URL> results = new ArrayList<URL>(); |
| BundleWiring wiring = suspect.adapt(BundleWiring.class); |
| suspect.getState(); |
| if (wiring == null) { |
| return results; |
| } |
| log.debug("visiting bundle " + suspect.getSymbolicName()); |
| // bundles containing model information |
| if (containsHeader(suspect, IExtenderConstants.FACTORY_MODEL_EXTENDER)) { |
| for (String extension : getExtensions(suspect, IExtenderConstants.FACTORY_MODEL_EXTENDER)) { |
| extension = extension.trim(); |
| if (!extension.isEmpty()) { |
| List<URL> entries = wiring.findEntries("/", "*." + extension, BundleWiring.LISTRESOURCES_RECURSE); |
| boolean hadEntries = false; |
| for (URL entry : entries) { |
| if (!entry.getPath().contains("META-INF")) { |
| log.debug("found entry " + entry.getPath() + " from bundle " + suspect.getSymbolicName()); |
| results.add(entry); |
| hadEntries = true; |
| } |
| } |
| if (hadEntries) { |
| if (dslBundles.containsKey(extension)) { |
| if (!dslBundles.get(extension).contains(suspect)) { |
| dslBundles.get(extension).add(suspect); |
| } |
| } else { |
| List<Bundle> list = new ArrayList<Bundle>(); |
| list.add(suspect); |
| dslBundles.put(extension, list); |
| } |
| loadTranslations(suspect); |
| } |
| } |
| } |
| } |
| // bundles necessary in runtime to be called dynamically via uri |
| if (containsHeader(suspect, IExtenderConstants.FACTORY_BUNDLE_EXTENDER)) { |
| for (String extension : getExtensions(suspect, IExtenderConstants.FACTORY_BUNDLE_EXTENDER)) { |
| extension = extension.trim(); |
| if (!extension.isEmpty()) { |
| if (dslBundles.containsKey(extension)) { |
| if (!dslBundles.get(extension).contains(suspect)) { |
| dslBundles.get(extension).add(suspect); |
| } |
| } else { |
| List<Bundle> list = new ArrayList<Bundle>(); |
| list.add(suspect); |
| dslBundles.put(extension, list); |
| } |
| } |
| } |
| } |
| // bundles containing translations |
| if (containsHeader(suspect, IExtenderConstants.FACTORY_TRANSLATIONS)) { |
| loadTranslations(suspect); |
| } |
| |
| Set<String> fragments = new HashSet<String>(); |
| for (Iterator<URL> iterator = results.iterator(); iterator.hasNext();) { |
| URL url = iterator.next(); |
| URI uri = URI.createURI(url.toString()); |
| if (fragments.contains(uri.lastSegment())) { |
| iterator.remove(); |
| } |
| fragments.add(uri.lastSegment()); |
| } |
| |
| return results; |
| } |
| |
| /** |
| * Load translations from a bundle. Tries to find an i18n directory with |
| * different language properties. |
| * |
| * @param suspect |
| * the suspect |
| */ |
| void loadTranslations(Bundle suspect) { |
| BundleWiring bundleWiring = suspect.adapt(BundleWiring.class); |
| ClassLoader classLoader = bundleWiring.getClassLoader(); |
| for (String language : ProductConfiguration.getLanguages().keySet()) { |
| Properties properties = null; |
| if (translations.containsKey(language)) { |
| properties = translations.get(language); |
| } else { |
| properties = new Properties(); |
| } |
| try { |
| ResourceBundle resource = ResourceBundle.getBundle("i18n.I18N", Locale.forLanguageTag(language), classLoader); |
| Enumeration<String> keyIterator = resource.getKeys(); |
| while (keyIterator.hasMoreElements()) { |
| String element = keyIterator.nextElement(); |
| String value = resource.getString(element); |
| properties.put(element, value); |
| } |
| if (!properties.isEmpty()) { |
| translations.put(language, properties); |
| } |
| } catch (MissingResourceException e) { |
| log.error("bundle "+suspect.getSymbolicName()+" has no resource for locale "+language); |
| } |
| } |
| } |
| |
| /** |
| * Returns true, if the bundle contains the header. |
| * |
| * @param bundle |
| * the bundle |
| * @param header |
| * the header |
| * @return true, if successful |
| */ |
| private boolean containsHeader(Bundle bundle, String header) { |
| Dictionary<String, String> headers = bundle.getHeaders(); |
| Enumeration<String> keys = headers.keys(); |
| while (keys.hasMoreElements()) { |
| String key = keys.nextElement(); |
| if (key.equals(header)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Gets the extensions. |
| * |
| * @param bundle |
| * the bundle |
| * @param header |
| * the header |
| * @return the extensions |
| */ |
| private List<String> getExtensions(Bundle bundle, String header) { |
| return new ArrayList<String>(Arrays.asList(bundle.getHeaders().get(header).split(","))); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.osbp.xtext.builder.metadata.services.AbstractBuilderParticipant |
| * #notifyLifecyle(org.eclipse.osbp.xtext.builder.metadata.services. |
| * IBuilderParticipant.LifecycleEvent) |
| */ |
| @Override |
| public void notifyLifecyle(LifecycleEvent event) { |
| if (event.getState() == IBuilderParticipant.LifecycleEvent.INITIALIZE) { |
| initialize(); |
| } else if (event.getState() == IBuilderParticipant.LifecycleEvent.BUNDLES_SCANNED) { |
| DSLMetadataService datatypesService = new DSLMetadataService(); |
| dslServiceRegister = context.getBundleContext().registerService(IDSLMetadataService.class, datatypesService, null); |
| |
| } else if (event.getState() == IBuilderParticipant.LifecycleEvent.DEACTIVATED) { |
| if (dslServiceRegister != null) { |
| dslServiceRegister.unregister(); |
| dslServiceRegister = null; |
| } |
| |
| if (metadataBuilderService != null) { |
| metadataBuilderService.removeFromBundleSpace(context.getBundleContext().getBundle()); |
| } |
| } |
| } |
| |
| /** |
| * Initialize. |
| */ |
| private void initialize() { |
| StandaloneGrammarsSetup.setup(); |
| metadataBuilderService.addToBundleSpace(context.getBundleContext().getBundle()); |
| } |
| |
| /** |
| * Provided as an OSGi service to returnmodels for the given qualified name. |
| */ |
| public class DSLMetadataService implements IDSLMetadataService { |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.osbp.ui.api.metadata.IDSLMetadataService#getMetadata( |
| * java.lang.String, org.eclipse.emf.ecore.EClass) |
| */ |
| @Override |
| public EObject getMetadata(String id, EClass eclass) { |
| EObject eObject = metadataBuilderService.getMetadata(id, eclass); |
| return eObject; |
| } |
| |
| @Override |
| public URL getResourceURL(EObject eObject, String resourceExtension, String extension) { |
| String fqn = NamingConventions.toFQN(eObject); |
| String resourcePath = fqn.replaceAll("\\.","/")+"."+resourceExtension; |
| if (dslBundles.containsKey(extension)) { |
| for (Bundle bundle : dslBundles.get(extension)) { |
| BundleWiring bundleWiring = bundle.adapt(BundleWiring.class); |
| ClassLoader classLoader = bundleWiring.getClassLoader(); |
| URL url = classLoader.getResource(resourcePath); |
| if(url != null) { |
| return url; |
| } |
| } |
| } |
| log.error("resource url "+resourcePath+" could not be found in bundles with extension "+extension); |
| return null; |
| } |
| |
| @Override |
| public Object getClassInstance(EObject eObject, String extension) { |
| String className = getClassName(eObject, ""); |
| if (dslBundles.containsKey(extension)) { |
| try { |
| for (Bundle bundle : dslBundles.get(extension)) { |
| BundleWiring bundleWiring = bundle.adapt(BundleWiring.class); |
| ClassLoader classLoader = bundleWiring.getClassLoader(); |
| Class<?> clz = classLoader.loadClass(className); |
| try { |
| return clz.newInstance(); |
| } catch (InstantiationException | IllegalAccessException e) { |
| log.error("class "+className+" could not be instantiated"); |
| if(e.getCause() != null) { |
| log.error("because "+e.getCause()); |
| } |
| } |
| } |
| } catch (ClassNotFoundException e) { |
| } |
| } |
| log.error("class "+className+" could not be found for extension "+extension); |
| return null; |
| } |
| /** |
| * Gets the class URI. As more than one bundle could carry a model |
| * instance, we must try to load the requested class to be sure to have |
| * the right bundle for this class. |
| * |
| * @param className |
| * the class name |
| * @param extension |
| * the extension |
| * @return the class URI as string |
| */ |
| @Override |
| public String getClassURI(String className, String extension) { |
| if (dslBundles.containsKey(extension)) { |
| for (Bundle bundle : dslBundles.get(extension)) { |
| try { |
| BundleWiring bundleWiring = bundle.adapt(BundleWiring.class); |
| ClassLoader classLoader = bundleWiring.getClassLoader(); |
| classLoader.loadClass(className); |
| return "bundleclass://" + bundle.getSymbolicName() + "/" + className; |
| } catch (ClassNotFoundException e) { |
| } |
| } |
| } |
| return null; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.osbp.ui.api.metadata.IDSLMetadataService#getClassURI( |
| * org.eclipse.emf.ecore.EObject, java.lang.String) |
| */ |
| @Override |
| public String getClassURI(EObject eObject, String kind) { |
| return getClassURI(getClassName(eObject, kind), NamingConventions.toExtension(eObject)); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.osbp.ui.api.metadata.IDSLMetadataService#getAllDescriptions |
| * (org.eclipse.emf.ecore.EClass) |
| */ |
| @Override |
| public Iterable<IEObjectDescription> getAllDescriptions(EClass eClass) { |
| return metadataBuilderService.getAllDescriptions(eClass); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.osbp.ui.api.metadata.IDSLMetadataService#getClassName |
| * (org.eclipse.emf.ecore.EObject, java.lang.String) |
| */ |
| @Override |
| public String getClassName(EObject eObject, String kind) { |
| return NamingConventions.toClassName(eObject); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.osbp.ui.api.metadata.IDSLMetadataService# |
| * getFullyQualifiedName(org.eclipse.emf.ecore.EObject) |
| */ |
| @Override |
| public String getFullyQualifiedName(EObject eObject) { |
| return NamingConventions.toFQN(eObject); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.osbp.ui.api.metadata.IDSLMetadataService#resolve(org. |
| * eclipse.emf.ecore.EObject) |
| */ |
| @Override |
| public EObject resolve(EObject proxy) { |
| return metadataBuilderService.resolve(proxy); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.osbp.ui.api.metadata.IDSLMetadataService#getAll(org.eclipse |
| * .emf.ecore.EClass) |
| */ |
| @Override |
| public Iterable<EObject> getAll(EClass eClass) { |
| return metadataBuilderService.getAll(eClass); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.osbp.ui.api.metadata.IDSLMetadataService#translate(java |
| * .lang.String, java.lang.String) |
| */ |
| @Override |
| public String translate(String localeString, String key) { |
| if (localeString == null) { |
| return key; |
| } |
| String k = I18NKeyGenerator.key(key); |
| // special solution for auto generated dto |
| if (k.endsWith("_dto")) { |
| k = k.substring(0, k.length() - 4); |
| } |
| String ranges = localeString + ";q=1.0"; |
| List<Locale.LanguageRange> languageRanges = Locale.LanguageRange.parse(ranges); |
| String localeTag = Locale.lookupTag(languageRanges, translations.keySet()); |
| Properties properties = translations.get(localeTag); |
| if (properties.containsKey(k)) { |
| String value = properties.getProperty(k); |
| return value; |
| } |
| return key; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.osbp.ui.api.metadata.IDSLMetadataService#getTranslations |
| * () |
| */ |
| @Override |
| public Map<String, Properties> getTranslations() { |
| return translations; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.osbp.ui.api.metadata.IDSLMetadataService#getTypeProvider |
| * () |
| */ |
| @Override |
| public BundleSpaceTypeProvider getTypeProvider() { |
| return metadataBuilderService.getTypeProvider(); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.osbp.ui.api.metadata.IDSLMetadataService#getAllTypeNames |
| * (java.lang.String, java.lang.String) |
| */ |
| @Override |
| public Map<String, String> getAllTypeNames(String localeTag, String typeName) { |
| HashMap<String, String> subTypesNames = new HashMap<>(); |
| subTypesNames.put(translate(localeTag, typeName.substring(typeName.lastIndexOf('.') + 1)), typeName); |
| JvmDeclaredType type = (JvmDeclaredType) metadataBuilderService.getTypeProvider().findTypeByName(typeName); |
| Set<JvmDeclaredType> subTypes = metadataBuilderService.findSubTypes(type); |
| for (JvmDeclaredType subType : subTypes) { |
| subTypesNames.put(translate(localeTag, subType.getSimpleName()), subType.getQualifiedName()); |
| } |
| return subTypesNames; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.osbp.ui.api.metadata.IDSLMetadataService#createType(java |
| * .lang.String) |
| */ |
| @Override |
| public Class<?> createType(String typeName) throws ClassNotFoundException { |
| return metadataBuilderService.getBundleSpace().forName(typeName); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.osbp.ui.api.metadata.IDSLMetadataService# |
| * getDslGrammarElements |
| * (org.eclipse.osbp.ui.api.metadata.IDSLMetadataService.DSLLiterals) |
| */ |
| @SuppressWarnings("rawtypes") |
| @Override |
| public List<Pair> getDslGrammarElementNames(IDSLMetadataService.DSLLiterals literal) { |
| List<Pair> result = new ArrayList<>(); |
| switch (literal) { |
| case PERSPECTIVES: |
| for (EObject obj : getAll(PerspectiveDslPackage.Literals.PERSPECTIVE)) { |
| Perspective perspective = ((Perspective) obj); |
| result.add(Tuples.pair(perspective.getName(), NamingConventions.getPerspectiveFQN(perspective))); |
| } |
| } |
| return result; |
| } |
| } |
| |
| /** |
| * The Class NamingConventions. |
| */ |
| private static class NamingConventions { |
| |
| /** |
| * To extension. |
| * |
| * @param eObject |
| * the e object |
| * @return the string |
| */ |
| public static String toExtension(EObject eObject) { |
| EPackage pkg = eObject.eClass().getEPackage(); |
| |
| if (pkg == ChartDSLPackage.eINSTANCE) { |
| return "chart"; |
| } else if (pkg == DialogDSLPackage.eINSTANCE) { |
| return "dialog"; |
| } else if (pkg == ReportDSLPackage.eINSTANCE) { |
| return "report"; |
| } else if (pkg == TableDSLPackage.eINSTANCE) { |
| return "table"; |
| } else if (pkg == TopologyDSLPackage.eINSTANCE) { |
| return "topology"; |
| } |
| |
| throw new IllegalArgumentException("No registered naming logic for " + eObject); |
| } |
| |
| /** |
| * To FQN. |
| * |
| * @param eObject |
| * the e object |
| * @return the string |
| */ |
| public static String toFQN(EObject eObject) { |
| if (eObject == null) { |
| return null; |
| } |
| |
| if (eObject instanceof Chart) { |
| return getChartFQN(eObject); |
| } else if (eObject instanceof Dialog) { |
| return getDialogFQN(eObject); |
| } else if (eObject instanceof LDto) { |
| return getDtoFQN(eObject); |
| } else if (eObject instanceof Report) { |
| return getReportFQN(eObject); |
| } else if (eObject instanceof Table) { |
| return getTableFQN(eObject); |
| } else if (eObject instanceof Topology) { |
| return getTopologyFQN(eObject); |
| } else if (eObject instanceof DatamartDefinition) { |
| return getDatamartFQN(eObject); |
| } |
| throw new IllegalArgumentException("No registered naming logic for " + eObject); |
| } |
| |
| /** |
| * To class name. |
| * |
| * @param eObject |
| * the e object |
| * @return the string |
| */ |
| public static String toClassName(EObject eObject) { |
| if (eObject == null) { |
| return null; |
| } |
| |
| if (eObject instanceof Chart) { |
| return getChartClassName(eObject); |
| } else if (eObject instanceof Dialog) { |
| return getDialogClassName(eObject); |
| } else if (eObject instanceof Report) { |
| return getReportClassName(eObject); |
| } else if (eObject instanceof Table) { |
| return getTableClassName(eObject); |
| } else if (eObject instanceof Organization) { |
| return getOrganizationClassName(eObject); |
| } else if (eObject instanceof Topology) { |
| return getTopologyClassName(eObject); |
| } else if (eObject instanceof DatamartDefinition) { |
| return getDatamartClassName(eObject); |
| } |
| throw new IllegalArgumentException("No registered naming logic for " + eObject); |
| } |
| |
| /** |
| * Gets the dto FQN. |
| * |
| * @param eObject |
| * the e object |
| * @return the dto FQN |
| */ |
| private static String getDtoFQN(EObject eObject) { |
| LDto dto = (LDto) eObject; |
| if (dto == null) { |
| return ""; |
| } |
| LTypedPackage pkg = (LTypedPackage) dto.eContainer(); |
| return pkg.getName() + "." + dto.getName(); |
| } |
| |
| /** |
| * Gets the table FQN. |
| * |
| * @param eObject |
| * the e object |
| * @return the table FQN |
| */ |
| private static String getTableFQN(EObject eObject) { |
| Table dto = (Table) eObject; |
| if (dto == null) { |
| return ""; |
| } |
| TablePackage pkg = (TablePackage) dto.eContainer(); |
| return pkg.getName() + "." + dto.getName(); |
| } |
| |
| /** |
| * Gets the chart FQN. |
| * |
| * @param eObject |
| * the e object |
| * @return the chart FQN |
| */ |
| private static String getChartFQN(EObject eObject) { |
| Chart dto = (Chart) eObject; |
| if (dto == null) { |
| return ""; |
| } |
| ChartPackage pkg = (ChartPackage) dto.eContainer(); |
| return pkg.getName() + "." + dto.getName(); |
| } |
| |
| /** |
| * Gets the report FQN. |
| * |
| * @param eObject |
| * the e object |
| * @return the report FQN |
| */ |
| private static String getReportFQN(EObject eObject) { |
| Report dto = (Report) eObject; |
| if (dto == null) { |
| return ""; |
| } |
| ReportPackage pkg = (ReportPackage) dto.eContainer(); |
| return pkg.getName() + "." + dto.getName(); |
| } |
| |
| /** |
| * Gets the dialog FQN. |
| * |
| * @param eObject |
| * the e object |
| * @return the dialog FQN |
| */ |
| private static String getDialogFQN(EObject eObject) { |
| Dialog dto = (Dialog) eObject; |
| if (dto == null) { |
| return ""; |
| } |
| DialogPackage pkg = (DialogPackage) dto.eContainer(); |
| return pkg.getName() + "." + dto.getName(); |
| } |
| |
| /** |
| * Gets the dialog FQN. |
| * |
| * @param eObject |
| * the e object |
| * @return the dialog FQN |
| */ |
| private static String getPerspectiveFQN(EObject eObject) { |
| Perspective perspective = (Perspective) eObject; |
| if (perspective == null) { |
| return ""; |
| } |
| PerspectivePackage pkg = (PerspectivePackage) perspective.eContainer(); |
| return pkg.getName() + "." + perspective.getName(); |
| } |
| |
| /** |
| * Gets the topology FQN. |
| * |
| * @param eObject |
| * the e object |
| * @return the topology FQN |
| */ |
| private static String getTopologyFQN(EObject eObject) { |
| Topology dto = (Topology) eObject; |
| if (dto == null) { |
| return ""; |
| } |
| TopologyPackage pkg = (TopologyPackage) dto.eContainer(); |
| return pkg.getName() + "." + dto.getName(); |
| } |
| |
| /** |
| * Gets the datamart FQN. |
| * |
| * @param eObject the e object |
| * @return the datamart FQN |
| */ |
| private static String getDatamartFQN(EObject eObject) { |
| DatamartDefinition datamart = (DatamartDefinition) eObject; |
| if (datamart == null) { |
| return ""; |
| } |
| DatamartPackage pkg = (DatamartPackage) datamart.eContainer(); |
| return pkg.getName() + "." + datamart.getName(); |
| } |
| |
| /** |
| * Gets the topology class name. |
| * |
| * @param eObject |
| * the e object |
| * @return the topology class name |
| */ |
| private static String getTopologyClassName(EObject eObject) { |
| return getTopologyFQN(eObject) + "Topology"; |
| } |
| |
| /** |
| * Gets the datamart class name. |
| * |
| * @param eObject the e object |
| * @return the datamart class name |
| */ |
| private static String getDatamartClassName(EObject eObject) { |
| return getDatamartFQN(eObject) + "Datamart"; |
| } |
| |
| /** |
| * Gets the report class name. |
| * |
| * @param eObject |
| * the e object |
| * @return the report class name |
| */ |
| private static String getReportClassName(EObject eObject) { |
| return getReportFQN(eObject) + "Report"; |
| } |
| |
| /** |
| * Gets the chart class name. |
| * |
| * @param eObject |
| * the e object |
| * @return the chart class name |
| */ |
| private static String getChartClassName(EObject eObject) { |
| return getChartFQN(eObject) + "Chart"; |
| } |
| |
| /** |
| * Gets the organization class name. |
| * |
| * @param eObject |
| * the e object |
| * @return the organization class name |
| */ |
| private static String getOrganizationClassName(EObject eObject) { |
| return getChartFQN(eObject) + "Organization"; |
| } |
| |
| /** |
| * Gets the table class name. |
| * |
| * @param eObject |
| * the e object |
| * @return the table class name |
| */ |
| private static String getTableClassName(EObject eObject) { |
| Table table = (Table) eObject; |
| if (table.getTabletype() instanceof TableGrid) { |
| return getTableFQN(eObject) + "Grid"; |
| } else { |
| return getTableFQN(eObject) + "Table"; |
| } |
| } |
| |
| /** |
| * Gets the dialog class name. |
| * |
| * @param eObject |
| * the e object |
| * @return the dialog class name |
| */ |
| private static String getDialogClassName(EObject eObject) { |
| return getDialogFQN(eObject) + "Dialog"; |
| } |
| } |
| |
| } |
