| /******************************************************************************* |
| * Copyright (c) 2010, 2013 E.D.Willink 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 |
| *******************************************************************************/ |
| package org.eclipse.ocl.xtext.base.as2cs; |
| |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.Comparator; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| |
| import org.apache.log4j.Logger; |
| import org.eclipse.emf.common.util.EList; |
| import org.eclipse.emf.common.util.URI; |
| import org.eclipse.emf.ecore.EClass; |
| import org.eclipse.emf.ecore.EFactory; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.ecore.EPackage; |
| import org.eclipse.emf.ecore.resource.Resource; |
| import org.eclipse.emf.ecore.util.EcoreUtil; |
| import org.eclipse.jdt.annotation.NonNull; |
| import org.eclipse.jdt.annotation.Nullable; |
| import org.eclipse.ocl.pivot.CollectionType; |
| import org.eclipse.ocl.pivot.CompletePackage; |
| import org.eclipse.ocl.pivot.Element; |
| import org.eclipse.ocl.pivot.Model; |
| import org.eclipse.ocl.pivot.NamedElement; |
| import org.eclipse.ocl.pivot.Namespace; |
| import org.eclipse.ocl.pivot.Package; |
| import org.eclipse.ocl.pivot.PivotConstants; |
| import org.eclipse.ocl.pivot.PivotPackage; |
| import org.eclipse.ocl.pivot.Property; |
| import org.eclipse.ocl.pivot.TemplateSignature; |
| import org.eclipse.ocl.pivot.Type; |
| import org.eclipse.ocl.pivot.TypedElement; |
| import org.eclipse.ocl.pivot.UMLReflection; |
| import org.eclipse.ocl.pivot.VoidType; |
| import org.eclipse.ocl.pivot.manager.MetaModelManager; |
| import org.eclipse.ocl.pivot.util.Visitable; |
| import org.eclipse.ocl.pivot.utilities.AbstractConversion; |
| import org.eclipse.ocl.pivot.utilities.ClassUtil; |
| import org.eclipse.ocl.pivot.utilities.PivotUtil; |
| import org.eclipse.ocl.pivot.values.Unlimited; |
| import org.eclipse.ocl.xtext.base.as2cs.AS2CS.Factory; |
| import org.eclipse.ocl.xtext.base.utilities.BaseCSResource; |
| import org.eclipse.ocl.xtext.basecs.AnnotationCS; |
| import org.eclipse.ocl.xtext.basecs.BaseCSFactory; |
| import org.eclipse.ocl.xtext.basecs.BaseCSPackage; |
| import org.eclipse.ocl.xtext.basecs.ClassCS; |
| import org.eclipse.ocl.xtext.basecs.ConstraintCS; |
| import org.eclipse.ocl.xtext.basecs.DetailCS; |
| import org.eclipse.ocl.xtext.basecs.ElementCS; |
| import org.eclipse.ocl.xtext.basecs.ImportCS; |
| import org.eclipse.ocl.xtext.basecs.ModelElementCS; |
| import org.eclipse.ocl.xtext.basecs.MultiplicityBoundsCS; |
| import org.eclipse.ocl.xtext.basecs.MultiplicityStringCS; |
| import org.eclipse.ocl.xtext.basecs.NamedElementCS; |
| import org.eclipse.ocl.xtext.basecs.PackageCS; |
| import org.eclipse.ocl.xtext.basecs.PathElementCS; |
| import org.eclipse.ocl.xtext.basecs.PathElementWithURICS; |
| import org.eclipse.ocl.xtext.basecs.PathNameCS; |
| import org.eclipse.ocl.xtext.basecs.RootCS; |
| import org.eclipse.ocl.xtext.basecs.StructuralFeatureCS; |
| import org.eclipse.ocl.xtext.basecs.TemplateBindingCS; |
| import org.eclipse.ocl.xtext.basecs.TemplateSignatureCS; |
| import org.eclipse.ocl.xtext.basecs.TypedElementCS; |
| import org.eclipse.ocl.xtext.basecs.TypedRefCS; |
| import org.eclipse.ocl.xtext.basecs.TypedTypeRefCS; |
| |
| public class AS2CSConversion extends AbstractConversion implements PivotConstants |
| { |
| private static final Logger logger = Logger.getLogger(AS2CSConversion.class); |
| |
| protected final @NonNull AS2CS converter; |
| protected final @NonNull BaseDeclarationVisitor defaultDeclarationVisitor; |
| protected final @NonNull BaseReferenceVisitor defaultReferenceVisitor; |
| |
| private org.eclipse.ocl.pivot.Class scope = null; |
| |
| private final @NonNull Map<EClass, BaseDeclarationVisitor> declarationVisitorMap = new HashMap<EClass, BaseDeclarationVisitor>(); |
| private final @NonNull Map<EClass, BaseReferenceVisitor> referenceVisitorMap = new HashMap<EClass, BaseReferenceVisitor>(); |
| private Map<Namespace, List<String>> importedNamespaces = null; |
| |
| /** |
| * The CS Resource currently being converted. |
| */ |
| private @Nullable BaseCSResource csResource = null;; |
| |
| public AS2CSConversion(@NonNull AS2CS converter) { |
| super(converter.getMetaModelManager()); |
| this.converter = converter; |
| this.defaultDeclarationVisitor = converter.createDefaultDeclarationVisitor(this); |
| this.defaultReferenceVisitor = converter.createDefaultReferenceVisitor(this); |
| } |
| |
| protected void addBooleanQualifier(@NonNull List<String> qualifiers, @NonNull DetailCS csDetail, @NonNull String csString) { |
| EList<String> values = csDetail.getValues(); |
| if ((values.size() == 1) && Boolean.valueOf(values.get(0))) { |
| qualifiers.add(csString); |
| } |
| else { |
| qualifiers.add("!" + csString); |
| } |
| } |
| |
| public void createImports(@NonNull RootCS documentCS, @NonNull Map<Namespace, List<String>> importedNamespaces) { |
| BaseCSResource csResource = (BaseCSResource) ClassUtil.nonNullState(documentCS.eResource()); |
| AliasAnalysis.dispose(csResource); // Force reanalysis |
| MetaModelManager metaModelManager = PivotUtil.findMetaModelManager(csResource); |
| if (metaModelManager == null) { |
| throw new IllegalStateException("No MetaModelManager"); |
| } |
| AliasAnalysis aliasAnalysis = null; |
| URI csURI = csResource.getURI(); |
| List<ImportCS> imports = new ArrayList<ImportCS>(); |
| for (Namespace importedNamespace : importedNamespaces.keySet()) { |
| if (importedNamespace != null) { |
| if (importedNamespace instanceof org.eclipse.ocl.pivot.Package){ |
| Package pivotPackage = metaModelManager.getCompletePackage((org.eclipse.ocl.pivot.Package)importedNamespace).getPivotPackage(); |
| // ModelElementCS csElement = createMap.get(importedPackage); |
| // if ((csElement != null) && (csElement.eResource() == xtextResource)) { |
| // continue; // Don't import defined packages |
| // } |
| if (metaModelManager.getLibraries().contains(pivotPackage)) { |
| continue; |
| } |
| } |
| List<String> aliases = importedNamespaces.get(importedNamespace); |
| if ((aliases == null) || aliases.isEmpty()) { |
| if (aliasAnalysis == null) { |
| aliasAnalysis = AliasAnalysis.getAdapter(csResource, metaModelManager); |
| } |
| String alias = aliasAnalysis.getAlias(importedNamespace, null); |
| aliases = Collections.singletonList(alias); |
| } |
| EObject eObject = importedNamespace.getETarget(); |
| String importURI = null; |
| if (eObject instanceof EPackage) { |
| EPackage ePackage = (EPackage)eObject; |
| Resource resource = ePackage.eResource(); |
| if (ClassUtil.isRegistered(resource)) { |
| importURI = ePackage.getNsURI(); |
| } |
| } |
| if (importURI == null) { |
| URI fullURI = EcoreUtil.getURI(eObject != null ? eObject : importedNamespace); |
| URI deresolvedURI = fullURI.deresolve(csURI, true, true, false); |
| importURI = deresolvedURI.toString(); |
| } |
| for (String alias : aliases) { |
| ImportCS importCS = BaseCSFactory.eINSTANCE.createImportCS(); |
| importCS.setName(alias); |
| @SuppressWarnings("null") @NonNull PathNameCS csPathName = BaseCSFactory.eINSTANCE.createPathNameCS(); |
| importCS.setOwnedPathName(csPathName); |
| List<PathElementCS> csPath = csPathName.getOwnedPathElements(); |
| PathElementWithURICS csSimpleRef = BaseCSFactory.eINSTANCE.createPathElementWithURICS(); |
| csPath.add(csSimpleRef); |
| csSimpleRef.setReferredElement(importedNamespace); |
| csSimpleRef.setUri(importURI); |
| importCS.setPivot(importedNamespace); |
| imports.add(importCS); |
| } |
| } |
| } |
| if (aliasAnalysis != null) { |
| aliasAnalysis.dispose(); |
| } |
| aliasAnalysis = AliasAnalysis.getAdapter(csResource, metaModelManager); |
| for (ImportCS csImport : imports) { |
| Namespace namespace = csImport.getReferredNamespace(); |
| String alias = csImport.getName(); |
| if ((namespace != null) && (alias == null)) { |
| alias = aliasAnalysis.getAlias(namespace, null); |
| if (alias == null) { |
| String hint = null; |
| if (namespace instanceof org.eclipse.ocl.pivot.Package) { |
| hint = ((org.eclipse.ocl.pivot.Package)namespace).getNsPrefix(); |
| } |
| if (hint == null) { |
| String name = namespace.getName(); |
| if (name.length() > 0) { |
| hint = name.substring(0, 1).toLowerCase() + name.substring(1); |
| } |
| } |
| if (hint != null) { |
| alias = aliasAnalysis.getAlias(namespace, hint); |
| } |
| } |
| if (alias != null) { |
| csImport.setName(alias); |
| } |
| } |
| } |
| Collections.sort(imports, new Comparator<ImportCS>() |
| { |
| @Override |
| public int compare(ImportCS o1, ImportCS o2) { |
| Namespace ns1 = o1.getReferredNamespace(); |
| Namespace ns2 = o2.getReferredNamespace(); |
| int d1 = PivotUtil.getContainmentDepth(ns1); |
| int d2 = PivotUtil.getContainmentDepth(ns2); |
| if (d1 != d2) { |
| return d1 - d2; |
| } |
| String n1 = o1.getName(); |
| String n2 = o2.getName(); |
| return n1.compareTo(n2); |
| } |
| }); |
| documentCS.getOwnedImports().addAll(imports); |
| } |
| |
| public @Nullable BaseCSResource getCSResource() { |
| return csResource; |
| } |
| |
| public @NonNull AS2CS getConverter() { |
| return converter; |
| } |
| |
| public @Nullable BaseDeclarationVisitor getDeclarationVisitor(@NonNull EClass eClass) { |
| BaseDeclarationVisitor declarationVisitor = declarationVisitorMap.get(eClass); |
| if ((declarationVisitor == null) && !declarationVisitorMap.containsKey(eClass)) { |
| Factory factory = converter.getFactory(eClass); |
| if (factory != null) { |
| declarationVisitor = factory.createDeclarationVisitor(this); |
| } |
| else { |
| declarationVisitor = defaultDeclarationVisitor; |
| } |
| declarationVisitorMap.put(eClass, declarationVisitor); |
| } |
| return declarationVisitor; |
| } |
| |
| public @Nullable BaseReferenceVisitor getReferenceVisitor(@NonNull EClass eClass, @Nullable Namespace scope) { |
| if (scope == null) { |
| BaseReferenceVisitor referenceVisitor = referenceVisitorMap.get(eClass); |
| if ((referenceVisitor == null) && !referenceVisitorMap.containsKey(eClass)) { |
| Factory factory = converter.getFactory(eClass); |
| if (factory != null) { |
| referenceVisitor = factory.createReferenceVisitor(this, null); |
| } |
| else { |
| referenceVisitor = defaultReferenceVisitor; |
| } |
| referenceVisitorMap.put(eClass, referenceVisitor); |
| } |
| return referenceVisitor; |
| } |
| else { |
| Factory factory = converter.getFactory(eClass); |
| if (factory != null) { |
| return factory.createReferenceVisitor(this, scope); |
| } |
| else { |
| return defaultReferenceVisitor; |
| } |
| |
| } |
| } |
| |
| public org.eclipse.ocl.pivot.Class getScope() { |
| return scope; |
| } |
| |
| protected List<TemplateBindingCS> getTemplateBindings(ElementCS csElement) { |
| List<TemplateBindingCS> csTemplateBindings; |
| // EObject container = csElement.eContainer(); |
| // if (container instanceof ElementCS) { |
| // csTemplateBindings = getTemplateBindings((ElementCS) container); |
| // } |
| // else { |
| csTemplateBindings = new ArrayList<TemplateBindingCS>(); |
| // } |
| if (csElement instanceof TypedTypeRefCS) { |
| TypedTypeRefCS csTemplateableElement = (TypedTypeRefCS)csElement; |
| TemplateBindingCS csTemplateBinding = csTemplateableElement.getOwnedBinding(); |
| if (csTemplateBinding != null) { |
| csTemplateBindings.add(csTemplateBinding); |
| } |
| } |
| return csTemplateBindings; |
| } |
| |
| public void importNamespace(@NonNull Namespace importNamespace, @Nullable String alias) { |
| Namespace primaryNamespace = metaModelManager.getPrimaryElement(importNamespace); |
| List<String> aliases = importedNamespaces.get(primaryNamespace); |
| if (aliases == null) { |
| aliases = new ArrayList<String>(); |
| importedNamespaces.put(primaryNamespace, aliases); |
| } |
| if ((alias != null) && !aliases.contains(alias)) { |
| aliases.add(alias); |
| } |
| } |
| |
| protected <T extends ClassCS> T refreshClassifier(@NonNull Class<T> csClass, /*@NonNull*/ EClass csEClass, @NonNull org.eclipse.ocl.pivot.Class object) { |
| T csElement = refreshNamedElement(csClass, csEClass, object); |
| List<ConstraintCS> csInvariants = visitDeclarations(ConstraintCS.class, object.getOwnedInvariants(), null); |
| for (ConstraintCS csInvariant : csInvariants) { |
| csInvariant.setStereotype(UMLReflection.INVARIANT); |
| } |
| refreshList(csElement.getOwnedConstraints(), csInvariants); |
| TemplateSignature ownedTemplateSignature = object.getOwnedSignature(); |
| if (ownedTemplateSignature != null) { |
| csElement.setOwnedSignature(visitDeclaration(TemplateSignatureCS.class, ownedTemplateSignature)); |
| } |
| if (object.eIsSet(PivotPackage.Literals.CLASS__INSTANCE_CLASS_NAME)) { |
| csElement.setInstanceClassName(object.getInstanceClassName()); |
| } |
| else { |
| csElement.eUnset(BaseCSPackage.Literals.CLASS_CS__INSTANCE_CLASS_NAME); |
| } |
| return csElement; |
| } |
| |
| public <T extends ModelElementCS> T refreshElement(@NonNull Class<T> csClass, /*@NonNull*/ EClass csEClass, @NonNull Element object) { |
| assert csClass == csEClass.getInstanceClass(); |
| EFactory eFactoryInstance = csEClass.getEPackage().getEFactoryInstance(); |
| ModelElementCS csElement = (ModelElementCS) eFactoryInstance.create(csEClass); |
| if (!csClass.isAssignableFrom(csElement.getClass())) { |
| throw new ClassCastException(); |
| } |
| csElement.setPivot(object); |
| @SuppressWarnings("unchecked") |
| T castElement = (T) csElement; |
| return castElement; |
| } |
| |
| public <T extends NamedElementCS> T refreshNamedElement(@NonNull Class<T> csClass, /*@NonNull */EClass csEClass, @NonNull NamedElement object) { |
| T csElement = refreshElement(csClass, csEClass, object); |
| String name = object.getName(); |
| csElement.setName(name); |
| refreshList(csElement.getOwnedAnnotations(), visitDeclarations(AnnotationCS.class, object.getOwnedAnnotations(), null)); |
| return csElement; |
| } |
| |
| /** |
| * Assign a sequence of one or more path elements to csPathName that identify element with respect |
| * to scope. |
| * <br> |
| * For example A::B::C::D::E with respect to A::B::C::X::Y is D::E. |
| * <br> |
| * Validation is performed to check that the shortened name resolves to the same |
| * element. |
| * <br> |
| * For example if there is also an A::B::C::X::D::E, the scope is shortened to A::B so |
| * that the result is C::D::E. |
| */ |
| public void refreshPathName(@NonNull PathNameCS csPathName, @NonNull Element element, @Nullable Namespace scope) {//, @Nullable Resource csResource) { |
| Namespace safeScope = scope; |
| Element primaryElement = metaModelManager.getPrimaryElement(element); |
| if ((safeScope != null) && (primaryElement instanceof Type)) { |
| String name = ((Type)primaryElement).getName(); |
| for (EObject eObject = safeScope; eObject != null; eObject = eObject.eContainer()) { |
| if (eObject instanceof Namespace) { |
| safeScope = (Namespace) eObject; |
| } |
| if (eObject instanceof org.eclipse.ocl.pivot.Package) { |
| CompletePackage completePackage = metaModelManager.getCompletePackage((org.eclipse.ocl.pivot.Package)eObject); |
| org.eclipse.ocl.pivot.Class memberType = completePackage.getMemberType(name); |
| if (memberType == primaryElement) { |
| if ((eObject != scope) && (eObject != PivotUtil.getContainingPackage(scope))) { |
| eObject = eObject.eContainer(); // If eObject is needed in path, optional scope is its container |
| } |
| if (eObject instanceof Namespace) { |
| safeScope = (Namespace) eObject; |
| } |
| break; |
| } |
| } |
| } |
| } |
| List<PathElementCS> csPath = csPathName.getOwnedPathElements(); |
| csPath.clear(); // FIXME re-use |
| PathElementCS csSimpleRef = BaseCSFactory.eINSTANCE.createPathElementCS(); |
| csPath.add(csSimpleRef); |
| csSimpleRef.setReferredElement(primaryElement); |
| BaseCSResource csResource2 = this.csResource; |
| if ((csResource2 == null) || (csResource2.isPathable(primaryElement) == null)) { |
| return; |
| } |
| for (EObject eContainer = primaryElement.eContainer(); eContainer instanceof Element; eContainer = eContainer.eContainer()) { |
| if (eContainer instanceof Model) { |
| return; // Skip root package |
| } |
| for (EObject aScope = safeScope; aScope != null; aScope = aScope.eContainer()) { |
| if (metaModelManager.getPrimaryElement(aScope) == metaModelManager.getPrimaryElement(eContainer)) { // If element ancestor is scope or an ancestor |
| return; // no need for further qualification |
| } |
| } |
| csSimpleRef = BaseCSFactory.eINSTANCE.createPathElementCS(); |
| csPath.add(0, csSimpleRef); |
| csSimpleRef.setReferredElement((Element) eContainer); |
| } |
| } |
| |
| public void refreshQualifiers(List<String> qualifiers, String string, boolean polarity) { |
| for (String qualifier : qualifiers) { |
| if (qualifier.equals(string)) { |
| if (!polarity) { |
| qualifiers.remove(qualifier); |
| } |
| return; |
| } |
| } |
| if (polarity) { |
| qualifiers.add(string); |
| } |
| } |
| |
| public <T extends StructuralFeatureCS> T refreshStructuralFeature(@NonNull Class<T> csClass, /*@NonNull */EClass csEClass, @NonNull Property object) { |
| T csElement = refreshTypedElement(csClass, csEClass, object); |
| csElement.setIsDerived(object.isDerived()); |
| csElement.setIsReadonly(object.isReadOnly()); |
| csElement.setIsStatic(object.isStatic()); |
| csElement.setIsTransient(object.isTransient()); |
| csElement.setIsUnsettable(object.isUnsettable()); |
| csElement.setIsVolatile(object.isVolatile()); |
| csElement.setDefault(object.getDefaultValueString()); |
| return csElement; |
| } |
| |
| public <T extends TypedElementCS> T refreshTypedElement(@NonNull Class<T> csClass, /*@NonNull */EClass csEClass, @NonNull TypedElement object) { |
| T csElement = refreshNamedElement(csClass, csEClass, object); |
| final Type type = object.getType(); |
| final Type elementType; |
| if ((type instanceof CollectionType) && (((CollectionType)type).getUnspecializedElement() != standardLibrary.getCollectionType())) { |
| PivotUtil.debugWellContainedness(type); |
| elementType = ((CollectionType)type).getElementType(); |
| } |
| else if (type instanceof VoidType) { |
| elementType = null; |
| } |
| else { |
| elementType = type; |
| } |
| if (elementType != null) { |
| PivotUtil.debugWellContainedness(elementType); |
| TypedRefCS typeRef = visitReference(TypedRefCS.class, elementType, null); |
| csElement.setOwnedType(typeRef); |
| } |
| else { |
| csElement.setOwnedType(null); |
| } |
| TypedRefCS csTypeRef = csElement.getOwnedType(); |
| if (csTypeRef != null) { |
| int lower; |
| int upper; |
| if ((type instanceof CollectionType) && (((CollectionType)type).getUnspecializedElement() != standardLibrary.getCollectionType())) { |
| CollectionType collectionType = (CollectionType)type; |
| lower = collectionType.getLower().intValue(); |
| Number upper2 = collectionType.getUpper(); |
| upper = upper2 instanceof Unlimited ? -1 : upper2.intValue(); |
| csElement.setIsOrdered(collectionType.isOrdered()); |
| csElement.setIsNotUnique(!collectionType.isUnique()); |
| } |
| else { |
| lower = object.isRequired() ? 1 : 0; |
| upper = 1; |
| } |
| if ((lower == 1) && (upper == 1)) { |
| csTypeRef.setOwnedMultiplicity(null); |
| } |
| else { |
| String stringValue = null; |
| if (lower == 0) { |
| if (upper == 1) { |
| stringValue = "?"; |
| } |
| else if (upper == -1) { |
| stringValue = "*"; |
| } |
| // else if (upper == -2) { |
| // stringValue = "0..?"; |
| // } |
| } |
| else if (lower == 1) { |
| if (upper == -1) { |
| stringValue = "+"; |
| } |
| } |
| if (stringValue != null) { |
| MultiplicityStringCS csMultiplicity = BaseCSFactory.eINSTANCE.createMultiplicityStringCS(); |
| csMultiplicity.setStringBounds(stringValue); |
| csTypeRef.setOwnedMultiplicity(csMultiplicity); |
| } |
| else { |
| MultiplicityBoundsCS csMultiplicity = BaseCSFactory.eINSTANCE.createMultiplicityBoundsCS(); |
| if (lower != 1) { |
| csMultiplicity.setLowerBound(lower); |
| } |
| if (upper != 1) { |
| csMultiplicity.setUpperBound(upper); |
| } |
| csTypeRef.setOwnedMultiplicity(csMultiplicity); |
| } |
| } |
| } |
| return csElement; |
| } |
| |
| public org.eclipse.ocl.pivot.Class setScope(org.eclipse.ocl.pivot.Class object) { |
| org.eclipse.ocl.pivot.Class savedScope = scope; |
| this.scope = object; |
| return savedScope; |
| } |
| |
| /** |
| * Sequence the update passes to make the pivot match the CS. |
| * @param csResources |
| */ |
| public void update(@NonNull BaseCSResource csResource) { |
| this.csResource = csResource; |
| // Map<Resource, Map<Namespace, List<String>>> imports = new HashMap<Resource, Map<Namespace, List<String>>>(); |
| // |
| // Perform the pre-order traversal to create the CS for each declaration. A |
| // separate reference pass is not needed since references are to the pivot model. |
| // |
| importedNamespaces = new HashMap<Namespace, List<String>>(); |
| Resource asResource = converter.getPivotResource(csResource); |
| if (asResource != null) { |
| List<PackageCS> list = visitDeclarations(PackageCS.class, asResource.getContents(), null); |
| refreshList(csResource.getContents(), list); |
| if (importedNamespaces != null) { |
| defaultDeclarationVisitor.postProcess(csResource, importedNamespaces); |
| } |
| // imports.put(csResource, importedNamespaces); |
| } |
| } |
| |
| public @Nullable <T extends ElementCS> T visitDeclaration(@NonNull Class<T> csClass, @Nullable EObject eObject) { |
| if (eObject == null) { |
| return null; |
| } |
| @SuppressWarnings("null") @NonNull EClass eClass = eObject.eClass(); |
| BaseDeclarationVisitor declarationVisitor = getDeclarationVisitor(eClass); |
| if ((declarationVisitor == null) || !(eObject instanceof Visitable)) { |
| logger.warn("Unsupported declaration " + eClass.getName()); |
| return null; |
| } |
| ElementCS csElement = ((Visitable)eObject).accept(declarationVisitor); |
| @SuppressWarnings("unchecked") |
| T castElement = (T) csElement; |
| return castElement; |
| } |
| |
| public @Nullable <T extends ElementCS, V extends EObject> List<T> visitDeclarationAsList(@NonNull Class<T> csClass, @Nullable V eObject) { |
| if (eObject == null) { |
| return null; |
| } |
| T csElement = visitDeclaration(csClass, eObject); |
| if (csElement == null) { |
| return null; |
| } |
| return Collections.singletonList(csElement); |
| } |
| |
| public @NonNull <T extends ElementCS, V extends EObject> List<T> visitDeclarations(@NonNull Class<T> csClass, /*@NonNull*/ List<V> eObjects, @Nullable AS2CS.Predicate<V> predicate) { |
| assert eObjects != null; |
| List<T> csElements = new ArrayList<T>(); |
| for (V eObject : eObjects) { |
| if ((eObject != null) && ((predicate == null) || predicate.filter(eObject))) { |
| T csElement = visitDeclaration(csClass, eObject); |
| if (csElement != null) { |
| csElements.add(csElement); |
| } |
| } |
| } |
| return csElements; |
| } |
| |
| public @Nullable <T extends ElementCS> T visitReference(@NonNull Class<T> csClass, @NonNull EObject eObject, @Nullable Namespace scope) { |
| @SuppressWarnings("null") @NonNull EClass eClass = eObject.eClass(); |
| BaseReferenceVisitor referenceVisitor = getReferenceVisitor(eClass, scope); |
| if ((referenceVisitor == null) || !(eObject instanceof Visitable)) { |
| logger.warn("Unsupported reference " + eObject.eClass().getName()); |
| return null; |
| } |
| ElementCS csElement = ((Visitable)eObject).accept(referenceVisitor); |
| if (csElement == null) { |
| return null; |
| } |
| if (!csClass.isAssignableFrom(csElement.getClass())) { |
| logger.error("CS " + csElement.getClass().getName() + "' element is not a '" + csClass.getName() + "'"); //$NON-NLS-1$ |
| return null; |
| } |
| @SuppressWarnings("unchecked") |
| T castElement = (T) csElement; |
| return castElement; |
| } |
| |
| public @NonNull <T extends ElementCS, V extends EObject> List<T> visitReferences(@NonNull Class<T> csClass, /*@NonNull*/ List<? extends V> eObjects, @Nullable AS2CS.Predicate<V> predicate) { |
| assert eObjects != null; |
| List<T> csElements = new ArrayList<T>(); |
| for (V eObject : eObjects) { |
| if ((eObject != null) && ((predicate == null) || predicate.filter(eObject))) { |
| T csElement = visitReference(csClass, eObject, null); |
| if (csElement != null) { |
| csElements.add(csElement); |
| } |
| } |
| } |
| return csElements; |
| } |
| } |
