/*******************************************************************************
* Copyright (c) 2013, 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
*******************************************************************************/
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.emf.mwe.utils.Mapping;
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.AnyType;
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.EnumerationLiteral;
import org.eclipse.ocl.pivot.Import;
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.Namespace;
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.TypedElement;
import org.eclipse.ocl.pivot.ids.IdManager;
import org.eclipse.ocl.pivot.ids.PackageId;
import org.eclipse.ocl.pivot.internal.PackageImpl;
import org.eclipse.ocl.pivot.internal.complete.CompleteClassInternal;
import org.eclipse.ocl.pivot.internal.complete.StandardLibraryInternal;
import org.eclipse.ocl.pivot.internal.manager.MetamodelManagerInternal;
import org.eclipse.ocl.pivot.internal.manager.Orphanage;
import org.eclipse.ocl.pivot.internal.manager.PivotMetamodelManager;
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.model.OCLmetamodel;
import org.eclipse.ocl.pivot.model.OCLstdlib;
import org.eclipse.ocl.pivot.utilities.ClassUtil;
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, @NonNull String> external2name = new HashMap<NamedElement, @NonNull String>();
protected final @NonNull Map<String, NamedElement> name2external = new HashMap<String, NamedElement>();
protected final @NonNull Map<String, String> generatedClassNameMap = new HashMap<String, String>();
protected EnvironmentFactoryInternal environmentFactory;
protected PivotMetamodelManager metamodelManager;
protected NameQueries nameQueries;
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<NamedElement> externalComparator = new Comparator<NamedElement>()
{
public int compare(NamedElement o1, NamedElement o2) {
int d1 = depth(o1);
int d2 = depth(o2);
int diff = d1 - d2;
if (diff != 0) {
return diff;
}
String m1 = external2name.get(o1);
String m2 = external2name.get(o2);
assert (m1 != null) && (m2 != null);
return m1.compareTo(m2);
}
private int depth(EObject o) {
EObject eContainer = o.eContainer();
if (eContainer != null) {
return depth(eContainer) + 1;
}
return 0;
}
};
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 final @NonNull Comparator<Package> packageComparator = new Comparator<Package>()
{
public int compare(Package o1, Package o2) {
String m1 = o1.getName();
String m2 = o2.getName();
if (PivotConstants.ORPHANAGE_NAME.equals(m1)) {
if (PivotConstants.ORPHANAGE_NAME.equals(m2)) {
return 0;
}
else {
return 1;
}
}
else{
if (PivotConstants.ORPHANAGE_NAME.equals(m2)) {
return -1;
}
else {
return m1.compareTo(m2);
}
}
}
};
protected final @NonNull Comparator<EObject> symbolNameComparator = new Comparator<EObject>()
{
public int compare(EObject o1, EObject o2) {
String m1 = getSymbolName(o1);
String m2 = getSymbolName(o2);
return m1.compareTo(m2);
}
};
protected void addExternalReference(@Nullable NamedElement reference, @NonNull Model root) {
if (reference == null) {
return;
}
Model containingModel = PivotUtil.getContainingModel(reference);
if ((containingModel == root) || external2name.containsKey(reference)) {
return;
}
if (reference instanceof Model) {
return;
}
if (reference instanceof Type) {
EnvironmentFactoryInternal environmentFactory = PivotUtilInternal.findEnvironmentFactory(reference);
// assert environmentFactory == this.environmentFactory;
if (environmentFactory != null) { // FIXME this conveniently does not relocate the built-in PrimitiveTypes
CompleteClassInternal completeClass = environmentFactory.getMetamodelManager().getCompleteClass((Type)reference);
for (Type partialType : completeClass.getPartialClasses()) {
Model containingModel2 = PivotUtil.getContainingModel(partialType);
if (containingModel2 == root) {
return;
}
if (containingModel2 == null) { // Orphanage
return;
}
}
reference = completeClass.getPrimaryClass();
}
}
else if (!(reference instanceof org.eclipse.ocl.pivot.Package)) {
reference = metamodelManager.getPrimaryElement(reference);
}
if (external2name.containsKey(reference)) {
return;
}
EObject eContainer = reference.eContainer();
String name;
if (reference instanceof TemplateParameter) {
TemplateParameter templateParameter = (TemplateParameter)reference;
TemplateSignature owningSignature = templateParameter.getOwningSignature();
TemplateableElement owningElement = owningSignature != null ? owningSignature.getOwningElement() : null;
if (owningElement instanceof NamedElement) {
name = "_" + ((NamedElement)owningElement).getName() + "_" + templateParameter.getName();
}
else {
name = "_" + templateParameter.getName();
}
}
else if (reference instanceof Model) {
name = "_" + ((NamedElement)reference).getName().toLowerCase();
}
else if (reference instanceof NamedElement) {
name = "_" + ((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);
if ((getGeneratedClassName(reference) == null) && (eContainer instanceof NamedElement)) {
addExternalReference((NamedElement)eContainer, root);
}
}
public void addGeneratedClassNameMap(Mapping mapping) {
generatedClassNameMap.put(mapping.getFrom(), mapping.getTo());
}
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 @NonNull EnvironmentFactoryInternal getEnvironmentFactory() {
assert environmentFactory != null;
return environmentFactory;
}
protected String getExternalReference(@NonNull Element element) {
EObject eContainer = element.eContainer();
if (eContainer == null) {
if (element instanceof Model) {
return ((Model)element).eResource().getClass().getName() + ".getDefaultModel()";
}
}
else {
String generatedClassName = getGeneratedClassName(element);
if (generatedClassName != null) {
return "getPackage(" + generatedClassName + ".getDefaultModel(), \"" + ((NamedElement)element).getName() + "\")";
}
if ((element instanceof TemplateParameter) && (eContainer instanceof TemplateSignature)) {
TemplateSignature templateSignature = (TemplateSignature)eContainer;
TemplateableElement templateableElement = templateSignature.getOwningElement();
if (templateableElement != null) {
return "get" + element.eClass().getName() + "(" + getSymbolName(eContainer.eContainer()) + ", " + templateSignature.getOwnedParameters().indexOf(element) + ")";
}
}
if (eContainer instanceof NamedElement) {
return "get" + element.eClass().getName() + "(" + getPrefixedSymbolName(eContainer, ((NamedElement)eContainer).getName()) + ", \"" + ((NamedElement)element).getName() + "\")";
}
else {
return "get" + element.eClass().getName() + "(" + getSymbolName(eContainer) + ", \"" + ((NamedElement)element).getName() + "\")";
}
}
return "\"" + EcoreUtil.getURI(element).toString() + "\"";
}
protected void getExternals(@NonNull Model root) {
Set<org.eclipse.ocl.pivot.Class> internalTypes = new HashSet<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) {
for (org.eclipse.ocl.pivot.Class classType : classTypes) {
for (org.eclipse.ocl.pivot.Class partialClass : metamodelManager.getCompleteClass(classType).getPartialClasses()) {
internalTypes.add(partialClass);
}
}
}
}
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);
}
else if (eObject instanceof Import) {
Import asImport = (Import)eObject;
addExternalReference(asImport.getImportedNamespace(), root);
}
else if (eObject instanceof TypedElement) {
TypedElement typedElement = (TypedElement)eObject;
Type type = typedElement.getType();
if (!internalTypes.contains(type)) {
addExternalReference(type, root);
}
if (eObject instanceof Property) {
Property property = (Property)eObject;
Property opposite = property.getOpposite();
if (opposite != null) {
if (PivotUtil.getContainingModel(opposite) == PivotUtil.getContainingModel(property)) {
addExternalReference(opposite, root);
}
Type oppositeType = opposite.getType();
if (!internalTypes.contains(oppositeType)) {
addExternalReference(oppositeType, root);
}
}
}
}
}
if (name2external.size() > 0) {
StandardLibraryInternal standardLibrary = environmentFactory.getStandardLibrary();
addExternalReference(standardLibrary.getOclAnyType(), root);
addExternalReference(standardLibrary.getOclElementType(), root);
}
}
protected String declarePackageImport(@NonNull Package elem) {
// String generatedClassName = getGeneratedClassName(elem);
// if (generatedClassName != null) {
// return null;//"import " + generatedClassName + ";";
// }
String ecoreQualifiedPackageInterfaceName = nameQueries.getEcoreQualifiedPackageInterfaceName(elem);
if (ecoreQualifiedPackageInterfaceName != null) {
return "import " + ecoreQualifiedPackageInterfaceName + ";";
}
return null;
}
protected @Nullable String getGeneratedClassName(EObject eObject) {
return (eObject instanceof Package) ? generatedClassNameMap.get(((Package)eObject).getURI()) : null;
}
protected @NonNull String getGeneratedPackageId(@NonNull Package pkge) {
PackageId basicPackageId = ((PackageImpl)pkge).basicGetPackageId();
return basicPackageId == IdManager.METAMODEL ? "IdManager.METAMODEL" : "null";
}
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 String getNameLiteral(@NonNull Property property) {
return '"' + property.getName() + '"';
}
protected org.eclipse.ocl.pivot.@Nullable Package getOrphanPackage(org.eclipse.ocl.pivot.@NonNull Package elem) {
return getOrphanPackage(getRootPackage(elem));
}
protected org.eclipse.ocl.pivot.@Nullable Package getOrphanPackage(@NonNull Model elem) {
for (org.eclipse.ocl.pivot.Package pkg : getAllPackages(elem)) {
if (PivotConstants.ORPHANAGE_NAME.equals(pkg.getName())) {
return pkg;
}
}
return null;
}
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) {
if (!(elem instanceof org.eclipse.ocl.pivot.Package)) {
elem = metamodelManager.getPrimaryElement(elem);
}
return nameQueries.getPrefixedSymbolName(prefix.replace(".", "_"), elem);
}
protected ResourceSet getResourceSet() {
if (resourceSet == null) {
resourceSet = new ResourceSetImpl();
}
return resourceSet;
}
protected @NonNull Model getRootPackage(org.eclipse.ocl.pivot.@Nullable 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);
}
/* else if (type instanceof org.eclipse.ocl.pivot.Class) { // FIXME fails because Orphanage has no Model
for (Property property : ((org.eclipse.ocl.pivot.Class)type).getOwnedProperties()) {
Property opposite = property.getOpposite();
if (opposite != null) {
Type oppositeType = opposite.getType();
if (oppositeType instanceof CollectionType) {
if (collectionTypes == null) {
collectionTypes = new ArrayList<CollectionType>();
pkge2collectionTypes.put(pkge, collectionTypes);
}
collectionTypes.add((CollectionType)oppositeType);
}
}
}
} */
}
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<Element> getSortedCommentedElements(@NonNull Model root) {
List<org.eclipse.ocl.pivot.Class> allClassTypes = new ArrayList<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) {
allClassTypes.addAll(classTypes);
}
}
Collection<org.eclipse.ocl.pivot.Class> oclTypes = allClassTypes;
Set<Element> allElements = new HashSet<Element>();
TreeIterator<EObject> tit = root.eAllContents();
while (tit.hasNext()) {
EObject eObject = tit.next();
if ((eObject instanceof Element) && !(eObject instanceof Constraint) &&
!((eObject instanceof Property) && (((Property)eObject).getOwningClass() == null)) &&
!((eObject instanceof org.eclipse.ocl.pivot.Class) && !oclTypes.contains(eObject))) {
Element t = (Element)eObject;
if (t.getOwnedComments().size() > 0) {
allElements.add(t);
}
}
}
List<Element> sortedElements = new ArrayList<Element>(allElements);
Collections.sort(sortedElements, monikerComparator);
return sortedElements;
}
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<Package> getSortedExternalPackages(@NonNull Model root) {
if (name2external.size() <= 0) {
getExternals(root);
}
List<Package> externalPackages = new ArrayList<Package>(root.getOwnedPackages());
for (Import asImport : root.getOwnedImports()) {
Namespace importedNamespace = asImport.getImportedNamespace();
Package externalPackage = PivotUtil.getContainingPackage(importedNamespace);
if (externalPackage != null) {
if (!externalPackages.contains(externalPackage)) {
externalPackages.add(externalPackage);
}
}
}
for (Element element : name2external.values()) {
Package externalPackage = PivotUtil.getContainingPackage(element);
if (externalPackage != null) {
if (!externalPackages.contains(externalPackage)) {
externalPackages.add(externalPackage);
}
}
}
if (externalPackages.size() > 1) {
Collections.sort(externalPackages, packageComparator);
}
return externalPackages;
}
protected @NonNull List<String> getSortedExternals(@NonNull Model root) {
if (name2external.size() <= 0) {
getExternals(root);
}
List<NamedElement> sortedExternals = new ArrayList<NamedElement>(name2external.values());
Collections.sort(sortedExternals, externalComparator);
List<String> sortedExternalNames = new ArrayList<String>(sortedExternals.size());
for (NamedElement sortedExternal : sortedExternals) {
sortedExternalNames.add(external2name.get(sortedExternal));
}
return sortedExternalNames;
}
protected @NonNull Map<Package,String> getSortedImports(@NonNull Model model) {
if (name2external.size() <= 0) {
getExternals(model);
}
Map<Package,String> import2alias = new HashMap<Package,String>();
for (Import asImport : model.getOwnedImports()) {
Namespace importedNamespace = asImport.getImportedNamespace();
if (importedNamespace instanceof Package) {
import2alias.put((Package)importedNamespace, asImport.getName());
}
}
for (Map.Entry<String, NamedElement> entry : name2external.entrySet()) {
NamedElement value = entry.getValue();
if ((value instanceof Library) && !import2alias.containsKey(value)) {
import2alias.put((Library)value, null);
}
}
return import2alias;
}
/* 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(org.eclipse.ocl.pivot.@NonNull 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(org.eclipse.ocl.pivot.@NonNull 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);
Collections.sort(sortedElements, packageComparator);
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>(root.getOwnedPackages());
Collections.sort(sortedElements, packageComparator);
return sortedElements;
}
protected @NonNull List<org.eclipse.ocl.pivot.Package> getSortedPackages(org.eclipse.ocl.pivot.@NonNull 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) {
type = metamodelManager.getPrimaryElement(type);
String externalName = external2name.get(type);
if (externalName == null) {
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(org.eclipse.ocl.pivot.@NonNull Class type) {
List<Property> sortedElements = new ArrayList<Property>(type.getOwnedProperties());
Collections.sort(sortedElements, OCLinEcoreTablesUtils.propertyComparator);
return sortedElements;
}
/* protected @NonNull List<Property> getSortedProperties(org.eclipse.ocl.pivot.@NonNull 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, @Nullable Comparator<EObject> nameComparator) {
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, nameComparator != null ? nameComparator : 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(org.eclipse.ocl.pivot.@NonNull 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) {
if (!(elem instanceof org.eclipse.ocl.pivot.Package)) {
elem = metamodelManager.getPrimaryElement(elem);
}
String name = external2name.get(elem);
if (name != null) {
return name;
}
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);
protected void setEnvironmentFactory(@NonNull EnvironmentFactoryInternal environmentFactory) {
this.environmentFactory = environmentFactory;
this.metamodelManager = environmentFactory.getMetamodelManager();
nameQueries = new NameQueries(metamodelManager);
}
}