| /******************************************************************************* |
| * Copyright (c) 2013, 2019 Willink Transformations and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v2.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v20.html |
| * |
| * Contributors: |
| * E.D.Willink - Initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.ocl.pivot.uml.internal.resource; |
| |
| import java.util.List; |
| |
| import org.eclipse.emf.common.util.URI; |
| import org.eclipse.emf.ecore.EAnnotation; |
| import org.eclipse.emf.ecore.EClass; |
| import org.eclipse.emf.ecore.EClassifier; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.ecore.EOperation; |
| import org.eclipse.emf.ecore.EPackage; |
| import org.eclipse.emf.ecore.EParameter; |
| import org.eclipse.emf.ecore.EReference; |
| import org.eclipse.emf.ecore.EcorePackage; |
| import org.eclipse.emf.ecore.resource.Resource; |
| import org.eclipse.emf.ecore.resource.ResourceSet; |
| import org.eclipse.emf.ecore.util.EcoreUtil; |
| import org.eclipse.jdt.annotation.NonNull; |
| import org.eclipse.jdt.annotation.Nullable; |
| import org.eclipse.ocl.pivot.Element; |
| import org.eclipse.ocl.pivot.Model; |
| import org.eclipse.ocl.pivot.internal.resource.ASResourceFactory; |
| import org.eclipse.ocl.pivot.internal.resource.AbstractASResourceFactory; |
| import org.eclipse.ocl.pivot.internal.utilities.EnvironmentFactoryInternal; |
| import org.eclipse.ocl.pivot.internal.utilities.Technology; |
| import org.eclipse.ocl.pivot.resource.ASResource; |
| import org.eclipse.ocl.pivot.uml.UMLStandaloneSetup; |
| import org.eclipse.ocl.pivot.uml.internal.es2as.UML2AS; |
| import org.eclipse.ocl.pivot.uml.internal.utilities.UMLEcoreTechnology; |
| import org.eclipse.ocl.pivot.uml.internal.validation.UMLOCLEValidator; |
| import org.eclipse.ocl.pivot.utilities.NameUtil; |
| import org.eclipse.ocl.pivot.utilities.ParserException; |
| import org.eclipse.uml2.uml.Type; |
| import org.eclipse.uml2.uml.UMLPackage; |
| import org.eclipse.uml2.uml.resource.UMLResource; |
| import org.eclipse.uml2.uml.resource.XMI2UMLResource; |
| |
| public final class UMLASResourceFactory extends AbstractASResourceFactory |
| { |
| private static @Nullable UMLASResourceFactory INSTANCE; |
| |
| public static synchronized @NonNull UMLASResourceFactory getInstance() { |
| if (INSTANCE == null) { |
| // ASResourceFactoryContribution asResourceRegistry = ASResourceFactoryRegistry.INSTANCE.get(ASResource.UML_CONTENT_TYPE); |
| // if (asResourceRegistry != null) { |
| // INSTANCE = (UMLASResourceFactory) asResourceRegistry.getASResourceFactory(); // Create the registered singleton |
| // } |
| // else { |
| INSTANCE = new UMLASResourceFactory(); // Create our own singleton |
| // } |
| assert INSTANCE != null; |
| INSTANCE.install("uml", INSTANCE.getResourceClassName()); |
| } |
| assert INSTANCE != null; |
| return INSTANCE; |
| } |
| |
| public UMLASResourceFactory() { |
| super(ASResource.UML_CONTENT_TYPE, null); |
| } |
| |
| @Override |
| public void configureResourceSets(@Nullable ResourceSet asResourceSet, @NonNull ResourceSet csResourceSet) { |
| super.configureResourceSets(asResourceSet, csResourceSet); |
| if (asResourceSet != null) { |
| UML2AS.initializeUML(asResourceSet); |
| } |
| UML2AS.initializeUML(csResourceSet); |
| } |
| |
| @Override |
| public @NonNull Resource createResource(URI uri) { |
| assert uri != null; |
| ASResource asResource = new UMLASResourceImpl(uri, this); |
| configureResource(asResource); |
| return asResource; |
| } |
| |
| @Override |
| public @Nullable <T extends Element> T getASElement(@NonNull EnvironmentFactoryInternal environmentFactory, |
| @NonNull Class<T> pivotClass, @NonNull EObject eObject) throws ParserException { |
| Resource metamodel = eObject.eResource(); |
| if (metamodel == null) { |
| return null; |
| } |
| UML2AS uml2as = UML2AS.getAdapter(metamodel, environmentFactory); |
| uml2as.getASModel(); |
| EClass eClass = eObject.eClass(); |
| EPackage ePackage = eClass.getEPackage(); |
| if (ePackage == EcorePackage.eINSTANCE) { |
| if (eObject instanceof EOperation) { |
| EOperation eOperation = (EOperation)eObject; |
| org.eclipse.uml2.uml.Constraint umlConstraint = getConstraintForEOperation(environmentFactory, eOperation); |
| if (umlConstraint != null) { |
| eObject = umlConstraint; |
| } |
| } |
| else if (eObject instanceof EClass) { |
| EClass eStereotype = (EClass)eObject; |
| org.eclipse.uml2.uml.Stereotype umlStereotype = getStereotypeForEClass(environmentFactory, eStereotype); |
| if (umlStereotype != null) { |
| eObject = umlStereotype; |
| } |
| } |
| } |
| return uml2as.getCreated(pivotClass, eObject); |
| } |
| |
| @Override |
| public @NonNull ASResourceFactory getASResourceFactory() { |
| return getInstance(); |
| } |
| |
| protected org.eclipse.uml2.uml.Constraint getConstraintForEOperation(@NonNull EnvironmentFactoryInternal environmentFactory, @NonNull EOperation eOperation) { |
| if (EcoreUtil.isInvariant(eOperation)) { |
| EClass eContainingClass = eOperation.getEContainingClass(); |
| EAnnotation eAnnotation = eContainingClass.getEAnnotation("http://www.eclipse.org/uml2/2.0.0/UML"); // UMLUtil.UML2_UML_PACKAGE_2_0_NS_URI |
| if (eAnnotation != null) { |
| List<EObject> eReferences = eAnnotation.getReferences(); |
| if ((eReferences != null) && (eReferences.size() > 0)) { |
| EObject eReference = eReferences.get(0); |
| if (eReference instanceof org.eclipse.uml2.uml.Type) { |
| String operationName = environmentFactory.getTechnology().getOriginalName(eOperation); |
| org.eclipse.uml2.uml.Constraint umlConstraint = ((org.eclipse.uml2.uml.Classifier)eReference).getOwnedRule(operationName); |
| if (umlConstraint != null) { |
| return umlConstraint; |
| } |
| } |
| } |
| } |
| } |
| return null; |
| } |
| |
| @Override |
| public @Nullable EOperation getEOperation(@NonNull ASResource asResource, @NonNull EObject eObject) { |
| UMLASResourceImpl umlResource = (UMLASResourceImpl) asResource; |
| if (!(eObject instanceof org.eclipse.uml2.uml.Operation)) { |
| return null; |
| } |
| org.eclipse.uml2.uml.Operation umlOperation = (org.eclipse.uml2.uml.Operation)eObject; |
| org.eclipse.uml2.uml.Class umlClass = umlOperation.getClass_(); |
| if (umlClass == null) { |
| return null; |
| } |
| EClassifier eClassifier = umlResource.getEClassifier(umlClass); |
| if (eClassifier == null) { |
| return null; |
| } |
| if (!(eClassifier instanceof EClass)) { |
| return null; |
| } |
| String operationName = umlOperation.getName(); |
| if (operationName == null) { |
| return null; |
| } |
| List<org.eclipse.uml2.uml.Parameter> umlParameters = umlOperation.getOwnedParameters(); |
| int umlParameterCount = umlParameters.size(); |
| for (EOperation eOperation : ((EClass)eClassifier).getEOperations()) { |
| if (operationName.equals(eOperation.getName())) { |
| List<EParameter> eParameters = eOperation.getEParameters(); |
| int eParameterCount = eParameters.size(); |
| if (umlParameterCount >= eParameterCount) { |
| boolean parametersMatch = true; |
| int umlIndex = 0; |
| int eIndex = 0; |
| while ((eIndex < eParameterCount) && (umlIndex < umlParameterCount)) { |
| org.eclipse.uml2.uml.Parameter umlInParameter = null; |
| while (umlIndex < umlParameterCount) { |
| org.eclipse.uml2.uml.Parameter umlParameter = umlParameters.get(umlIndex++); |
| if (umlParameter.getDirection() == org.eclipse.uml2.uml.ParameterDirectionKind.IN_LITERAL) { |
| umlInParameter = umlParameter; |
| break; |
| } |
| } |
| if (umlInParameter == null) { |
| parametersMatch = false; |
| break; |
| } |
| EParameter eParameter = eParameters.get(eIndex++); |
| Type umlParameterType = umlInParameter.getType(); |
| EClassifier umlEParameterType = umlParameterType != null ? umlResource.getEClassifier(umlParameterType) : null; |
| EClassifier eParameterType = eParameter.getEType(); |
| if (umlEParameterType != eParameterType) { |
| parametersMatch = false; |
| break; |
| } |
| } |
| while (umlIndex < umlParameterCount) { |
| org.eclipse.uml2.uml.Parameter umlParameter = umlParameters.get(umlIndex++); |
| if (umlParameter.getDirection() == org.eclipse.uml2.uml.ParameterDirectionKind.IN_LITERAL) { |
| parametersMatch = false; |
| break; |
| } |
| } |
| if ((eIndex == eParameterCount) && (umlIndex == umlParameterCount) && parametersMatch) { |
| return eOperation; |
| } |
| } |
| } |
| } |
| return null; |
| } |
| |
| @Override |
| public @Nullable EReference getEReference(@NonNull ASResource asResource, @NonNull EObject eObject) { |
| UMLASResourceImpl umlResource = (UMLASResourceImpl) asResource; |
| if (!(eObject instanceof org.eclipse.uml2.uml.Property)) { |
| return null; |
| } |
| org.eclipse.uml2.uml.Property umlProperty = (org.eclipse.uml2.uml.Property)eObject; |
| org.eclipse.uml2.uml.Class umlClass = umlProperty.getClass_(); |
| if (umlClass == null) { |
| return null; |
| } |
| EClassifier eClassifier = umlResource.getEClassifier(umlClass); |
| if (eClassifier == null) { |
| return null; |
| } |
| if (!(eClassifier instanceof EClass)) { |
| return null; |
| } |
| String propertyName = umlProperty.getName(); |
| if (propertyName == null) { |
| return null; |
| } |
| for (EReference eReference : ((EClass)eClassifier).getEReferences()) { |
| if (propertyName.equals(eReference.getName())) { |
| return eReference; |
| } |
| } |
| return null; |
| } |
| |
| @Override |
| public @NonNull Technology getTechnology() { |
| UMLStandaloneSetup.assertInitialized(); |
| return UMLEcoreTechnology.INSTANCE; |
| } |
| |
| @Override |
| public @Nullable String getMetamodelNsURI(@NonNull EPackage ePackage) { |
| if (ePackage instanceof UMLPackage) { |
| return XMI2UMLResource.UML_METAMODEL_NS_URI; |
| } |
| if (ePackage.getClass().getName().startsWith(UMLPackage.class.getPackage().getName())) { // StandardPackage/L2Package/L3Package |
| return XMI2UMLResource.UML_METAMODEL_NS_URI; |
| } |
| return null; |
| } |
| |
| @Override |
| public @Nullable URI getPackageURI(@NonNull EObject eObject) { |
| if (eObject instanceof org.eclipse.uml2.uml.Package) { |
| String uri = ((org.eclipse.uml2.uml.Package)eObject).getURI(); |
| if (uri != null) { |
| return URI.createURI(uri); |
| } |
| } |
| return null; |
| } |
| |
| @Override |
| public @Nullable Integer getPriority() { |
| return 200; |
| } |
| |
| @Override |
| public @Nullable String getResourceClassName() { |
| return UMLResource.class.getName(); |
| } |
| |
| protected org.eclipse.uml2.uml.Stereotype getStereotypeForEClass(@NonNull EnvironmentFactoryInternal environmentFactory, @NonNull EClass eClass) { |
| EObject eAnnotationParent = null; |
| for (EObject eObject = eClass; true; eObject = eObject.eContainer()) { |
| if (eObject == null) { |
| return null; |
| } |
| if (eObject instanceof EAnnotation) { |
| eAnnotationParent = eObject.eContainer(); |
| break; |
| } |
| } |
| if (!(eAnnotationParent instanceof org.eclipse.uml2.uml.Profile)) { |
| return null; |
| } |
| org.eclipse.uml2.uml.Profile umlProfile = (org.eclipse.uml2.uml.Profile)eAnnotationParent; // FIXME could there be hierarchy ? |
| org.eclipse.uml2.uml.Stereotype umlStereotype = umlProfile.getOwnedStereotype(NameUtil.getOriginalName(eClass)); |
| return umlStereotype; |
| } |
| |
| @Override |
| public @Nullable Element importFromResource(@NonNull EnvironmentFactoryInternal environmentFactory, @NonNull Resource umlResource, @Nullable URI uri) throws ParserException { |
| UML2AS conversion = UML2AS.getAdapter(umlResource, environmentFactory); |
| conversion.setUMLURI(uri != null ? uri.trimFragment() : null); |
| Model pivotModel = conversion.getASModel(); |
| String uriFragment = uri != null ? uri.fragment() : null; |
| if (uriFragment == null) { |
| return pivotModel; |
| } |
| else { |
| EObject eObject = umlResource.getEObject(uriFragment); |
| if (eObject == null) { |
| return null; |
| } |
| return conversion.getCreated(Element.class, eObject); |
| } |
| } |
| |
| @Override |
| public void initializeEValidatorRegistry(org.eclipse.emf.ecore.EValidator.@NonNull Registry eValidatorRegistry) { |
| eValidatorRegistry.put(UMLPackage.eINSTANCE, UMLOCLEValidator.NO_NEW_LINES); |
| } |
| } |
