/*******************************************************************************
* Copyright (c) 2010, 2015 Willink Transformations and others.
* 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:
* E.D.Willink - initial API and implementation
* E.D.Willink (CEA LIST) - Bug 388493, 399252, 399378
*******************************************************************************/
package org.eclipse.ocl.pivot.uml.internal.es2as;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import org.apache.log4j.Logger;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EAnnotation;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EModelElement;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EPackage;
import org.eclipse.emf.ecore.EStructuralFeature;
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.FeatureMap;
import org.eclipse.emf.ecore.util.FeatureMap.Entry;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.eclipse.ocl.pivot.AssociationClass;
import org.eclipse.ocl.pivot.Comment;
import org.eclipse.ocl.pivot.ConnectionPointReference;
import org.eclipse.ocl.pivot.Constraint;
import org.eclipse.ocl.pivot.DataType;
import org.eclipse.ocl.pivot.DynamicBehavior;
import org.eclipse.ocl.pivot.DynamicElement;
import org.eclipse.ocl.pivot.DynamicType;
import org.eclipse.ocl.pivot.DynamicValueSpecification;
import org.eclipse.ocl.pivot.Element;
import org.eclipse.ocl.pivot.Enumeration;
import org.eclipse.ocl.pivot.EnumerationLiteral;
import org.eclipse.ocl.pivot.ExpressionInOCL;
import org.eclipse.ocl.pivot.FinalState;
import org.eclipse.ocl.pivot.InstanceSpecification;
import org.eclipse.ocl.pivot.NamedElement;
import org.eclipse.ocl.pivot.Namespace;
import org.eclipse.ocl.pivot.Operation;
import org.eclipse.ocl.pivot.Parameter;
import org.eclipse.ocl.pivot.PivotFactory;
import org.eclipse.ocl.pivot.PivotPackage;
import org.eclipse.ocl.pivot.PrimitiveType;
import org.eclipse.ocl.pivot.Profile;
import org.eclipse.ocl.pivot.ProfileApplication;
import org.eclipse.ocl.pivot.Property;
import org.eclipse.ocl.pivot.Pseudostate;
import org.eclipse.ocl.pivot.Region;
import org.eclipse.ocl.pivot.Signal;
import org.eclipse.ocl.pivot.Slot;
import org.eclipse.ocl.pivot.State;
import org.eclipse.ocl.pivot.StateMachine;
import org.eclipse.ocl.pivot.Stereotype;
import org.eclipse.ocl.pivot.StereotypeExtender;
import org.eclipse.ocl.pivot.TemplateParameter;
import org.eclipse.ocl.pivot.TemplateSignature;
import org.eclipse.ocl.pivot.TemplateableElement;
import org.eclipse.ocl.pivot.Transition;
import org.eclipse.ocl.pivot.Type;
import org.eclipse.ocl.pivot.TypedElement;
import org.eclipse.ocl.pivot.ids.IdManager;
import org.eclipse.ocl.pivot.ids.TypeId;
import org.eclipse.ocl.pivot.internal.PackageImpl;
import org.eclipse.ocl.pivot.internal.complete.StandardLibraryInternal;
import org.eclipse.ocl.pivot.internal.ecore.es2as.Ecore2ASDeclarationSwitch;
import org.eclipse.ocl.pivot.internal.manager.PivotMetamodelManager;
import org.eclipse.ocl.pivot.utilities.PivotConstants;
import org.eclipse.ocl.pivot.values.IntegerValue;
import org.eclipse.ocl.pivot.values.RealValue;
import org.eclipse.uml2.common.util.UML2Util;
import org.eclipse.uml2.uml.UMLPackage;
import org.eclipse.uml2.uml.resource.UMLResource;
import org.eclipse.uml2.uml.util.UMLSwitch;
import org.eclipse.uml2.uml.util.UMLUtil;
public class UML2ASDeclarationSwitch extends UMLSwitch<Object>
{
@SuppressWarnings("null")
private static final @NonNull Logger logger = Logger.getLogger(UML2ASDeclarationSwitch.class);
protected final @NonNull Ecore2ASDeclarationSwitch ecoreSwitch;
protected final @NonNull UML2AS converter;
protected final @NonNull PivotMetamodelManager metamodelManager;
protected final @NonNull StandardLibraryInternal standardLibrary;
public UML2ASDeclarationSwitch(@NonNull UML2AS converter) {
this.converter = converter;
this.ecoreSwitch = new Ecore2ASDeclarationSwitch(converter);
this.metamodelManager = converter.getMetamodelManager();
this.standardLibrary = converter.getStandardLibrary();
}
@Override
public Object caseAssociation(org.eclipse.uml2.uml.Association umlAssociation) {
assert umlAssociation != null;
//
// It would be nice to create Pivot AssociationClass instances lazily, but UML defines these objects and it is hard
// to be lazy; the proxies could be nearly as costly as their trurths.
//
AssociationClass asAssociationClass = converter.refreshNamedElement(org.eclipse.ocl.pivot.AssociationClass.class, PivotPackage.Literals.ASSOCIATION_CLASS, umlAssociation);
// System.out.println("Association " + umlAssociation.getName() + ", " + NameUtil.debugSimpleName(umlAssociation) + " => " + NameUtil.debugSimpleName(asAssociationClass));
copyNamedElement(asAssociationClass, umlAssociation);
converter.queueReference(umlAssociation); // properties, superClasses
converter.queueUse(umlAssociation); // redefinitions, constraints
return asAssociationClass;
}
@Override
public Object caseAssociationClass(org.eclipse.uml2.uml.AssociationClass umlAssociationClass) {
assert umlAssociationClass != null;
AssociationClass asAssociationClass = converter.refreshNamedElement(AssociationClass.class, PivotPackage.Literals.ASSOCIATION_CLASS, umlAssociationClass);
// System.out.println("AssociationClass " + umlAssociationClass.getName() + " => " + NameUtil.debugSimpleName(asAssociationClass));
copyClass(asAssociationClass, umlAssociationClass);
converter.queueReference(umlAssociationClass); // properties, superClasses
converter.queueUse(umlAssociationClass); // redefinitions, constraints
return asAssociationClass;
}
@Override
public Object caseBehavior(org.eclipse.uml2.uml.Behavior umlBehavior) {
assert umlBehavior != null;
DynamicBehavior pivotElement = converter.refreshElement(DynamicBehavior.class, PivotPackage.Literals.DYNAMIC_BEHAVIOR, umlBehavior);
pivotElement.setName(((org.eclipse.uml2.uml.Type)umlBehavior).getName());
doSwitchAll(pivotElement.getOwnedAnnotations(), ((org.eclipse.uml2.uml.Element)umlBehavior).getOwnedElements(), null);
EClass umlMetaClass = umlBehavior.eClass();
Type metaType = metamodelManager.getASOfEcore(Type.class, umlMetaClass);
pivotElement.setMetaType(metaType);
return pivotElement;
}
@Override
public org.eclipse.ocl.pivot.Class caseClass(org.eclipse.uml2.uml.Class umlClass) {
assert umlClass != null;
org.eclipse.ocl.pivot.Class pivotElement = converter.refreshNamedElement(org.eclipse.ocl.pivot.Class.class, PivotPackage.Literals.CLASS, umlClass);
// System.out.println("Class " + umlClass.getName() + " => " + ClassUtil.debugSimpleName(pivotElement));
copyClass(pivotElement, umlClass);
converter.queueReference(umlClass); // superClasses
return pivotElement;
}
@Override
public Object caseClassifierTemplateParameter(org.eclipse.uml2.uml.ClassifierTemplateParameter umlTemplateParameter) {
assert umlTemplateParameter != null;
@SuppressWarnings("null") org.eclipse.uml2.uml.@NonNull Class umlParameterClass = (org.eclipse.uml2.uml.Class) umlTemplateParameter.getParameteredElement();
TemplateParameter pivotElement = converter.refreshElement(TemplateParameter.class, PivotPackage.Literals.TEMPLATE_PARAMETER, umlTemplateParameter);
// TemplateParameter pivotTemplateParameter = converter.refreshNamedElement(org.eclipse.ocl.pivot.Class.class, PivotPackage.Literals.CLASS, umlTemplateParameter);
// setOriginalMapping(pivotElement, umlTemplateParameter);
// String name = umlTemplateParameter.getName();
pivotElement.setName(umlParameterClass.getName());
// TemplateParameter templateParameter = pivotElement.isTemplateParameter();
// if (templateParameter == null) {
// templateParameter = PivotFactory.eINSTANCE.createTemplateParameter();
// templateParameter.setOwnedParameteredElement(pivotElement);
// converter.setOriginalMapping(templateParameter, umlTemplateParameter);
// }
converter.setOriginalMapping(pivotElement, umlTemplateParameter);
// List<EGenericType> eBounds = umlTemplateParameter.getEBounds();
// if (!eBounds.isEmpty()) {
// doSwitchAll(eBounds);
// converter.queueReference(umlTemplateParameter);
// }
return pivotElement;
}
@Override
public Comment caseComment(org.eclipse.uml2.uml.Comment umlComment) {
assert umlComment != null;
Comment pivotElement = converter.refreshElement(Comment.class, PivotPackage.Literals.COMMENT, umlComment);
pivotElement.setBody(umlComment.getBody());
copyComments(pivotElement, umlComment);
return pivotElement;
}
@Override
public ConnectionPointReference caseConnectionPointReference(org.eclipse.uml2.uml.ConnectionPointReference umlConnectionPointReference) {
assert umlConnectionPointReference != null;
ConnectionPointReference pivotElement = converter.refreshNamedElement(ConnectionPointReference.class, PivotPackage.Literals.CONNECTION_POINT_REFERENCE, umlConnectionPointReference);
copyNamedElement(pivotElement, umlConnectionPointReference);
return pivotElement;
}
@Override
public Constraint caseConstraint(org.eclipse.uml2.uml.Constraint umlConstraint) {
assert umlConstraint != null;
Constraint pivotElement = converter.refreshNamedElement(Constraint.class, PivotPackage.Literals.CONSTRAINT, umlConstraint);
copyNamedElement(pivotElement, umlConstraint);
converter.queueUse(umlConstraint);
return pivotElement;
}
@Override
public DataType caseDataType(org.eclipse.uml2.uml.DataType umlDataType) {
assert umlDataType != null;
DataType pivotElement = converter.refreshNamedElement(DataType.class, PivotPackage.Literals.DATA_TYPE, umlDataType);
copyDataTypeOrEnum(pivotElement, umlDataType);
@SuppressWarnings("null") @NonNull List<org.eclipse.uml2.uml.Property> umlAttributes = umlDataType.getAttributes();
doSwitchAll(umlAttributes);
// converter.addProperties(umlAttributes, null);
pivotElement.getSuperClasses().add(standardLibrary.getOclAnyType());
return pivotElement;
}
@Override
public Enumeration caseEnumeration(org.eclipse.uml2.uml.Enumeration umlEnumeration) {
assert umlEnumeration != null;
Enumeration pivotElement = converter.refreshNamedElement(Enumeration.class, PivotPackage.Literals.ENUMERATION, umlEnumeration);
copyDataTypeOrEnum(pivotElement, umlEnumeration);
doSwitchAll(pivotElement.getOwnedLiterals(), umlEnumeration.getOwnedLiterals(), null);
pivotElement.getSuperClasses().add(((StandardLibraryInternal.StandardLibraryExtension)standardLibrary).getOclEnumerationType());
return pivotElement;
}
@Override
public EnumerationLiteral caseEnumerationLiteral(org.eclipse.uml2.uml.EnumerationLiteral umlEnumLiteral) {
assert umlEnumLiteral != null;
EnumerationLiteral pivotElement = converter.refreshNamedElement(EnumerationLiteral.class,
PivotPackage.Literals.ENUMERATION_LITERAL, umlEnumLiteral);
copyNamedElement(pivotElement, umlEnumLiteral);
// if (eEnumLiteral.eIsSet(EcorePackage.Literals.EENUM_LITERAL__VALUE)) {
// pivotElement.setValue(BigInteger.valueOf(eEnumLiteral.getValue()));
// }
// else {
// pivotElement.eUnset(PivotPackage.Literals.ENUMERATION_LITERAL__VALUE);
// }
// String literal = basicGet(eObject, EcorePackage.Literals.EENUM_LITERAL__LITERAL, String.class);
// Enumerator instance = eEnumLiteral.getInstance();
// if (literal != null) {
/* AnnotationCS csAnnotation = PivotFactory.eINSTANCE.createAnnotationCS();
csAnnotation.setIdSource(EcorePackage.eNS_URI);
DetailCS csDetail = PivotFactory.eINSTANCE.createDetailCS();
csDetail.setIdName("literal");
copyDetailLines(csDetail.getValue(), literal);
csAnnotation.getDetails().add(csDetail);
pivotElement.getAnnotations().add(csAnnotation); */
// }
return pivotElement;
}
@Override
public Object caseExtension(org.eclipse.uml2.uml.Extension umlExtension) {
assert umlExtension != null;
/* Redundant while NsURI set at start of convert
org.eclipse.uml2.uml.Class metaclass = umlExtension.getMetaclass();
if (metaclass != null) {
org.eclipse.uml2.uml.Package metapackage = metaclass.getPackage();
if (metapackage != null) {
String metaNsURI = metapackage.getURI();
if (metaNsURI != null) {
metamodelManager.setMetamodelNsURI(metaNsURI);
}
}
} */
StereotypeExtender asTypeExtension = converter.refreshElement(StereotypeExtender.class, PivotPackage.Literals.STEREOTYPE_EXTENDER, umlExtension);
converter.copyModelElement(asTypeExtension, umlExtension);
// converter.queueReference(umlProfileApplication);
// converter.addProfileApplication(umlProfileApplication);
boolean isRequired = false;
for (org.eclipse.uml2.uml.Property umlProperty : umlExtension.getOwnedEnds()) {
@SuppressWarnings("unused")Object eObject = doSwitch(umlProperty);
int lower = umlProperty.getLower();
if (lower == 1) {
isRequired = false;
}
}
asTypeExtension.setIsRequired(isRequired);
org.eclipse.uml2.uml.Class umlMetaclass = umlExtension.getMetaclass();
if (umlMetaclass != null) {
org.eclipse.uml2.uml.Package umlMetapackage = umlMetaclass.getPackage();
if (umlMetapackage != null) {
String nsURI = umlMetapackage.getURI();
if (nsURI != null) {
metamodelManager.getCompleteModel().addPackageURI2completeURI(nsURI, PivotConstants.UML_METAMODEL_NAME);
}
converter.addImportedPackage(umlMetapackage);
}
}
converter.queueReference(umlExtension); // stereotype, type, opposites
return asTypeExtension;
}
/* @Override
public Object caseExtensionEnd(ExtensionEnd umlExtensionEnd) {
int lower = umlExtensionEnd.getLower();
if (lower == 1) {
// converter.addRequiredExtensionEnd(umlExtensionEnd);
}
return this;
} */
@Override
public FinalState caseFinalState(org.eclipse.uml2.uml.FinalState umlState) {
assert umlState != null;
FinalState pivotElement = converter.refreshNamedElement(FinalState.class, PivotPackage.Literals.FINAL_STATE, umlState);
copyState(pivotElement, umlState);
return pivotElement;
}
@Override
public InstanceSpecification caseInstanceSpecification(org.eclipse.uml2.uml.InstanceSpecification umlInstanceSpecification) {
assert umlInstanceSpecification != null;
InstanceSpecification pivotElement = converter.refreshNamedElement(InstanceSpecification.class, PivotPackage.Literals.INSTANCE_SPECIFICATION, umlInstanceSpecification);
doSwitchAll(pivotElement.getOwnedSlots(), umlInstanceSpecification.getSlots(), null);
// converter.queueReference(umlInstanceSpecification); // classifiers
return pivotElement;
}
@Override
public org.eclipse.ocl.pivot.Class caseInterface(org.eclipse.uml2.uml.Interface umlInterface) {
assert umlInterface != null;
org.eclipse.ocl.pivot.Class pivotElement = converter.refreshNamedElement(org.eclipse.ocl.pivot.Class.class, PivotPackage.Literals.CLASS, umlInterface);
pivotElement.setIsInterface(true);
copyClassOrInterface(pivotElement, umlInterface);
return pivotElement;
}
@Override
public Object caseOpaqueExpression(org.eclipse.uml2.uml.OpaqueExpression umlExpression) {
assert umlExpression != null;
if (umlExpression.eContainer() instanceof org.eclipse.uml2.uml.Constraint) {
converter.queueUse(umlExpression);
return this;
}
else {
ExpressionInOCL pivotElement = converter.refreshOpaqueExpression(umlExpression);
return pivotElement;
}
}
@Override
public Operation caseOperation(org.eclipse.uml2.uml.Operation umlOperation) {
assert umlOperation != null;
Operation pivotElement = converter.refreshNamedElement(Operation.class, PivotPackage.Literals.OPERATION, umlOperation);
copyNamedElement(pivotElement, umlOperation);
for (org.eclipse.uml2.uml.Parameter umlParameter : umlOperation.getOwnedParameters()) {
org.eclipse.uml2.uml.ParameterDirectionKind direction = umlParameter.getDirection();
if (direction == org.eclipse.uml2.uml.ParameterDirectionKind.IN_LITERAL) {
Parameter pivotObject = (Parameter) doSwitch(umlParameter);
if (pivotObject != null) {
pivotElement.getOwnedParameters().add(pivotObject);
}
}
}
copyTemplateSignature(pivotElement, umlOperation.getOwnedTemplateSignature());
// doSwitchAll(umlOperation.getEGenericExceptions());
converter.queueUse(umlOperation); // For exceptions
return pivotElement;
}
@Override
public org.eclipse.ocl.pivot.Package casePackage(org.eclipse.uml2.uml.Package umlPackage) {
assert umlPackage != null;
org.eclipse.ocl.pivot.Package pivotElement = converter.refreshNamedElement(org.eclipse.ocl.pivot.Package.class, PivotPackage.Literals.PACKAGE, umlPackage);
copyPackage(pivotElement, umlPackage);
// if (pivotElement.getName() == null) {
// pivotElement.setName("anon_" + Integer.toHexString(System.identityHashCode(umlPackage)));
// logger.error("Anonymous package named as '" + pivotElement.getName() + "'");
// }
return pivotElement;
}
@Override
public Parameter caseParameter(org.eclipse.uml2.uml.Parameter eObject) {
assert eObject != null;
Parameter pivotElement = converter.refreshNamedElement(Parameter.class, PivotPackage.Literals.PARAMETER, eObject);
copyTypedElement(pivotElement, eObject, null);
return pivotElement;
}
@Override
public DataType casePrimitiveType(org.eclipse.uml2.uml.PrimitiveType umlPrimitiveType) {
assert umlPrimitiveType != null;
PrimitiveType asPrimitiveType = getPrimitiveTypeByName(umlPrimitiveType);
if (asPrimitiveType == null) {
asPrimitiveType = getPrimitiveTypeByOCLStereotype(umlPrimitiveType);
}
// if (pivotElement != null) {
// converter.addCreated(umlPrimitiveType, pivotElement);
// }
org.eclipse.uml2.uml.Stereotype ecoreStereotype = null;
DataType pivotElement;
if (asPrimitiveType == standardLibrary.getBooleanType()) {
pivotElement = converter.refreshNamedElement(PrimitiveType.class, PivotPackage.Literals.PRIMITIVE_TYPE, umlPrimitiveType);
}
else if (asPrimitiveType == standardLibrary.getIntegerType()) {
pivotElement = converter.refreshNamedElement(PrimitiveType.class, PivotPackage.Literals.PRIMITIVE_TYPE, umlPrimitiveType);
}
else if (asPrimitiveType == standardLibrary.getRealType()) {
pivotElement = converter.refreshNamedElement(PrimitiveType.class, PivotPackage.Literals.PRIMITIVE_TYPE, umlPrimitiveType);
}
else if (asPrimitiveType == standardLibrary.getStringType()) {
pivotElement = converter.refreshNamedElement(PrimitiveType.class, PivotPackage.Literals.PRIMITIVE_TYPE, umlPrimitiveType);
}
else if (asPrimitiveType == standardLibrary.getUnlimitedNaturalType()) {
pivotElement = converter.refreshNamedElement(PrimitiveType.class, PivotPackage.Literals.PRIMITIVE_TYPE, umlPrimitiveType);
}
else {
ecoreStereotype = umlPrimitiveType.getAppliedStereotype("Ecore::EDataType");
if (ecoreStereotype == null) {
ecoreStereotype = umlPrimitiveType.getAppliedStereotype("Ecore::EClassifier");
}
if (ecoreStereotype != null) {
pivotElement = converter.refreshNamedElement(DataType.class, PivotPackage.Literals.DATA_TYPE, umlPrimitiveType);
}
else {
pivotElement = converter.refreshNamedElement(PrimitiveType.class, PivotPackage.Literals.PRIMITIVE_TYPE, umlPrimitiveType);
}
}
if (asPrimitiveType != null) {
// @SuppressWarnings("unused")TypeServer typeServer1 = metamodelManager.getTypeServer(asPrimitiveType);
// @SuppressWarnings("unused")TypeServer typeServer2 = metamodelManager.getTypeServer(pivotElement);
// pivotElement.setBehavioralClass(asPrimitiveType);
org.eclipse.uml2.uml.Package umlPackage = umlPrimitiveType.getPackage();
if (umlPackage != null) {
String nsURI = umlPackage.getURI();
if (nsURI != null) {
// metamodelManager.getPackageManager().addPackageNsURISynonym(nsURI, PackageId.METAMODEL_NAME);
}
}
}
else {
// System.out.println("unknown PrimitiveType " + umlPrimitiveType);
}
copyClassifier(pivotElement, umlPrimitiveType);
String instanceClassName = null;
PrimitiveType behavioralClass = asPrimitiveType;
if (ecoreStereotype != null) {
Object object = umlPrimitiveType.getValue(ecoreStereotype, "instanceClassName");
if (object instanceof String) {
instanceClassName = (String) object;
behavioralClass = getPrimitiveTypeByEcoreStereotype(ecoreStereotype, instanceClassName);
}
}
pivotElement.setInstanceClassName(instanceClassName);
pivotElement.setBehavioralClass(behavioralClass);
return pivotElement;
}
@Override
public Object caseProfile(org.eclipse.uml2.uml.Profile umlProfile) {
assert umlProfile != null;
Profile pivotElement = converter.refreshNamedElement(Profile.class, PivotPackage.Literals.PROFILE, umlProfile);
copyPackage(pivotElement, umlProfile);
return pivotElement;
}
@Override
public Object caseProfileApplication(org.eclipse.uml2.uml.ProfileApplication umlProfileApplication) {
assert umlProfileApplication != null;
ProfileApplication pivotElement = converter.refreshElement(ProfileApplication.class, PivotPackage.Literals.PROFILE_APPLICATION, umlProfileApplication);
converter.copyModelElement(pivotElement, umlProfileApplication);
converter.queueReference(umlProfileApplication); // Resolve Profile reference
return pivotElement;
}
@Override
public Object caseProperty(org.eclipse.uml2.uml.Property umlProperty) {
assert umlProperty != null;
org.eclipse.uml2.uml.Association umlAssociation = umlProperty.getAssociation();
if (umlAssociation != null) {
if (umlAssociation instanceof org.eclipse.uml2.uml.Extension) {
// FIXME regularize by handling Extension properties as part of the Extension
}
else {
return this; // Association Properties are handled by the Association
}
}
// if ((umlProperty.getName() != null) && umlProperty.getName().startsWith(UML2AS.STEREOTYPE_BASE_PREFIX)) {
// System.out.println("Got it");
// }
Property pivotElement = converter.refreshNamedElement(Property.class, PivotPackage.Literals.PROPERTY, umlProperty);
// System.out.println("Property " + ((org.eclipse.uml2.uml.NamedElement)umlProperty.eContainer()).getName() + "::" + umlProperty.getName() + " => " + ClassUtil.debugSimpleName(pivotElement));
copyProperty(pivotElement, umlProperty, null);
// NB MDT/UML2's base_XXX/extension_YYY are spurious composites
@SuppressWarnings("unused")org.eclipse.uml2.uml.Element owner = umlProperty.getOwner();
boolean isComposer = true; //(owner instanceof org.eclipse.uml2.uml.Classifier) && !(owner instanceof org.eclipse.uml2.uml.Association);
pivotElement.setIsComposite(isComposer && umlProperty.isComposite());
pivotElement.setIsImplicit(!isComposer);
// pivotElement.setIsID(umlProperty.isID());
// pivotElement.setIsResolveProxies(umlProperty.isResolveProxies());
// converter.addProperty(umlProperty);
converter.queueReference(umlProperty); // type
converter.queueUse(umlProperty); // Defer
return pivotElement;
}
@Override
public Pseudostate casePseudostate(org.eclipse.uml2.uml.Pseudostate umlPseudostate) {
assert umlPseudostate != null;
Pseudostate pivotElement = converter.refreshNamedElement(Pseudostate.class, PivotPackage.Literals.PSEUDOSTATE, umlPseudostate);
copyNamedElement(pivotElement, umlPseudostate);
return pivotElement;
}
@Override
public Region caseRegion(org.eclipse.uml2.uml.Region umlRegion) {
assert umlRegion != null;
Region pivotElement = converter.refreshNamedElement(Region.class, PivotPackage.Literals.REGION, umlRegion);
copyNamespace(pivotElement, umlRegion);
doSwitchAll(pivotElement.getOwnedSubvertexes(), umlRegion.getSubvertices(), null);
doSwitchAll(pivotElement.getOwnedTransitions(), umlRegion.getTransitions(), null);
return pivotElement;
}
/**
* @since 1.1
*/
@Override
public Signal caseSignal(org.eclipse.uml2.uml.Signal umlSignal) {
assert umlSignal != null;
Signal pivotElement = converter.refreshNamedElement(Signal.class, PivotPackage.Literals.SIGNAL, umlSignal);
copyClassOrInterface(pivotElement, umlSignal);
converter.queueReference(umlSignal); // superClasses
return pivotElement;
}
@Override
public Slot caseSlot(org.eclipse.uml2.uml.Slot umlSlot) {
assert umlSlot != null;
Slot pivotElement = converter.refreshElement(Slot.class, PivotPackage.Literals.SLOT, umlSlot);
doSwitchAll(pivotElement.getOwnedValues(), umlSlot.getValues(), null);
converter.setOriginalMapping(pivotElement, umlSlot);
converter.queueReference(umlSlot); // definingFeature
return pivotElement;
}
@Override
public State caseState(org.eclipse.uml2.uml.State umlState) {
assert umlState != null;
State pivotElement = converter.refreshNamedElement(State.class, PivotPackage.Literals.STATE, umlState);
copyState(pivotElement, umlState);
return pivotElement;
}
@Override
public StateMachine caseStateMachine(org.eclipse.uml2.uml.StateMachine umlStateMachine) {
assert umlStateMachine != null;
StateMachine pivotElement = converter.refreshNamedElement(StateMachine.class, PivotPackage.Literals.STATE_MACHINE, umlStateMachine);
copyClass(pivotElement, umlStateMachine);
doSwitchAll(pivotElement.getOwnedRegions(), umlStateMachine.getRegions(), null);
return pivotElement;
}
@Override
public Stereotype caseStereotype(org.eclipse.uml2.uml.Stereotype umlStereotype) {
assert umlStereotype != null;
Stereotype pivotElement = converter.refreshNamedElement(Stereotype.class, PivotPackage.Literals.STEREOTYPE, umlStereotype);
copyClass(pivotElement, umlStereotype);
converter.queueReference(umlStereotype); // superClasses
return pivotElement;
}
@Override
public Transition caseTransition(org.eclipse.uml2.uml.Transition umlTransition) {
assert umlTransition != null;
Transition pivotElement = converter.refreshNamedElement(Transition.class, PivotPackage.Literals.TRANSITION, umlTransition);
copyNamespace(pivotElement, umlTransition);
return pivotElement;
}
@Override
public DynamicValueSpecification caseValueSpecification(org.eclipse.uml2.uml.ValueSpecification umlValueSpecification) {
assert umlValueSpecification != null;
DynamicValueSpecification pivotElement = converter.refreshElement(DynamicValueSpecification.class, PivotPackage.Literals.DYNAMIC_VALUE_SPECIFICATION, umlValueSpecification);
converter.setOriginalMapping(pivotElement, umlValueSpecification);
return pivotElement;
}
protected void copyAnnotatedElement(@NonNull NamedElement pivotElement,
@NonNull EModelElement umlElement, @Nullable List<EAnnotation> excludedAnnotations) {
List<Element> pivotAnnotations = pivotElement.getOwnedAnnotations();
for (EAnnotation eAnnotation : umlElement.getEAnnotations()) {
if ((excludedAnnotations == null) || !excludedAnnotations.contains(eAnnotation)) {
Element pivotAnnotation = (Element) doSwitch(eAnnotation);
if (pivotAnnotation != null) {
pivotAnnotations.add(pivotAnnotation);
}
}
}
}
protected void copyClassOrInterface(org.eclipse.ocl.pivot.@NonNull Class pivotElement, org.eclipse.uml2.uml.@NonNull Classifier umlClassifier) {
copyClassifier(pivotElement, umlClassifier);
pivotElement.setIsAbstract(umlClassifier.isAbstract());
String instanceClassName = null;
org.eclipse.uml2.uml.Stereotype ecoreStereotype = umlClassifier.getAppliedStereotype("Ecore::EClass");
if (ecoreStereotype != null) {
Object object = umlClassifier.getValue(ecoreStereotype, "instanceClassName");
if (object instanceof String) {
instanceClassName = (String) object;
}
}
pivotElement.setInstanceClassName(instanceClassName);
// doSwitchAll(umlClass.getSuperClasses());
@SuppressWarnings("null") @NonNull List<org.eclipse.uml2.uml.Property> umlAttributes = umlClassifier.getAttributes();
/* converter.addProperties(umlAttributes, new UML2AS.Predicate<org.eclipse.uml2.uml.Property>()
{
public boolean filter(org.eclipse.uml2.uml.@NonNull Property element) {
if (element.getAssociation() == null) {
doSwitch(element);
}
return element.getAssociation() == null;
}
}); */
// doSwitchAll(pivotElement.getOwnedAttribute(), umlClassifier.getAttributes());
doSwitchAll(umlAttributes);
converter.queueUse(umlClassifier); // For superclasses
}
protected void copyClass(org.eclipse.ocl.pivot.@NonNull Class pivotElement, org.eclipse.uml2.uml.@NonNull Class umlClass) {
pivotElement.setIsInterface(false);
copyClassOrInterface(pivotElement, umlClass);
/* for (org.eclipse.uml2.uml.Classifier umlType : umlClass.getNestedClassifiers()) {
// doSwitch(umlType);
Type pivotObject = (Type) doSwitch(umlType);
if (pivotObject != null) {
metamodelManager.addOrphanClass(pivotObject);
}
} */
// doSwitchAll(pivotElement.getNestedClassifier(), umlClass.getNestedClassifiers(), null);
doSwitchAll(pivotElement.getOwnedBehaviors(), umlClass.getOwnedBehaviors(), null);
}
protected void copyClassifier(org.eclipse.ocl.pivot.@NonNull Class pivotElement, org.eclipse.uml2.uml.@NonNull Classifier umlClassifier) {
copyNamespace(pivotElement, umlClassifier);
copyTemplateSignature(pivotElement, umlClassifier.getOwnedTemplateSignature());
doSwitchAll(pivotElement.getOwnedOperations(), umlClassifier.getOperations(), null);
}
protected void copyComments(@NonNull Element pivotElement, org.eclipse.uml2.uml.@NonNull Element umlElement) {
doSwitchAll(pivotElement.getOwnedComments(), umlElement.getOwnedComments(), null);
}
/* protected void copyConstraints(@NonNull Namespace pivotElement, org.eclipse.uml2.uml.@NonNull Namespace umlNamespace,
@Nullable List<org.eclipse.uml2.uml.Constraint> exclusions) {
List<org.eclipse.uml2.uml.Constraint> ownedRules = umlNamespace.getOwnedRules();
if ((exclusions != null) && (exclusions.size() > 0)) {
ownedRules = new ArrayList<org.eclipse.uml2.uml.Constraint>(ownedRules);
ownedRules.removeAll(exclusions);
}
doSwitchAll(pivotElement.getOwnedRule(), ownedRules, null);
} */
protected void copyDataTypeOrEnum(@NonNull DataType pivotElement, org.eclipse.uml2.uml.@NonNull DataType umlDataType) {
copyClassifier(pivotElement, umlDataType);
String instanceClassName = null;
org.eclipse.uml2.uml.Stereotype ecoreStereotype = umlDataType.getAppliedStereotype("Ecore::EClass"); // Bug 453090 : UML2 does not support generalization
if (ecoreStereotype == null) {
ecoreStereotype = umlDataType.getAppliedStereotype("Ecore::EDataType");
}
if (ecoreStereotype == null) {
ecoreStereotype = umlDataType.getAppliedStereotype("Ecore::EClassifier");
}
if (ecoreStereotype != null) {
Object object = umlDataType.getValue(ecoreStereotype, "instanceClassName");
if (object instanceof String) {
instanceClassName = (String) object;
pivotElement.setBehavioralClass(getPrimitiveTypeByEcoreStereotype(ecoreStereotype, instanceClassName));
}
}
PrimitiveType asPrimitiveType = getPrimitiveTypeByOCLStereotype(umlDataType);
if (asPrimitiveType != null) {
pivotElement.setBehavioralClass(asPrimitiveType);
if (instanceClassName == null) {
if (asPrimitiveType == standardLibrary.getIntegerType()) {
instanceClassName = IntegerValue.class.getName();
}
else {
instanceClassName = RealValue.class.getName();
}
}
}
pivotElement.setInstanceClassName(instanceClassName);
// pivotElement.setIsSerializable(umlDataType.isSerializable());
converter.queueReference(umlDataType); // For generals
}
/* public void copyDetailLines(List<String> lines, String value) {
String[] splitLines = value.split("\n");
for (int i = 0; i < splitLines.length-1; i++) {
lines.add(splitLines[i] + '\n');
}
if (splitLines.length > 0) {
lines.add(splitLines[splitLines.length-1]);
}
} */
protected void copyNamedElement(@NonNull NamedElement pivotElement, org.eclipse.uml2.uml.@NonNull NamedElement umlNamedElement) {
converter.copyNamedElement(pivotElement, umlNamedElement);
copyAnnotatedElement(pivotElement, umlNamedElement, null);
copyComments(pivotElement, umlNamedElement);
}
protected void copyNamespace(@NonNull Namespace pivotElement, org.eclipse.uml2.uml.@NonNull Namespace umlNamespace) {
copyNamedElement(pivotElement, umlNamespace);
converter.queueUse(umlNamespace); // Defer for constraints
}
protected void copyPackage(org.eclipse.ocl.pivot.@NonNull Package pivotElement, org.eclipse.uml2.uml.@NonNull Package umlPackage) {
// EAnnotation eAnnotation = umlPackage.getEAnnotation(EcorePackage.eNS_URI);
// List<EAnnotation> exclusions = eAnnotation == null ? Collections.<EAnnotation>emptyList() : Collections.singletonList(eAnnotation);
copyNamespace(pivotElement, umlPackage);
Object nsPrefix = null;
Object nsURI = umlPackage.getURI();
org.eclipse.uml2.uml.Stereotype ecoreStereotype = getEcoreStereotype(umlPackage, UMLUtil.STEREOTYPE__E_PACKAGE);
if ((ecoreStereotype != null) && umlPackage.isStereotypeApplied(ecoreStereotype)) {
nsPrefix = umlPackage.getValue(ecoreStereotype, UMLUtil.TAG_DEFINITION__NS_PREFIX);
if (nsURI == null) {
nsURI = umlPackage.getValue(ecoreStereotype, UMLUtil.TAG_DEFINITION__NS_URI);
}
}
pivotElement.setNsPrefix(nsPrefix != null ? nsPrefix.toString() : null);
if (nsURI instanceof String) {
String nsURI2 = (String)nsURI;
if (!(umlPackage instanceof org.eclipse.uml2.uml.Profile) && nsURI2.startsWith("http://www.omg.org/spec/")) {
String packageName = umlPackage.getName();
if ("UML".equals(packageName)) { // OMG's
for (org.eclipse.uml2.uml.Type umlType : umlPackage.getOwnedTypes()) {
if ((umlType instanceof org.eclipse.uml2.uml.Class) && "Class".equals(umlType.getName())) {
metamodelManager.getCompleteModel().addPackageURI2completeURI(nsURI2, PivotConstants.UML_METAMODEL_NAME);;
((PackageImpl)pivotElement).setIgnoreInvariants(true);
break;
}
}
}
else if ("PrimitiveTypes".equals(packageName)) {
for (org.eclipse.uml2.uml.Type umlType : umlPackage.getOwnedTypes()) {
if ((umlType instanceof org.eclipse.uml2.uml.PrimitiveType) && "Boolean".equals(umlType.getName())) {
metamodelManager.getCompleteModel().addPackageURI2completeURI(nsURI2, PivotConstants.TYPES_METAMODEL_NAME);;
break;
}
}
}
}
String sharedURI = metamodelManager.getCompleteModel().getCompleteURI(nsURI2);
if ((sharedURI != null) && !sharedURI.equals(nsURI)) {
((PackageImpl)pivotElement).setPackageId(IdManager.getRootPackageId(sharedURI));
}
}
pivotElement.setURI(nsURI != null ? nsURI.toString() : null);
@Nullable List<org.eclipse.uml2.uml.Constraint> umlConstraints = null;
@Nullable List<org.eclipse.uml2.uml.Element> umlOtherElements = null;
@Nullable List<org.eclipse.uml2.uml.InstanceSpecification> umlInstanceSpecifications = null;
@Nullable List<org.eclipse.uml2.uml.Package> umlNestedPackages = null;
@Nullable List<org.eclipse.uml2.uml.Package> umlImportedPackages = null;
@Nullable List<org.eclipse.uml2.uml.ProfileApplication> umlProfileApplications = null;
@Nullable List<org.eclipse.uml2.uml.Type> umlTypes = null;
@Nullable List<org.eclipse.uml2.uml.Association> umlAssociations = null;
for (org.eclipse.uml2.uml.Element ownedElement : umlPackage.getOwnedElements()) {
if (ownedElement instanceof org.eclipse.uml2.uml.Package) {
if (umlNestedPackages == null) {
umlNestedPackages = new ArrayList<org.eclipse.uml2.uml.Package>();
}
umlNestedPackages.add((org.eclipse.uml2.uml.Package)ownedElement);
}
else if (ownedElement instanceof org.eclipse.uml2.uml.PackageImport) {
if (umlImportedPackages == null) {
umlImportedPackages = new ArrayList<org.eclipse.uml2.uml.Package>();
}
umlImportedPackages.add(((org.eclipse.uml2.uml.PackageImport)ownedElement).getImportedPackage());
}
else if (ownedElement instanceof org.eclipse.uml2.uml.Association) {
if (umlAssociations == null) {
umlAssociations = new ArrayList<org.eclipse.uml2.uml.Association>();
}
umlAssociations.add((org.eclipse.uml2.uml.Association)ownedElement);
}
else if (ownedElement instanceof org.eclipse.uml2.uml.Constraint) {
if (umlConstraints == null) {
umlConstraints = new ArrayList<org.eclipse.uml2.uml.Constraint>();
}
umlConstraints.add((org.eclipse.uml2.uml.Constraint)ownedElement);
}
else if (ownedElement instanceof org.eclipse.uml2.uml.InstanceSpecification) {
if (umlInstanceSpecifications == null) {
umlInstanceSpecifications = new ArrayList<org.eclipse.uml2.uml.InstanceSpecification>();
}
umlInstanceSpecifications.add((org.eclipse.uml2.uml.InstanceSpecification)ownedElement);
}
else if (ownedElement instanceof org.eclipse.uml2.uml.Type) {
if (umlTypes == null) {
umlTypes = new ArrayList<org.eclipse.uml2.uml.Type>();
}
umlTypes.add((org.eclipse.uml2.uml.Type)ownedElement);
}
else if (ownedElement instanceof org.eclipse.uml2.uml.ProfileApplication) {
if (umlProfileApplications == null) {
umlProfileApplications = new ArrayList<org.eclipse.uml2.uml.ProfileApplication>();
}
umlProfileApplications.add((org.eclipse.uml2.uml.ProfileApplication)ownedElement);
}
else if (ownedElement instanceof org.eclipse.uml2.uml.Comment) {
// umlComments.add((org.eclipse.uml2.uml.Comment)ownedElement);
}
else {
if (umlOtherElements == null) {
umlOtherElements = new ArrayList<org.eclipse.uml2.uml.Element>();
}
umlOtherElements.add(ownedElement);
}
}
if (umlInstanceSpecifications != null) {
doSwitchAll(pivotElement.getOwnedInstances(), umlInstanceSpecifications, null);
}
else {
pivotElement.getOwnedInstances().clear();
}
if (umlNestedPackages != null) {
doSwitchAll(pivotElement.getOwnedPackages(), umlNestedPackages, null);
}
else {
pivotElement.getOwnedPackages().clear();
}
if (umlProfileApplications != null) {
doSwitchAll(pivotElement.getOwnedProfileApplications(), umlProfileApplications, null);
for (org.eclipse.uml2.uml.ProfileApplication umlProfileApplication : umlProfileApplications) {
if (umlProfileApplication != null) {
org.eclipse.uml2.uml.Profile appliedProfile = umlProfileApplication.getAppliedProfile();
if (appliedProfile != null) {
if (umlImportedPackages == null) {
umlImportedPackages = new ArrayList<org.eclipse.uml2.uml.Package>();
}
umlImportedPackages.add(appliedProfile);
}
}
}
}
else {
pivotElement.getOwnedProfileApplications().clear();
}
List<org.eclipse.ocl.pivot.@NonNull Class> asClasses = new ArrayList<org.eclipse.ocl.pivot.@NonNull Class>();
if (umlTypes != null) {
doSwitchAll(asClasses, umlTypes, null);
}
else {
asClasses.clear();
}
if (umlAssociations != null) {
for (org.eclipse.uml2.uml.Association umlAssociation : umlAssociations) {
Object asAssociation = doSwitch(umlAssociation);
if (asAssociation instanceof AssociationClass) {
asClasses.add((AssociationClass)asAssociation);
}
}
}
converter.refreshList(pivotElement.getOwnedClasses(), asClasses);
if (umlConstraints != null) {
doSwitchAll(pivotElement.getOwnedConstraints(), umlConstraints, null);
}
if (umlOtherElements != null) {
doSwitchAll(pivotElement.getOwnedAnnotations(), umlOtherElements, null);
}
else {
pivotElement.getOwnedAnnotations().clear();
}
if (umlImportedPackages != null) {
converter.addImportedPackages(umlImportedPackages);
converter.queueUse(umlPackage); // Defer
}
else {
pivotElement.getImportedPackages().clear();
}
}
protected void copyProperty(@NonNull Property pivotElement, org.eclipse.uml2.uml.@NonNull Property umlProperty, List<EAnnotation> excludedAnnotations) {
copyTypedElement(pivotElement, umlProperty, excludedAnnotations); pivotElement.setIsReadOnly(umlProperty.isReadOnly());
pivotElement.setIsDerived(umlProperty.isDerived());
// pivotElement.setIsTransient(umlProperty.isTransient());
// pivotElement.setIsUnsettable(umlProperty.isUnsettable());
// pivotElement.setIsVolatile(umlProperty.isVolatile());
// if (umlProperty.eIsSet(EcorePackage.Literals.ESTRUCTURAL_FEATURE__DEFAULT_VALUE_LITERAL)) {
// pivotElement.setDefault(eObject.getDefaultValueLiteral());
// }
// else {
// pivotElement.eUnset(PivotPackage.Literals.PROPERTY__DEFAULT);
// }
}
protected void copyState(@NonNull State pivotElement, org.eclipse.uml2.uml.@NonNull State umlState) {
copyNamespace(pivotElement, umlState);
doSwitchAll(pivotElement.getOwnedRegions(), umlState.getRegions(), null);
}
protected void copyTemplateSignature(TemplateableElement pivotElement, org.eclipse.uml2.uml.TemplateSignature umlTemplateSignature) {
if (umlTemplateSignature != null) {
List<org.eclipse.uml2.uml.TemplateParameter> umlTemplateParameters = umlTemplateSignature.getOwnedParameters();
if (!umlTemplateParameters.isEmpty()) {
TemplateSignature pivotTemplateSignature = PivotFactory.eINSTANCE.createTemplateSignature();
pivotElement.setOwnedSignature(pivotTemplateSignature);
doSwitchAll(pivotTemplateSignature.getOwnedParameters(), umlTemplateParameters, null);
}
}
}
protected void copyTypedElement(@NonNull TypedElement pivotElement, org.eclipse.uml2.uml.@NonNull TypedElement umlTypedElement, List<EAnnotation> excludedAnnotations) {
copyNamedElement(pivotElement, umlTypedElement);
int lower = ((org.eclipse.uml2.uml.MultiplicityElement)umlTypedElement).getLower();
int upper = ((org.eclipse.uml2.uml.MultiplicityElement)umlTypedElement).getUpper();
pivotElement.setIsRequired((upper == 1) && (lower == 1));
org.eclipse.uml2.uml.Type umlType = umlTypedElement.getType();
if (umlType != null) {
converter.queueReference(umlTypedElement);
Resource umlResource = umlType.eResource();
if (umlResource != null) {
converter.addImportedResource(umlResource);
}
}
}
@Override
public Element defaultCase(EObject umlObject) {
DynamicElement pivotElement;
if (umlObject instanceof org.eclipse.uml2.uml.Type) {
pivotElement = converter.refreshElement(DynamicType.class, PivotPackage.Literals.DYNAMIC_TYPE, umlObject);
((DynamicType)pivotElement).setName(((org.eclipse.uml2.uml.Type)umlObject).getName());
}
else if (umlObject instanceof org.eclipse.uml2.uml.Element) {
pivotElement = converter.refreshElement(DynamicElement.class, PivotPackage.Literals.DYNAMIC_ELEMENT, umlObject);
}
else {
converter.error("Unsupported " + umlObject.eClass().getName() + " for UML2ASDeclarationSwitch");
return null;
}
converter.setOriginalMapping(pivotElement, umlObject);
doSwitchAll(pivotElement.getOwnedAnnotations(), ((org.eclipse.uml2.uml.Element)umlObject).getOwnedElements(), null);
EClass umlMetaClass = umlObject.eClass();
Type metaType = metamodelManager.getASOfEcore(Type.class, umlMetaClass);
pivotElement.setMetaType(metaType);
if (umlObject instanceof org.eclipse.uml2.uml.Slot) {
converter.queueUse(umlObject);
}
return pivotElement;
}
public Object doInPackageSwitch(@NonNull EObject eObject) {
int classifierID = eObject.eClass().getClassifierID();
return doSwitch(classifierID, eObject);
}
@Override
public Object doSwitch(EObject eObject) {
EClass eClass = eObject.eClass();
EPackage ePackage = eClass.getEPackage();
if (ePackage == UMLPackage.eINSTANCE) {
return doInPackageSwitch(eObject);
}
else if (ePackage == EcorePackage.eINSTANCE) {
if (eObject.eContainer() instanceof org.eclipse.uml2.uml.Profile) {
return null;
}
return ecoreSwitch.doInPackageSwitch(eObject);
}
else if (ePackage.getNsURI().startsWith("http://www.omg.org/spec/MOF")) { // Should never happen (removed by CMOF2UMLResourceHandler
if ((eObject instanceof org.eclipse.emf.ecore.xml.type.AnyType) && "Tag".equals(eClass.getName())) {
FeatureMap anyAttribute = ((org.eclipse.emf.ecore.xml.type.AnyType)eObject).getAnyAttribute();
Object name = null;
Object value = null;
Object element = null;
for (Entry entry : anyAttribute) {
EStructuralFeature eFeature = entry.getEStructuralFeature();
if ("name".equals(eFeature.getName())) {
name = anyAttribute.get(eFeature, false);
}
else if ("value".equals(eFeature.getName())) {
value = anyAttribute.get(eFeature, false);
}
else if ("element".equals(eFeature.getName())) {
element = anyAttribute.get(eFeature, false);
}
}
boolean gotIt = false;
EObject taggedObject = eObject.eResource().getEObject(String.valueOf(element));
if ("org.omg.xmi.nsPrefix".equals(name) && (taggedObject instanceof org.eclipse.uml2.uml.Package)) {
org.eclipse.ocl.pivot.Package asPackage = converter.getCreated(org.eclipse.ocl.pivot.Package.class, taggedObject);
if (asPackage != null) {
asPackage.setNsPrefix(String.valueOf(value));
gotIt = true;
}
}
else if ("org.omg.xmi.nsURI".equals(name) && (taggedObject instanceof org.eclipse.uml2.uml.Package)) {
org.eclipse.ocl.pivot.Package asPackage = converter.getCreated(org.eclipse.ocl.pivot.Package.class, taggedObject);
if (asPackage != null) {
asPackage.setURI(String.valueOf(value));
gotIt = true;
}
}
else if ("org.omg.xmi.schemaType".equals(name) && (taggedObject instanceof org.eclipse.uml2.uml.DataType)) {
DataType asPackage = converter.getCreated(DataType.class, taggedObject);
if (asPackage != null) {
// FIXME asPackage.setNsURI(String.valueOf(value));
System.out.println("Unknown " + ePackage.getNsURI() + "::" + eObject.eClass().getName() + "::" + name + " ignored");
gotIt = true;
}
}
if (!gotIt) {
logger.warn("Unknown " + ePackage.getNsURI() + "::" + eObject.eClass().getName() + "::" + name + " ignored");
}
}
return null;
}
else if (ePackage.getNsURI().startsWith("http://www.eclipse.org/uml2/schemas/Ecore")) {
// FIXME
return null;
}
else {
converter.addStereotypeApplication(eObject);
return null;
}
}
public <T extends Element, V extends EObject> void doSwitchAll(/*@NonNull*/ Collection<T> pivotObjects, /*@NonNull*/ List<V> eObjects, UML2AS.@Nullable Predicate<V> predicate) {
assert pivotObjects != null;
assert eObjects != null;
eObjects.size();
for (V eObject : eObjects) {
if ((eObject != null) && ((predicate == null) || predicate.filter(eObject))) {
@SuppressWarnings("unchecked")
T pivotObject = (T) doSwitch(eObject);
if (pivotObject != null) {
pivotObjects.add(pivotObject);
}
}
}
}
public <T extends Element> void doSwitchAll(@NonNull List<? extends EObject> eObjects) {
for (EObject eObject : eObjects) {
doSwitch(eObject);
}
}
protected org.eclipse.uml2.uml.Profile getEcoreProfile(EObject eObject) {
Resource eResource = eObject.eResource();
if (eResource != null) {
ResourceSet resourceSet = eResource.getResourceSet();
if (resourceSet != null) {
return UML2Util.load(resourceSet, URI
.createURI(UMLResource.ECORE_PROFILE_URI),
UMLPackage.Literals.PROFILE);
}
}
return null;
}
protected org.eclipse.uml2.uml.Stereotype getEcoreStereotype(EObject eObject, String name) {
org.eclipse.uml2.uml.Profile ecoreProfile = getEcoreProfile(eObject);
return ecoreProfile != null
? ecoreProfile.getOwnedStereotype(name)
: null;
}
protected @Nullable PrimitiveType getPrimitiveTypeByEcoreStereotype(org.eclipse.uml2.uml.@NonNull Stereotype ecoreStereotype, @NonNull String instanceClassName) {
if ("boolean".equals(instanceClassName)) {
return standardLibrary.getBooleanType();
}
if ("byte".equals(instanceClassName) || "char".equals(instanceClassName) || "int".equals(instanceClassName) || "long".equals(instanceClassName) || "short".equals(instanceClassName)) {
return standardLibrary.getIntegerType();
}
if ("double".equals(instanceClassName) || "float".equals(instanceClassName)) {
return standardLibrary.getRealType();
}
try {
@SuppressWarnings("null")@NonNull ClassLoader classLoader = ecoreStereotype.getClass().getClassLoader();
Class<?> instanceClass = classLoader.loadClass(instanceClassName);
if (instanceClass != null) {
PrimitiveType behavioralClass = standardLibrary.getBehavioralClass(instanceClass);
if (behavioralClass != null) {
return behavioralClass;
}
instanceClass.getDeclaredMethod("compareTo", instanceClass);
// converter.queueReference(eObject2); // Defer synthesis till supertypes resolved
}
}
catch (Exception e) {
// converter.error("Unknown '" + instanceClassName + "'"); // Ignores e.g. byte[]
}
return null;
}
protected @Nullable PrimitiveType getPrimitiveTypeByName(org.eclipse.uml2.uml.@NonNull PrimitiveType umlPrimitiveType) {
String name = umlPrimitiveType.getName();
if (UMLUtil.isBoolean(umlPrimitiveType) || TypeId.BOOLEAN_NAME.equals(name)) {
return standardLibrary.getBooleanType();
}
if (UMLUtil.isInteger(umlPrimitiveType) || TypeId.INTEGER_NAME.equals(name)) {
return standardLibrary.getIntegerType();
}
if (UMLUtil.isReal(umlPrimitiveType) || TypeId.REAL_NAME.equals(name)) {
return standardLibrary.getRealType();
}
if (UMLUtil.isString(umlPrimitiveType) || TypeId.STRING_NAME.equals(name)) {
return standardLibrary.getStringType();
}
if (UMLUtil.isUnlimitedNatural(umlPrimitiveType) || TypeId.UNLIMITED_NATURAL_NAME.equals(name)) {
return standardLibrary.getUnlimitedNaturalType();
}
org.eclipse.uml2.uml.Package umlPackage = umlPrimitiveType.getPackage();
if ((umlPackage != null) && "EcorePrimitiveTypes".equals(umlPackage.getName())) { // FIXME Bug 412918 for extra cases
if ("EBigDecimal".equals(name)
|| "EFloat".equals(name) || "EFloatObject".equals(name)) {
return standardLibrary.getRealType();
}
else if ("EBigInteger".equals(name)
|| "EByte".equals(name) || "EByteObject".equals(name)
|| "EChar".equals(name) || "ECharacterObject".equals(name)
|| "ELong".equals(name) || "ELongObject".equals(name)
|| "EShortObject".equals(name) || "EShortObject".equals(name)) {
return standardLibrary.getIntegerType();
}
}
return null;
}
protected @Nullable PrimitiveType getPrimitiveTypeByOCLStereotype(org.eclipse.uml2.uml.@NonNull DataType umlDataType) {
if (umlDataType.getAppliedStereotype("OCLforUML::Integer") != null) {
return standardLibrary.getIntegerType();
}
if (umlDataType.getAppliedStereotype("OCLforUML::Real") != null) {
return standardLibrary.getRealType();
}
return null;
}
}