| /******************************************************************************* |
| * Copyright (c) 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.examples.build.xtend; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.Comparator; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| import org.eclipse.emf.common.util.TreeIterator; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.ecore.resource.Resource; |
| import org.eclipse.emf.ecore.resource.ResourceSet; |
| import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl; |
| import org.eclipse.emf.ecore.util.EcoreUtil; |
| import org.eclipse.jdt.annotation.NonNull; |
| import org.eclipse.jdt.annotation.Nullable; |
| import org.eclipse.ocl.examples.codegen.oclinecore.OCLinEcoreTablesUtils; |
| import org.eclipse.ocl.pivot.CollectionType; |
| import org.eclipse.ocl.pivot.Comment; |
| import org.eclipse.ocl.pivot.Constraint; |
| import org.eclipse.ocl.pivot.DataType; |
| import org.eclipse.ocl.pivot.Element; |
| import org.eclipse.ocl.pivot.Enumeration; |
| import org.eclipse.ocl.pivot.Iteration; |
| import org.eclipse.ocl.pivot.LambdaType; |
| import org.eclipse.ocl.pivot.LanguageExpression; |
| import org.eclipse.ocl.pivot.Library; |
| import org.eclipse.ocl.pivot.MapType; |
| import org.eclipse.ocl.pivot.Model; |
| import org.eclipse.ocl.pivot.NamedElement; |
| import org.eclipse.ocl.pivot.Operation; |
| import org.eclipse.ocl.pivot.Package; |
| import org.eclipse.ocl.pivot.Parameter; |
| import org.eclipse.ocl.pivot.Precedence; |
| import org.eclipse.ocl.pivot.PrimitiveType; |
| import org.eclipse.ocl.pivot.Property; |
| import org.eclipse.ocl.pivot.TemplateBinding; |
| import org.eclipse.ocl.pivot.TemplateParameter; |
| import org.eclipse.ocl.pivot.TemplateParameterSubstitution; |
| import org.eclipse.ocl.pivot.TemplateSignature; |
| import org.eclipse.ocl.pivot.TemplateableElement; |
| import org.eclipse.ocl.pivot.TupleType; |
| import org.eclipse.ocl.pivot.Type; |
| import org.eclipse.ocl.pivot.internal.complete.StandardLibraryInternal; |
| import org.eclipse.ocl.pivot.internal.utilities.AS2Moniker; |
| import org.eclipse.ocl.pivot.internal.utilities.EnvironmentFactoryInternal; |
| import org.eclipse.ocl.pivot.internal.utilities.PivotUtilInternal; |
| import org.eclipse.ocl.pivot.utilities.Nameable; |
| import org.eclipse.ocl.pivot.utilities.PivotConstants; |
| import org.eclipse.ocl.pivot.utilities.PivotUtil; |
| import org.eclipse.xtext.util.Strings; |
| |
| @SuppressWarnings("all") |
| public abstract class GenerateOCLCommon extends GenerateMetamodelWorkflowComponent |
| { |
| private final @NonNull Map<Element, String> element2moniker = new HashMap<Element, String>(); |
| private final @NonNull Map<NamedElement, String> external2name = new HashMap<NamedElement, String>(); |
| protected final @NonNull Map<String, NamedElement> name2external = new HashMap<String, NamedElement>(); |
| |
| public static final @NonNull Comparator<Property> classPropertyComparator = new Comparator<Property>() |
| { |
| @Override |
| public int compare(Property p1, Property p2) { |
| String c1 = String.valueOf(p1.getOwningClass().getName()); |
| String c2 = String.valueOf(p2.getOwningClass().getName()); |
| int diff = c1.compareTo(c2); |
| if (diff != 0) { |
| return diff; |
| } |
| boolean b1 = p1.isIsImplicit(); |
| boolean b2 = p2.isIsImplicit(); |
| if (b1 != b2) { |
| return b1 ? 1 : -1; |
| } |
| String n1 = String.valueOf(p1.getName()); |
| String n2 = String.valueOf(p2.getName()); |
| diff = n1.compareTo(n2); |
| if (diff != 0) { |
| return diff; |
| } |
| Property o1 = p1.getOpposite(); |
| Property o2 = p2.getOpposite(); |
| if (o1 == null) { |
| if (o2 == null) { |
| return 0; |
| } |
| else { |
| return 1; |
| } |
| } |
| else { |
| if (o2 == null) { |
| return -1; |
| } |
| else { |
| n1 = String.valueOf(o1.getName()); |
| n2 = String.valueOf(o2.getName()); |
| return n1.compareTo(n2); |
| } |
| } |
| } |
| }; |
| |
| protected final @NonNull Comparator<Comment> commentComparator = new Comparator<Comment>() |
| { |
| public int compare(Comment o1, Comment o2) { |
| String m1 = o1.getBody(); |
| String m2 = o2.getBody(); |
| return m1.compareTo(m2); |
| } |
| }; |
| |
| protected final @NonNull Comparator<Element> monikerComparator = new Comparator<Element>() |
| { |
| public int compare(Element o1, Element o2) { |
| String m1 = getMoniker(o1); |
| String m2 = getMoniker(o2); |
| return m1.compareTo(m2); |
| } |
| }; |
| |
| protected final @NonNull Comparator<Nameable> nameableComparator = new Comparator<Nameable>() |
| { |
| public int compare(Nameable o1, Nameable o2) { |
| String m1 = o1.getName(); |
| String m2 = o2.getName(); |
| return m1.compareTo(m2); |
| } |
| }; |
| |
| protected void addExternalReference(@NonNull NamedElement reference, @NonNull Model root) { |
| Model containingModel = PivotUtil.getContainingModel(reference); |
| if ((containingModel == root) || external2name.containsKey(reference)) { |
| return; |
| } |
| EObject eContainer = reference.eContainer(); |
| if (eContainer instanceof Library) { |
| String name = reference.getName(); |
| if ("OclAny".equals(name)) { |
| name2external.put("_OclAny", reference); |
| external2name.put(reference, "_OclAny"); |
| return; |
| } |
| else if ("OclElement".equals(name)) { |
| name2external.put("_OclElement", reference); |
| external2name.put(reference, "_OclElement"); |
| return; |
| } |
| } |
| if (eContainer instanceof NamedElement) { |
| addExternalReference((NamedElement)eContainer, root); |
| } |
| String name; |
| if (reference instanceof NamedElement) { |
| int depth = 0; |
| for (EObject eObj = reference; eObj != null; eObj = eObj.eContainer()) { |
| depth++; |
| } |
| name = "X" + depth + "_" + ((NamedElement)reference).getName(); |
| } |
| else { |
| name = "X_" + name2external.size(); |
| } |
| if (name2external.containsKey(name)) { |
| for (int i = 0; true; i++) { |
| String suffixedName = name + "_" + i; |
| if (!name2external.containsKey(suffixedName)) { |
| name = suffixedName; |
| break; |
| } |
| } |
| } |
| name2external.put(name, reference); |
| external2name.put(reference, name); |
| } |
| |
| protected @NonNull Set<CollectionType> getAllCollectionTypes(@NonNull Model root) { |
| Set<CollectionType> allElements = new HashSet<CollectionType>(); |
| TreeIterator<EObject> tit = root.eAllContents(); |
| while (tit.hasNext()) { |
| EObject eObject = tit.next(); |
| if (eObject instanceof CollectionType) { |
| allElements.add((CollectionType)eObject); |
| } |
| } |
| return allElements; |
| } |
| |
| protected @NonNull Set<Enumeration> getAllEnumerations(@NonNull Model root) { |
| Set<Enumeration> allElements = new HashSet<Enumeration>(); |
| TreeIterator<EObject> tit = root.eAllContents(); |
| while (tit.hasNext()) { |
| EObject eObject = tit.next(); |
| if (eObject instanceof Enumeration) { |
| allElements.add((Enumeration)eObject); |
| } |
| } |
| return allElements; |
| } |
| |
| protected @NonNull Set<LambdaType> getAllLambdaTypes(@NonNull Model root) { |
| Set<LambdaType> allElements = new HashSet<LambdaType>(); |
| TreeIterator<EObject> tit = root.eAllContents(); |
| while (tit.hasNext()) { |
| EObject eObject = tit.next(); |
| if (eObject instanceof LambdaType) { |
| allElements.add((LambdaType)eObject); |
| } |
| } |
| return allElements; |
| } |
| |
| protected @NonNull Set<MapType> getAllMapTypes(@NonNull Model root) { |
| Set<MapType> allElements = new HashSet<MapType>(); |
| TreeIterator<EObject> tit = root.eAllContents(); |
| while (tit.hasNext()) { |
| EObject eObject = tit.next(); |
| if (eObject instanceof MapType) { |
| allElements.add((MapType)eObject); |
| } |
| } |
| return allElements; |
| } |
| |
| protected @NonNull List<org.eclipse.ocl.pivot.Package> getAllPackages(@NonNull Model root) { |
| Set<org.eclipse.ocl.pivot.Package> allElements = new HashSet<org.eclipse.ocl.pivot.Package>(); |
| TreeIterator<EObject> tit = root.eAllContents(); |
| while (tit.hasNext()) { |
| EObject eObject = tit.next(); |
| if (eObject instanceof org.eclipse.ocl.pivot.Package) { |
| allElements.add((org.eclipse.ocl.pivot.Package)eObject); |
| } |
| } |
| List<org.eclipse.ocl.pivot.Package> sortedElements = new ArrayList<org.eclipse.ocl.pivot.Package>(allElements); |
| Collections.sort(sortedElements, monikerComparator); |
| return sortedElements; |
| } |
| |
| protected @NonNull Set<Precedence> getAllPrecedences(@NonNull Model root) { |
| Set<Precedence> allElements = new HashSet<Precedence>(); |
| TreeIterator<EObject> tit = root.eAllContents(); |
| while (tit.hasNext()) { |
| EObject eObject = tit.next(); |
| if (eObject instanceof Precedence) { |
| allElements.add((Precedence)eObject); |
| } |
| } |
| return allElements; |
| } |
| |
| protected @NonNull Set<PrimitiveType> getAllPrimitiveTypes(@NonNull Model root) { |
| Set<PrimitiveType> allElements = new HashSet<PrimitiveType>(); |
| TreeIterator<EObject> tit = root.eAllContents(); |
| while (tit.hasNext()) { |
| EObject eObject = tit.next(); |
| if (eObject instanceof PrimitiveType) { |
| allElements.add((PrimitiveType)eObject); |
| } |
| } |
| return allElements; |
| } |
| |
| protected @NonNull List<Property> getAllProperties(@NonNull Model root) { |
| List<Property> allElements = new ArrayList<Property>(); |
| TreeIterator<EObject> tit = root.eAllContents(); |
| while (tit.hasNext()) { |
| EObject eObject = tit.next(); |
| if ((eObject instanceof Property) && !(eObject.eContainer() instanceof TupleType) && |
| (((Property)eObject).getOwningClass() != null)) { |
| allElements.add((Property)eObject); |
| } |
| } |
| return allElements; |
| } |
| |
| protected @NonNull Set<TemplateBinding> getAllTemplateBindings(@NonNull Model root) { |
| Set<TemplateBinding> allElements = new HashSet<TemplateBinding>(); |
| TreeIterator<EObject> tit = root.eAllContents(); |
| while (tit.hasNext()) { |
| EObject eObject = tit.next(); |
| if (eObject instanceof TemplateBinding) { |
| allElements.add((TemplateBinding)eObject); |
| } |
| } |
| return allElements; |
| } |
| |
| protected @NonNull Set<TemplateSignature> getAllTemplateSignatures(@NonNull Model root) { |
| Set<TemplateSignature> allElements = new HashSet<TemplateSignature>(); |
| TreeIterator<EObject> tit = root.eAllContents(); |
| while (tit.hasNext()) { |
| EObject eObject = tit.next(); |
| if (eObject instanceof TemplateSignature) { |
| allElements.add((TemplateSignature)eObject); |
| } |
| } |
| return allElements; |
| } |
| |
| protected @NonNull Set<TupleType> getAllTupleTypes(@NonNull Model root) { |
| Set<TupleType> allElements = new HashSet<TupleType>(); |
| TreeIterator<EObject> tit = root.eAllContents(); |
| while (tit.hasNext()) { |
| EObject eObject = tit.next(); |
| if (eObject instanceof TupleType) { |
| allElements.add((TupleType)eObject); |
| } |
| } |
| return allElements; |
| } |
| |
| protected @NonNull Set<org.eclipse.ocl.pivot.Class> getAllTypes(@NonNull Model root) { |
| Set<org.eclipse.ocl.pivot.Class> allElements = new HashSet<org.eclipse.ocl.pivot.Class>(); |
| TreeIterator<EObject> tit = root.eAllContents(); |
| while (tit.hasNext()) { |
| EObject eObject = tit.next(); |
| if (eObject instanceof org.eclipse.ocl.pivot.Class) { |
| allElements.add((org.eclipse.ocl.pivot.Class)eObject); |
| } |
| } |
| return allElements; |
| } |
| |
| protected @Nullable List<org.eclipse.ocl.pivot.Class> getClassTypes(@NonNull Package pkge) { |
| List<org.eclipse.ocl.pivot.Class> classTypes = null; |
| for (org.eclipse.ocl.pivot.Class type : pkge.getOwnedClasses()) { |
| boolean useIt = false; |
| if (type instanceof CollectionType) { |
| useIt = false; |
| } |
| else if (type instanceof Enumeration) { |
| useIt = false; |
| } |
| else if (type instanceof LambdaType) { |
| useIt = false; |
| } |
| else if (type instanceof MapType) { |
| useIt = false; |
| } |
| else if (type instanceof PrimitiveType) { |
| useIt = false; |
| } |
| else if (type instanceof TupleType) { |
| useIt = false; |
| } |
| else if (type.isTemplateParameter() != null) { |
| useIt = false; |
| } |
| else { |
| useIt = true; |
| } |
| if (useIt) { |
| if (classTypes == null) { |
| classTypes = new ArrayList<org.eclipse.ocl.pivot.Class>(); |
| } |
| classTypes.add(type); |
| } |
| } |
| return classTypes; |
| } |
| |
| protected String getExternalReference(@NonNull Element element) { |
| EObject eContainer = element.eContainer(); |
| if (eContainer == null) { |
| if (element instanceof Model) { |
| return "get" + element.eClass().getName() + "(\"" + ((Model)element).getExternalURI() + "\")"; |
| } |
| } |
| else { |
| if ((element instanceof TemplateParameter) && (eContainer instanceof TemplateSignature)) { |
| TemplateSignature templateSignature = (TemplateSignature)eContainer; |
| TemplateableElement templateableElement = templateSignature.getOwningElement(); |
| if (templateableElement != null) { |
| return "get" + element.eClass().getName() + "(" + external2name.get(eContainer.eContainer()) + ", " + templateSignature.getOwnedParameters().indexOf(element) + ")"; |
| } |
| } |
| if (element instanceof NamedElement) { |
| return "get" + element.eClass().getName() + "(" + external2name.get(eContainer) + ", \"" + ((NamedElement)element).getName() + "\")"; |
| } |
| } |
| return "\"" + EcoreUtil.getURI(element).toString() + "\""; |
| } |
| |
| protected @NonNull String getMoniker(@NonNull Element elem) { |
| String moniker = element2moniker.get(elem); |
| if (moniker == null) { |
| moniker = AS2Moniker.toString(elem); |
| element2moniker.put(elem, moniker); |
| } |
| return moniker; |
| } |
| |
| protected @NonNull Collection<org.eclipse.ocl.pivot.Class> zzgetOclTypes(@NonNull Model root) { |
| Set<org.eclipse.ocl.pivot.Class> allElements = new HashSet<org.eclipse.ocl.pivot.Class>(); |
| TreeIterator<EObject> tit = root.eAllContents(); |
| while (tit.hasNext()) { |
| EObject eObject = tit.next(); |
| boolean useIt = false; |
| if (eObject instanceof MapType) { |
| // if (((MapType)eObject).getUnspecializedElement() == null) { |
| useIt = false; |
| // } |
| } |
| else if ((eObject instanceof org.eclipse.ocl.pivot.Class) && !(eObject instanceof Enumeration) && !(eObject instanceof LambdaType) && |
| !(eObject instanceof CollectionType) && !(eObject instanceof PrimitiveType) && |
| !(eObject instanceof TupleType) && |
| (((org.eclipse.ocl.pivot.Class)eObject).isTemplateParameter() == null)) { |
| useIt = true; |
| } |
| if (useIt) { |
| allElements.add((org.eclipse.ocl.pivot.Class)eObject); |
| } |
| } |
| return allElements; |
| } |
| |
| protected @Nullable org.eclipse.ocl.pivot.Package getOnlyPackage(@NonNull Model model) { |
| org.eclipse.ocl.pivot.Package onlyPackage = null; |
| for (org.eclipse.ocl.pivot.Package asPackage : model.getOwnedPackages()) { |
| if (PivotConstants.ORPHANAGE_NAME.equals(asPackage.getName())) { |
| ; |
| } |
| else if (onlyPackage != null) { |
| return null; |
| } |
| else { |
| onlyPackage = asPackage; |
| } |
| } |
| return onlyPackage; |
| } |
| |
| |
| protected @NonNull org.eclipse.ocl.pivot.Package getOrphanPackage(@NonNull org.eclipse.ocl.pivot.Package elem) { |
| return getOrphanPackage(getRootPackage(elem)); |
| } |
| |
| protected @NonNull org.eclipse.ocl.pivot.Package getOrphanPackage(@NonNull Model elem) { |
| for (org.eclipse.ocl.pivot.Package pkg : getAllPackages(elem)) { |
| if (PivotConstants.ORPHANAGE_NAME.equals(pkg.getName())) { |
| return pkg; |
| } |
| } |
| throw new IllegalStateException("Missing orphan package"); |
| } |
| |
| protected @NonNull String getPartialName(@NonNull Property property) { |
| org.eclipse.ocl.pivot.Class owningType = property.getOwningClass(); |
| if (owningType == null) { |
| return "null_" + javaName(property); |
| } |
| String simpleName = partialName(owningType) + "_" + javaName(property); |
| if (!property.isIsImplicit()) { |
| return simpleName; |
| } |
| Property opposite = property.getOpposite(); |
| if (opposite == null) { |
| return simpleName; |
| } |
| else { |
| return simpleName + "_" + javaName(opposite); |
| } |
| } |
| |
| protected String getPrefixedSymbolName(@NonNull EObject elem, @NonNull String prefix) { |
| EnvironmentFactoryInternal environmentFactory = PivotUtilInternal.findEnvironmentFactory(elem); |
| if (environmentFactory != null) { |
| elem = environmentFactory.getMetamodelManager().getPrimaryElement(elem); |
| } |
| return NameQueries.getPrefixedSymbolName(prefix, elem); |
| } |
| |
| protected ResourceSet getResourceSet() { |
| if (resourceSet == null) { |
| resourceSet = new ResourceSetImpl(); |
| } |
| return resourceSet; |
| } |
| |
| protected @NonNull Model getRootPackage(@Nullable org.eclipse.ocl.pivot.Package elem) { |
| EObject eObject = elem; |
| while (eObject != null) { |
| if (eObject instanceof Model) { |
| return (Model)eObject; |
| } |
| eObject = eObject.eContainer(); |
| } |
| throw new IllegalStateException("Missing Root"); |
| } |
| |
| protected String getSignature(@NonNull NamedElement elem) { |
| EObject parent = elem.eContainer(); |
| if (parent != null) { |
| return getSignature((NamedElement)parent) + "::" + elem.getName(); |
| } else { |
| return elem.getName(); |
| } |
| } |
| |
| protected String getSignature(@NonNull Operation elem) { |
| EObject parent = elem.eContainer(); |
| if (parent != null) { |
| return getSignature((NamedElement)parent) + "::" + elem.getName() + "()"; |
| } else { |
| return elem.getName() + "()"; |
| } |
| } |
| |
| protected @NonNull List<Operation> getSortedCoercions(@NonNull Model root) { |
| Set<Operation> allElements = new HashSet<Operation>(); |
| TreeIterator<EObject> tit = root.eAllContents(); |
| while (tit.hasNext()) { |
| EObject eObject = tit.next(); |
| if (eObject instanceof PrimitiveType) { |
| allElements.addAll(((PrimitiveType)eObject).getCoercions()); |
| } |
| } |
| List<Operation> sortedElements = new ArrayList<Operation>(allElements); |
| Collections.sort(sortedElements, monikerComparator); |
| return sortedElements; |
| } |
| |
| protected @NonNull List<Operation> getSortedCoercions(@NonNull PrimitiveType type, @NonNull List<Operation> allCoercions) { |
| Set<Operation> allElements = new HashSet<Operation>(); |
| for (Operation coercion : type.getCoercions()) { |
| if (allCoercions.contains(coercion)) { |
| allElements.add(coercion); |
| } |
| } |
| List<Operation> sortedElements = new ArrayList<Operation>(allElements); |
| Collections.sort(sortedElements, monikerComparator); |
| return sortedElements; |
| } |
| |
| protected @NonNull Map<org.eclipse.ocl.pivot.Package, List<org.eclipse.ocl.pivot.Class>> getSortedClassTypes(@NonNull Model root) { |
| Map<org.eclipse.ocl.pivot.Package, List<org.eclipse.ocl.pivot.Class>> pkge2classTypes = new HashMap<org.eclipse.ocl.pivot.Package, List<org.eclipse.ocl.pivot.Class>>(); |
| for (org.eclipse.ocl.pivot.Package pkge : root.getOwnedPackages()) { |
| List<org.eclipse.ocl.pivot.Class> classTypes = getClassTypes(pkge); |
| if (classTypes != null) { |
| pkge2classTypes.put(pkge, classTypes); |
| Collections.sort(classTypes, monikerComparator); |
| } |
| } |
| return pkge2classTypes; |
| } |
| |
| protected abstract @NonNull Map<org.eclipse.ocl.pivot.Package, List<CollectionType>> getSortedCollectionTypes(@NonNull Model root); |
| |
| protected @NonNull Map<org.eclipse.ocl.pivot.Package, List<CollectionType>> getSortedCollectionTypes(@NonNull Model root, Comparator<? super CollectionType> comparator) { |
| Map<org.eclipse.ocl.pivot.Package, List<CollectionType>> pkge2collectionTypes = new HashMap<org.eclipse.ocl.pivot.Package, List<CollectionType>>(); |
| for (org.eclipse.ocl.pivot.Package pkge : root.getOwnedPackages()) { |
| List<CollectionType> collectionTypes = null; |
| for (Type type : pkge.getOwnedClasses()) { |
| if (type instanceof CollectionType) { |
| if (collectionTypes == null) { |
| collectionTypes = new ArrayList<CollectionType>(); |
| pkge2collectionTypes.put(pkge, collectionTypes); |
| } |
| collectionTypes.add((CollectionType)type); |
| } |
| } |
| if (collectionTypes != null) { |
| Collections.sort(collectionTypes, comparator); |
| } |
| } |
| return pkge2collectionTypes; |
| } |
| |
| protected @NonNull List<Element> getSortedCommentedElements(@NonNull Model root) { |
| List<Element> allClassTypes = new ArrayList<Element>(); |
| for (org.eclipse.ocl.pivot.Package pkge : root.getOwnedPackages()) { |
| List<org.eclipse.ocl.pivot.Class> classTypes = getClassTypes(pkge); |
| if (classTypes != null) { |
| allClassTypes.addAll(classTypes); |
| } |
| } |
| Collections.sort(allClassTypes, monikerComparator); |
| return allClassTypes; |
| } |
| |
| protected @NonNull List<Comment> getSortedComments(@NonNull Element element) { |
| List<Comment> sortedElements = new ArrayList<Comment>(element.getOwnedComments()); |
| Collections.sort(sortedElements, commentComparator); |
| return sortedElements; |
| } |
| |
| protected @NonNull Map<org.eclipse.ocl.pivot.Package, List<Enumeration>> getSortedEnumerations(@NonNull Model root) { |
| Map<org.eclipse.ocl.pivot.Package, List<Enumeration>> pkge2enumerations = new HashMap<org.eclipse.ocl.pivot.Package, List<Enumeration>>(); |
| for (org.eclipse.ocl.pivot.Package pkge : root.getOwnedPackages()) { |
| List<Enumeration> enumerations = null; |
| for (Type type : pkge.getOwnedClasses()) { |
| if (type instanceof Enumeration) { |
| if (enumerations == null) { |
| enumerations = new ArrayList<Enumeration>(); |
| pkge2enumerations.put(pkge, enumerations); |
| } |
| enumerations.add((Enumeration)type); |
| } |
| } |
| if (enumerations != null) { |
| Collections.sort(enumerations, nameableComparator); |
| } |
| } |
| return pkge2enumerations; |
| } |
| |
| protected @NonNull List<String> getSortedExternals(@NonNull Model root) { |
| if (name2external.size() <= 0) { |
| Set<Element> allReferences = new HashSet<Element>(); |
| TreeIterator<EObject> tit = root.eAllContents(); |
| while (tit.hasNext()) { |
| EObject eObject = tit.next(); |
| if (eObject instanceof CollectionType) { |
| CollectionType collectionType = (CollectionType)eObject; |
| addExternalReference(collectionType, root); |
| TemplateableElement unspecializedElement = collectionType.getUnspecializedElement(); |
| if (unspecializedElement instanceof NamedElement) { |
| addExternalReference((NamedElement) unspecializedElement, root); |
| } |
| } |
| else if (eObject instanceof TemplateParameterSubstitution) { |
| TemplateParameterSubstitution templateParameterSubstitution = (TemplateParameterSubstitution)eObject; |
| addExternalReference(templateParameterSubstitution.getActual(), root); |
| addExternalReference(templateParameterSubstitution.getFormal(), root); |
| } |
| } |
| if (name2external.size() > 0) { |
| EnvironmentFactoryInternal environmentFactory = PivotUtilInternal.findEnvironmentFactory(root); |
| if (environmentFactory != null) { |
| StandardLibraryInternal standardLibrary = environmentFactory.getStandardLibrary(); |
| addExternalReference(standardLibrary.getOclAnyType(), root); |
| addExternalReference(standardLibrary.getOclElementType(), root); |
| } |
| } |
| } |
| List<String> sortedExternals = new ArrayList<String>(name2external.keySet()); |
| Collections.sort(sortedExternals); |
| return sortedExternals; |
| } |
| |
| protected @NonNull List<String> getSortedImports(@NonNull Model model) { |
| if (name2external.size() <= 0) { |
| getSortedExternals(model); |
| } |
| List<String> imports = new ArrayList<String>(); |
| for (Map.Entry<String, NamedElement> entry : name2external.entrySet()) { |
| if (entry.getValue() instanceof Library) { |
| imports.add(entry.getKey()); |
| } |
| } |
| return imports; |
| } |
| |
| |
| /* protected @NonNull List<Iteration> getSortedIterations(@NonNull Model root) { |
| Set<Iteration> allElements = new HashSet<Iteration>(); |
| TreeIterator<EObject> tit = root.eAllContents(); |
| while (tit.hasNext()) { |
| EObject eObject = tit.next(); |
| if (eObject instanceof Iteration) { |
| allElements.add((Iteration)eObject); |
| } |
| } |
| List<Iteration> sortedElements = new ArrayList<Iteration>(allElements); |
| Collections.sort(sortedElements, monikerComparator); |
| return sortedElements; |
| } */ |
| |
| protected @NonNull Map<org.eclipse.ocl.pivot.Package, List<Iteration>> getSortedIterations(@NonNull Model root) { |
| Map<org.eclipse.ocl.pivot.Package, List<Iteration>> pkge2iterations = new HashMap<org.eclipse.ocl.pivot.Package, List<Iteration>>(); |
| for (org.eclipse.ocl.pivot.Package pkge : root.getOwnedPackages()) { |
| List<Iteration> iterations = null; |
| for (org.eclipse.ocl.pivot.Class type : pkge.getOwnedClasses()) { |
| for (Operation operation : type.getOwnedOperations()) { |
| if (operation instanceof Iteration) { |
| if (iterations == null) { |
| iterations = new ArrayList<Iteration>(); |
| pkge2iterations.put(pkge, iterations); |
| } |
| iterations.add((Iteration) operation); |
| } |
| } |
| } |
| if (iterations != null) { |
| Collections.sort(iterations, monikerComparator); |
| } |
| } |
| return pkge2iterations; |
| } |
| |
| /* protected @NonNull List<Iteration> getSortedIterations(@NonNull org.eclipse.ocl.pivot.Class type, @NonNull List<Iteration> allIterations) { |
| Set<Iteration> allElements = new HashSet<Iteration>(); |
| for (Operation operation : type.getOwnedOperations()) { |
| if (allIterations.contains(operation)) { |
| allElements.add((Iteration)operation); |
| } |
| } |
| List<Iteration> sortedElements = new ArrayList<Iteration>(allElements); |
| Collections.sort(sortedElements, monikerComparator); |
| return sortedElements; |
| } */ |
| |
| protected @NonNull List<LambdaType> getSortedLambdaTypes(@NonNull Model root) { |
| Set<LambdaType> allElements = new HashSet<LambdaType>(); |
| TreeIterator<EObject> tit = root.eAllContents(); |
| while (tit.hasNext()) { |
| EObject eObject = tit.next(); |
| if (eObject instanceof LambdaType) { |
| allElements.add((LambdaType)eObject); |
| } |
| } |
| List<LambdaType> sortedElements = new ArrayList<LambdaType>(allElements); |
| Collections.sort(sortedElements, monikerComparator); |
| return sortedElements; |
| } |
| |
| protected @NonNull List<Library> getSortedLibraries(@NonNull Model root) { |
| Set<Library> allElements = new HashSet<Library>(); |
| TreeIterator<EObject> tit = root.eAllContents(); |
| while (tit.hasNext()) { |
| EObject eObject = tit.next(); |
| if (eObject instanceof Library) { |
| allElements.add((Library)eObject); |
| } |
| } |
| List<Library> sortedElements = new ArrayList<Library>(allElements); |
| Collections.sort(sortedElements, monikerComparator); |
| return sortedElements; |
| } |
| |
| protected @NonNull List<Library> getSortedLibrariesWithPrecedence(@NonNull Model root) { |
| Set<Library> allElements = new HashSet<Library>(); |
| TreeIterator<EObject> tit = root.eAllContents(); |
| while (tit.hasNext()) { |
| EObject eObject = tit.next(); |
| if ((eObject instanceof Library) && (((Library)eObject).getOwnedPrecedences().size() > 0)) { |
| allElements.add((Library)eObject); |
| } |
| } |
| List<Library> sortedElements = new ArrayList<Library>(allElements); |
| Collections.sort(sortedElements, monikerComparator); |
| return sortedElements; |
| } |
| |
| protected @NonNull <T extends Nameable> List<T> getSortedList(@NonNull Collection<? extends T> packages) { |
| List<T> sortedElements = new ArrayList<T>(packages); |
| Collections.sort(sortedElements, nameableComparator); |
| return sortedElements; |
| } |
| |
| protected @NonNull Map<org.eclipse.ocl.pivot.Package, List<MapType>> getSortedMapTypes(@NonNull Model root) { |
| Map<org.eclipse.ocl.pivot.Package, List<MapType>> pkge2mapTypes = new HashMap<org.eclipse.ocl.pivot.Package, List<MapType>>(); |
| for (org.eclipse.ocl.pivot.Package pkge : root.getOwnedPackages()) { |
| List<MapType> mapTypes = null; |
| for (Type type : pkge.getOwnedClasses()) { |
| if (type instanceof MapType) { |
| if (mapTypes == null) { |
| mapTypes = new ArrayList<MapType>(); |
| pkge2mapTypes.put(pkge, mapTypes); |
| } |
| mapTypes.add((MapType)type); |
| } |
| } |
| if (mapTypes != null) { |
| Collections.sort(mapTypes, monikerComparator); |
| } |
| } |
| return pkge2mapTypes; |
| } |
| |
| /* protected @NonNull List<Operation> getSortedOperations(@NonNull Model root) { |
| Set<Operation> allElements = new HashSet<Operation>(); |
| TreeIterator<EObject> tit = root.eAllContents(); |
| while (tit.hasNext()) { |
| EObject eObject = tit.next(); |
| if ((eObject instanceof Operation) && !(eObject instanceof Iteration) && |
| !isEcoreConstraint((Operation)eObject)) { |
| allElements.add((Operation)eObject); |
| } |
| } |
| List<Operation> sortedElements = new ArrayList<Operation>(allElements); |
| Collections.sort(sortedElements, monikerComparator); |
| return sortedElements; |
| } */ |
| |
| protected @NonNull Map<org.eclipse.ocl.pivot.Package, List<Operation>> getSortedOperations(@NonNull Model root) { |
| Map<org.eclipse.ocl.pivot.Package, List<Operation>> pkge2operations = new HashMap<org.eclipse.ocl.pivot.Package, List<Operation>>(); |
| for (org.eclipse.ocl.pivot.Package pkge : root.getOwnedPackages()) { |
| List<Operation> operations = null; |
| for (org.eclipse.ocl.pivot.Class type : pkge.getOwnedClasses()) { |
| for (Operation operation : type.getOwnedOperations()) { |
| if (!(operation instanceof Iteration)) { |
| if (operations == null) { |
| operations = new ArrayList<Operation>(); |
| pkge2operations.put(pkge, operations); |
| } |
| operations.add(operation); |
| } |
| } |
| } |
| if (operations != null) { |
| Collections.sort(operations, monikerComparator); |
| } |
| } |
| return pkge2operations; |
| } |
| |
| /* protected @NonNull List<Operation> getSortedOperations(@NonNull org.eclipse.ocl.pivot.Class type, @NonNull List<Operation> allOperations) { |
| Set<Operation> allElements = new HashSet<Operation>(); |
| for (Operation operation : type.getOwnedOperations()) { |
| if (allOperations.contains(operation)) { |
| allElements.add(operation); |
| } |
| } |
| List<Operation> sortedElements = new ArrayList<Operation>(allElements); |
| Collections.sort(sortedElements, monikerComparator); |
| return sortedElements; |
| } */ |
| |
| protected @NonNull List<Operation> getSortedOperationsWithPrecedence(@NonNull Model root) { |
| Set<Operation> allElements = new HashSet<Operation>(); |
| TreeIterator<EObject> tit = root.eAllContents(); |
| while (tit.hasNext()) { |
| EObject eObject = tit.next(); |
| if ((eObject instanceof Operation) && !(eObject instanceof Iteration) && |
| !isEcoreConstraint((Operation)eObject)) { |
| Operation operation = (Operation)eObject; |
| if (!(operation instanceof Iteration) && !isEcoreConstraint(operation) && |
| (operation.getPrecedence() != null)) { |
| allElements.add(operation); |
| } |
| } |
| } |
| List<Operation> sortedElements = new ArrayList<Operation>(allElements); |
| Collections.sort(sortedElements, monikerComparator); |
| return sortedElements; |
| } |
| |
| protected @NonNull List<org.eclipse.ocl.pivot.Class> getSortedOwningTypes(@NonNull List<? extends Operation> operations) { |
| Set<org.eclipse.ocl.pivot.Class> allElements = new HashSet<org.eclipse.ocl.pivot.Class>(); |
| for (Operation operation : operations) { |
| if (operation.getOwningClass() != null) { |
| allElements.add(operation.getOwningClass()); |
| } |
| } |
| List<org.eclipse.ocl.pivot.Class> sortedElements = new ArrayList<org.eclipse.ocl.pivot.Class>(allElements); |
| Collections.sort(sortedElements, monikerComparator); |
| return sortedElements; |
| } |
| |
| protected @NonNull List<org.eclipse.ocl.pivot.Class> getSortedOwningTypes2(@NonNull List<? extends Property> properties) { |
| Set<org.eclipse.ocl.pivot.Class> allElements = new HashSet<org.eclipse.ocl.pivot.Class>(); |
| for (Property property : properties) { |
| if (property.getOwningClass() != null) { |
| allElements.add(property.getOwningClass()); |
| } |
| } |
| List<org.eclipse.ocl.pivot.Class> sortedElements = new ArrayList<org.eclipse.ocl.pivot.Class>(allElements); |
| Collections.sort(sortedElements, monikerComparator); |
| return sortedElements; |
| } |
| |
| protected @NonNull List<org.eclipse.ocl.pivot.Package> getSortedPackages(@NonNull Model root, @NonNull Collection<? extends org.eclipse.ocl.pivot.Package> packages) { |
| Package orphanPackage = getOrphanPackage(root); |
| List<org.eclipse.ocl.pivot.Package> sortedElements = new ArrayList<org.eclipse.ocl.pivot.Package>(packages); |
| boolean removed = ((orphanPackage != null)) && sortedElements.remove(getOrphanPackage(root)); |
| Collections.sort(sortedElements, nameableComparator); |
| if (removed) { |
| sortedElements.add(orphanPackage); |
| } |
| return sortedElements; |
| } |
| |
| protected @NonNull List<org.eclipse.ocl.pivot.Package> getSortedPackages(@NonNull Model root) { |
| Set<org.eclipse.ocl.pivot.Package> allElements = new HashSet<org.eclipse.ocl.pivot.Package>(); |
| TreeIterator<EObject> tit = root.eAllContents(); |
| while (tit.hasNext()) { |
| EObject eObject = tit.next(); |
| if (eObject instanceof org.eclipse.ocl.pivot.Package) { |
| allElements.add((org.eclipse.ocl.pivot.Package)eObject); |
| } |
| } |
| List<org.eclipse.ocl.pivot.Package> sortedElements = new ArrayList<org.eclipse.ocl.pivot.Package>(allElements); |
| Collections.sort(sortedElements, nameableComparator); |
| return sortedElements; |
| } |
| |
| protected @NonNull List<org.eclipse.ocl.pivot.Package> getSortedPackages(@NonNull org.eclipse.ocl.pivot.Package pkg) { |
| List<org.eclipse.ocl.pivot.Package> sortedElements = new ArrayList<org.eclipse.ocl.pivot.Package>(pkg.getOwnedPackages()); |
| Collections.sort(sortedElements, nameableComparator); |
| return sortedElements; |
| } |
| |
| protected @NonNull List<org.eclipse.ocl.pivot.Class> getSortedParameterTypes(@NonNull Model root) { |
| Set<org.eclipse.ocl.pivot.Class> allElements = new HashSet<org.eclipse.ocl.pivot.Class>(); |
| TreeIterator<EObject> tit = root.eAllContents(); |
| while (tit.hasNext()) { |
| EObject eObject = tit.next(); |
| if (eObject instanceof org.eclipse.ocl.pivot.Class) { |
| org.eclipse.ocl.pivot.Class t = (org.eclipse.ocl.pivot.Class)eObject; |
| if (t.isTemplateParameter() != null) { // FIXME can never happen |
| allElements.add(t); |
| } |
| } |
| } |
| List<org.eclipse.ocl.pivot.Class> sortedElements = new ArrayList<org.eclipse.ocl.pivot.Class>(allElements); |
| Collections.sort(sortedElements, monikerComparator); |
| return sortedElements; |
| } |
| |
| protected @NonNull List<Precedence> getSortedPrecedences(@NonNull Library library) { |
| List<Precedence> sortedElements = new ArrayList<Precedence>(library.getOwnedPrecedences()); |
| Collections.sort(sortedElements, nameableComparator); |
| return sortedElements; |
| } |
| |
| protected @NonNull Map<org.eclipse.ocl.pivot.Package, List<PrimitiveType>> getSortedPrimitiveTypes(@NonNull Model root) { |
| Map<org.eclipse.ocl.pivot.Package, List<PrimitiveType>> pkge2primitiveTypes = new HashMap<org.eclipse.ocl.pivot.Package, List<PrimitiveType>>(); |
| for (org.eclipse.ocl.pivot.Package pkge : root.getOwnedPackages()) { |
| List<PrimitiveType> primitiveTypes = null; |
| for (Type type : pkge.getOwnedClasses()) { |
| if (type instanceof PrimitiveType) { |
| if (primitiveTypes == null) { |
| primitiveTypes = new ArrayList<PrimitiveType>(); |
| pkge2primitiveTypes.put(pkge, primitiveTypes); |
| } |
| primitiveTypes.add((PrimitiveType)type); |
| } |
| } |
| if (primitiveTypes != null) { |
| Collections.sort(primitiveTypes, monikerComparator); |
| } |
| } |
| return pkge2primitiveTypes; |
| } |
| |
| protected @NonNull Map<org.eclipse.ocl.pivot.Package, List<Property>> getSortedProperties(@NonNull Model root) { |
| Map<org.eclipse.ocl.pivot.Package, List<Property>> pkge2properties = new HashMap<org.eclipse.ocl.pivot.Package, List<Property>>(); |
| for (org.eclipse.ocl.pivot.Package pkge : root.getOwnedPackages()) { |
| List<Property> properties = null; |
| for (org.eclipse.ocl.pivot.Class type : pkge.getOwnedClasses()) { |
| if (!(type instanceof TupleType)) { |
| for (Property property : type.getOwnedProperties()) { |
| if (properties == null) { |
| properties = new ArrayList<Property>(); |
| pkge2properties.put(pkge, properties); |
| } |
| properties.add(property); |
| } |
| } |
| } |
| if (properties != null) { |
| Collections.sort(properties, classPropertyComparator); |
| } |
| } |
| return pkge2properties; |
| } |
| |
| protected @NonNull List<Property> getSortedProperties(@NonNull org.eclipse.ocl.pivot.Class type) { |
| List<Property> sortedElements = new ArrayList<Property>(type.getOwnedProperties()); |
| Collections.sort(sortedElements, OCLinEcoreTablesUtils.propertyComparator); |
| return sortedElements; |
| } |
| |
| /* protected @NonNull List<Property> getSortedProperties(@NonNull org.eclipse.ocl.pivot.Class type, @NonNull List<Property> allProperties) { |
| Set<Property> allElements = new HashSet<Property>(); |
| for (Property property : type.getOwnedProperties()) { |
| if (allProperties.contains(property)) { |
| allElements.add(property); |
| } |
| } |
| List<Property> sortedElements = new ArrayList<Property>(allElements); |
| Collections.sort(sortedElements, OCLinEcoreTablesUtils.propertyComparator); |
| if ("OCLExpression".equals(type.getName())) { |
| Collections.sort(sortedElements, OCLinEcoreTablesUtils.propertyComparator); |
| } |
| return sortedElements; |
| } */ |
| |
| protected @NonNull List<TemplateParameter> getSortedTemplateParameters(@NonNull Model root) { |
| Set<TemplateParameter> allElements = new HashSet<TemplateParameter>(); |
| TreeIterator<EObject> tit = root.eAllContents(); |
| while (tit.hasNext()) { |
| EObject eObject = tit.next(); |
| if (eObject instanceof TemplateParameter) { |
| allElements.add((TemplateParameter)eObject); |
| } |
| } |
| List<TemplateParameter> sortedElements = new ArrayList<TemplateParameter>(allElements); |
| Collections.sort(sortedElements, monikerComparator); |
| return sortedElements; |
| } |
| |
| protected @NonNull List<TemplateSignature> getSortedTemplateSignatures(@NonNull Model root) { |
| Set<TemplateSignature> allElements = new HashSet<TemplateSignature>(); |
| TreeIterator<EObject> tit = root.eAllContents(); |
| while (tit.hasNext()) { |
| EObject eObject = tit.next(); |
| if (eObject instanceof TemplateSignature) { |
| allElements.add((TemplateSignature)eObject); |
| } |
| } |
| List<TemplateSignature> sortedElements = new ArrayList<TemplateSignature>(allElements); |
| Collections.sort(sortedElements, monikerComparator); |
| return sortedElements; |
| } |
| |
| protected List<TemplateableElement> getSortedTemplateableElements(@NonNull Model root) { |
| Set<TemplateableElement> allElements = new HashSet<TemplateableElement>(); |
| TreeIterator<EObject> tit = root.eAllContents(); |
| while (tit.hasNext()) { |
| EObject eObject = tit.next(); |
| if (eObject instanceof TemplateableElement) { |
| TemplateableElement asTemplateableElement = (TemplateableElement)eObject; |
| if (asTemplateableElement.getOwnedBindings().size() > 0) { |
| allElements.add(asTemplateableElement); |
| } |
| } |
| } |
| List<TemplateableElement> sortedElements = new ArrayList<TemplateableElement>(allElements); |
| Collections.sort(sortedElements, monikerComparator); |
| return sortedElements; |
| } |
| |
| protected @NonNull List<Property> getSortedTupleParts(@NonNull TupleType tupleType) { |
| List<Property> sortedElements = new ArrayList<Property>(tupleType.getOwnedProperties()); |
| Collections.sort(sortedElements, nameableComparator); |
| return sortedElements; |
| } |
| |
| protected @NonNull List<TupleType> getSortedTupleTypes(@NonNull Model root) { |
| Set<TupleType> allElements = new HashSet<TupleType>(); |
| TreeIterator<EObject> tit = root.eAllContents(); |
| while (tit.hasNext()) { |
| EObject eObject = tit.next(); |
| if (eObject instanceof TupleType) { |
| allElements.add((TupleType)eObject); |
| } |
| } |
| List<TupleType> sortedElements = new ArrayList<TupleType>(allElements); |
| Collections.sort(sortedElements, monikerComparator); |
| return sortedElements; |
| } |
| |
| protected @NonNull List<org.eclipse.ocl.pivot.Class> getSuperclassesInPackage(@NonNull org.eclipse.ocl.pivot.Class type) { |
| List<org.eclipse.ocl.pivot.Class> allElements = new ArrayList<org.eclipse.ocl.pivot.Class>(); |
| for (org.eclipse.ocl.pivot.Class superclass : type.getSuperClasses()) { |
| if (getRootPackage(superclass.getOwningPackage()) == getRootPackage(type.getOwningPackage())) { |
| allElements.add(superclass); |
| } |
| } |
| return allElements; |
| } |
| |
| protected @NonNull List<TemplateParameterSubstitution> getTemplateParameterSubstitutions(@NonNull TemplateableElement element) { |
| List<TemplateParameterSubstitution> allElements = new ArrayList<TemplateParameterSubstitution>(); |
| for (TemplateBinding templateBinding : element.getOwnedBindings()) { |
| allElements.addAll(templateBinding.getOwnedSubstitutions()); |
| } |
| return allElements; |
| } |
| |
| protected String getSymbolName(@NonNull EObject elem) { |
| String name = external2name.get(elem); |
| if (name != null) { |
| return name; |
| } |
| EnvironmentFactoryInternal environmentFactory = PivotUtilInternal.findEnvironmentFactory(elem); |
| if (environmentFactory != null) { |
| elem = environmentFactory.getMetamodelManager().getPrimaryElement(elem); |
| } |
| Model thatModel = PivotUtil.getContainingModel(elem); |
| if (getThisModel() == thatModel) { |
| return NameQueries.getSymbolName(elem); |
| } |
| return NameQueries.getSymbolName(elem); |
| // throw new IllegalStateException("No external name defined for " + EcoreUtil.getURI(elem)); |
| } |
| |
| protected abstract Model getThisModel(); |
| |
| protected Boolean isEcoreConstraint(@NonNull Operation operation) { |
| for (Parameter p : operation.getOwnedParameters()) { |
| if (p.getName().equals("diagnostics") && p.getType().getName().equals("EDiagnosticChain")) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| protected @NonNull String javaName(@NonNull NamedElement element) { |
| return NameQueries.rawEncodeName(element.getName(), 0); |
| } |
| |
| protected @NonNull String javaName(@Nullable Object element, @NonNull String string) { |
| return NameQueries.rawEncodeName(string, 0); |
| } |
| |
| protected @NonNull String javaString(@NonNull Comment aComment) { |
| return Strings.convertToJavaString(aComment.getBody().trim()); |
| } |
| |
| protected @NonNull String javaString(@NonNull LanguageExpression anExpression) { |
| return Strings.convertToJavaString(anExpression.getBody().trim()); |
| } |
| |
| protected abstract /*@NonNull*/ String partialName(EObject element); |
| } |
