| /******************************************************************************* |
| * Copyright (c) 2010, 2016 Willink Transformations and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * E.D.Willink - initial API and implementation |
| * E.D.Willink (Obeo) - Bug 416287 - tuple-valued constraints |
| *******************************************************************************/ |
| package org.eclipse.ocl.xtext.base.utilities; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Set; |
| |
| import org.eclipse.core.runtime.IConfigurationElement; |
| import org.eclipse.core.runtime.IExtensionPoint; |
| import org.eclipse.core.runtime.IExtensionRegistry; |
| import org.eclipse.core.runtime.Platform; |
| import org.eclipse.emf.ecore.EDataType; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.ecore.EReference; |
| import org.eclipse.emf.ecore.plugin.EcorePlugin; |
| import org.eclipse.emf.ecore.resource.Resource; |
| import org.eclipse.emf.ecore.resource.Resource.Diagnostic; |
| import org.eclipse.emf.ecore.resource.ResourceSet; |
| import org.eclipse.jdt.annotation.NonNull; |
| import org.eclipse.jdt.annotation.Nullable; |
| import org.eclipse.ocl.pivot.CollectionType; |
| import org.eclipse.ocl.pivot.Constraint; |
| import org.eclipse.ocl.pivot.Element; |
| import org.eclipse.ocl.pivot.ExpressionInOCL; |
| import org.eclipse.ocl.pivot.LanguageExpression; |
| import org.eclipse.ocl.pivot.Model; |
| import org.eclipse.ocl.pivot.Operation; |
| import org.eclipse.ocl.pivot.TemplateBinding; |
| import org.eclipse.ocl.pivot.TemplateParameter; |
| import org.eclipse.ocl.pivot.TemplateSignature; |
| import org.eclipse.ocl.pivot.TemplateableElement; |
| import org.eclipse.ocl.pivot.Type; |
| import org.eclipse.ocl.pivot.ids.TypeId; |
| import org.eclipse.ocl.pivot.internal.manager.PivotMetamodelManager; |
| import org.eclipse.ocl.pivot.internal.resource.ICSI2ASMapping; |
| import org.eclipse.ocl.pivot.internal.scoping.Attribution; |
| import org.eclipse.ocl.pivot.internal.utilities.EnvironmentFactoryInternal; |
| import org.eclipse.ocl.pivot.internal.utilities.PivotUtilInternal; |
| import org.eclipse.ocl.pivot.resource.ASResource; |
| import org.eclipse.ocl.pivot.utilities.ParserException; |
| import org.eclipse.ocl.pivot.utilities.PivotUtil; |
| import org.eclipse.ocl.xtext.base.attributes.RootCSAttribution; |
| import org.eclipse.ocl.xtext.base.cs2as.CS2AS; |
| import org.eclipse.ocl.xtext.base.cs2as.ImportDiagnostic; |
| import org.eclipse.ocl.xtext.base.cs2as.LibraryDiagnostic; |
| import org.eclipse.ocl.xtext.basecs.ElementCS; |
| import org.eclipse.ocl.xtext.basecs.ModelElementCS; |
| import org.eclipse.ocl.xtext.basecs.MultiplicityCS; |
| import org.eclipse.ocl.xtext.basecs.NamedElementCS; |
| import org.eclipse.ocl.xtext.basecs.OperationCS; |
| import org.eclipse.ocl.xtext.basecs.PathElementCS; |
| import org.eclipse.ocl.xtext.basecs.PathNameCS; |
| import org.eclipse.ocl.xtext.basecs.StructuredClassCS; |
| import org.eclipse.ocl.xtext.basecs.TemplateBindingCS; |
| import org.eclipse.ocl.xtext.basecs.TemplateParameterSubstitutionCS; |
| import org.eclipse.ocl.xtext.basecs.TypeRefCS; |
| import org.eclipse.ocl.xtext.basecs.TypedElementCS; |
| import org.eclipse.ocl.xtext.basecs.TypedRefCS; |
| import org.eclipse.ocl.xtext.basecs.TypedTypeRefCS; |
| import org.eclipse.ocl.xtext.basecs.WildcardTypeRefCS; |
| import org.eclipse.xtext.nodemodel.BidiIterator; |
| import org.eclipse.xtext.nodemodel.ICompositeNode; |
| import org.eclipse.xtext.nodemodel.ILeafNode; |
| import org.eclipse.xtext.nodemodel.INode; |
| import org.eclipse.xtext.nodemodel.impl.AbstractNode; |
| import org.eclipse.xtext.nodemodel.util.NodeModelUtils; |
| import org.eclipse.xtext.resource.XtextSyntaxDiagnostic; |
| import org.eclipse.xtext.util.ITextRegion; |
| |
| public class ElementUtil |
| { |
| private static final String delegateExtensionPoints[] = { |
| // EcorePlugin.CONVERSION_DELEGATE_PPID, -- not available in EMF 2.7 |
| EcorePlugin.INVOCATION_DELEGATE_PPID, |
| EcorePlugin.QUERY_DELEGATE_PPID, |
| EcorePlugin.SETTING_DELEGATE_PPID, |
| EcorePlugin.VALIDATION_DELEGATE_PPID |
| }; |
| |
| private static String[][] delegationModes = null; |
| |
| public static void appendTextRegion(@NonNull StringBuilder s, @Nullable ITextRegion textRegion, boolean isSignificant) { |
| s.append(isSignificant ? "[" : "("); |
| if (textRegion != null) { |
| s.append(textRegion.getOffset() + "," + textRegion.getLength()); |
| } |
| else { |
| s.append("null"); |
| } |
| s.append(isSignificant ? "]" : ")"); |
| } |
| |
| public static @Nullable String getCollectionTypeName(@NonNull TypedElementCS csTypedElement) { |
| TypedRefCS csTypeRef = csTypedElement.getOwnedType(); |
| if (csTypeRef == null) { |
| return null; |
| } |
| // if (csTypeRef instanceof CollectionTypeRefCS) { |
| // Type csType = ((CollectionTypeRefCS)csTypeRef).getType(); |
| // if (csType instanceof CollectionType) { |
| // return ((CollectionType)csType).getName(); |
| // } |
| // } |
| //FIXME Obsolete compatibility |
| MultiplicityCS csMultiplicity = csTypeRef.getOwnedMultiplicity(); |
| if (csMultiplicity == null) { |
| return null; |
| } |
| int upper = csMultiplicity.getUpper(); |
| if (upper == 1) { |
| return null; |
| } |
| List<String> qualifiers = csTypedElement.getQualifiers(); |
| boolean isOrdered = true; |
| boolean isUnique = true; |
| if (qualifiers.contains("!ordered")) { //$NON-NLS-1$ |
| isOrdered = false; |
| } |
| else if (qualifiers.contains("ordered")) { //$NON-NLS-1$ |
| isOrdered = true; |
| } |
| if (qualifiers.contains("!unique")) { //$NON-NLS-1$ |
| isUnique = false; |
| } |
| else if (qualifiers.contains("unique")) { //$NON-NLS-1$ |
| isUnique = true; |
| } |
| return getCollectionName(isOrdered, isUnique); |
| } |
| |
| public static @NonNull String getCollectionName(boolean ordered, boolean unique) { |
| if (ordered) { |
| return unique ? TypeId.ORDERED_SET_NAME : TypeId.SEQUENCE_NAME; |
| } |
| else { |
| return unique ? TypeId.SET_NAME : TypeId.BAG_NAME; |
| } |
| } |
| |
| public static @Nullable ModelElementCS getCsElement(@NonNull Element asElement) { |
| Resource asResource = asElement.eResource(); |
| if (asResource == null) { |
| return null; |
| } |
| ResourceSet asResourceSet = asResource.getResourceSet(); |
| if (asResourceSet == null) { |
| return null; |
| } |
| PivotMetamodelManager metamodelManager = PivotMetamodelManager.findAdapter(asResourceSet); |
| if (metamodelManager == null) { |
| return null; |
| } |
| EnvironmentFactoryInternal environmentFactory = metamodelManager.getEnvironmentFactory(); |
| ICSI2ASMapping csi2asMapping = environmentFactory.getCSI2ASMapping(); |
| if (csi2asMapping == null) { |
| return null; |
| } |
| return ((CSI2ASMapping)csi2asMapping).getCSElement(asElement); |
| } |
| |
| // FIXME share with common.ui once promoted from examples |
| public static String[][] getDelegateURIs() { |
| if (delegationModes == null) { |
| Set<String> uris = new HashSet<String>(); |
| IExtensionRegistry pluginRegistry = Platform.getExtensionRegistry(); |
| String pluginID = EcorePlugin.getPlugin().getBundle().getSymbolicName(); |
| for (String extensionPointID : delegateExtensionPoints) { |
| IExtensionPoint point = pluginRegistry.getExtensionPoint(pluginID, extensionPointID); |
| if (point != null) { |
| IConfigurationElement[] elements = point.getConfigurationElements(); |
| for (int i = 0; i < elements.length; i++) { |
| String uri = elements[i].getAttribute("uri"); //$NON-NLS-1$ |
| if (uri != null) { |
| uris.add(uri); |
| } |
| } |
| } |
| } |
| List<String> uriList = new ArrayList<String>(uris); |
| Collections.sort(uriList); |
| delegationModes = new String[uriList.size()][2]; |
| for (int i = 0; i < uris.size(); i++) { |
| delegationModes[i][0] = uriList.get(i); |
| delegationModes[i][1] = uriList.get(i); |
| } |
| } |
| return delegationModes; |
| } |
| |
| public static @Nullable RootCSAttribution getDocumentAttribution(@NonNull ElementCS context) { |
| for (ElementCS target = context, parent; (parent = target.getParent()) != null; target = parent) { |
| Attribution attribution = PivotUtilInternal.getAttribution(parent); |
| if (attribution instanceof RootCSAttribution) { |
| return (RootCSAttribution) attribution; |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Return the user text for csElement preserving all surrounding whitespace. |
| * <br> |
| * Except that Carriage Returns are removed. |
| * <br> |
| * Except that a first space is removed since it originates from the auto-formatter. |
| * <br> |
| * The leading whitespace of the next element is included since the folloowing token |
| * is expected to be a semicolon. |
| */ |
| public static @NonNull String getExpressionText(@NonNull ElementCS csElement) { |
| ICompositeNode parserNode = NodeModelUtils.getNode(csElement); |
| if (parserNode != null) { |
| String text = parserNode.getText().replace("\r", ""); |
| if ((text.length() > 0) && text.charAt(0) == ' ') { |
| text = text.substring(1); // Step over the leading separator. |
| } |
| INode nextNode = parserNode.getNextSibling(); |
| for (INode parent = parserNode.getParent(); parent != null; parent = parent.getParent()) { |
| nextNode = parent.getNextSibling(); |
| if (nextNode != null) { |
| String nextText = nextNode.getText().replace("\r", ""); |
| int i = 0; |
| int iMax = nextText.length(); |
| for ( ; i < iMax; i++) { // Step up to the leading separator. |
| if (!Character.isWhitespace(nextText.charAt(i))) { |
| break; |
| } |
| } |
| return text + nextText.substring(0, i); |
| } |
| } |
| assert text != null; |
| return text; |
| } |
| return "null"; |
| } |
| |
| /** |
| * Extract the first embedded ExpressionInOCL. |
| * @throws ParserException |
| */ |
| public static @Nullable ExpressionInOCL getFirstQuery(@NonNull PivotMetamodelManager metamodelManager, BaseCSResource csResource) throws ParserException { |
| CS2AS cs2as = csResource.findCS2AS(); |
| if (cs2as != null) { |
| ASResource asResource = cs2as.getASResource(); |
| for (EObject eRoot: asResource.getContents()) { |
| if (eRoot instanceof Model) { |
| for (org.eclipse.ocl.pivot.Package asPackage: ((Model)eRoot).getOwnedPackages()) { |
| for (org.eclipse.ocl.pivot.Class asType: asPackage.getOwnedClasses()) { |
| for (Constraint asConstraint : asType.getOwnedInvariants()) { |
| LanguageExpression specification = asConstraint.getOwnedSpecification(); |
| if (specification != null) { |
| return metamodelManager.parseSpecification(specification); |
| } |
| } |
| for (Operation asOperation : asType.getOwnedOperations()) { |
| LanguageExpression specification = asOperation.getBodyExpression(); |
| if (specification != null) { |
| return metamodelManager.parseSpecification(specification); |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| return null; |
| } |
| |
| public static @Nullable TemplateParameter getFormalTemplateParameter(@NonNull TemplateParameterSubstitutionCS csTemplateParameterSubstitution) { |
| TemplateBindingCS csTemplateBinding = csTemplateParameterSubstitution.getOwningBinding(); |
| int index = csTemplateBinding.getOwnedSubstitutions().indexOf(csTemplateParameterSubstitution); |
| if (index < 0) { |
| return null; |
| } |
| TemplateBinding templateBinding = (TemplateBinding) csTemplateBinding.getPivot(); |
| TemplateSignature templateSignature = templateBinding.getTemplateSignature(); |
| List<TemplateParameter> templateParameters = templateSignature.getOwnedParameters(); |
| if (templateParameters.size() <= index) { |
| return null; |
| } |
| return templateParameters.get(index); |
| } |
| |
| public static @Nullable ILeafNode getLeafNode(@NonNull INode node) { |
| ILeafNode leafNode = null; |
| if (node instanceof ILeafNode) { |
| return (ILeafNode) node; |
| } |
| else { |
| for (ILeafNode lNode : node.getLeafNodes()) { |
| if (!lNode.isHidden()) { |
| leafNode = lNode; |
| return leafNode; |
| } |
| } |
| } |
| return null; |
| } |
| |
| public static int getLower(@NonNull TypedElementCS csTypedElement) { |
| TypedRefCS csTypeRef = csTypedElement.getOwnedType(); |
| if (csTypeRef == null) { |
| return 0; // e.g. missing Operation return type |
| } |
| MultiplicityCS csMultiplicity = csTypeRef.getOwnedMultiplicity(); |
| if (csMultiplicity == null) { |
| Type type = PivotUtil.getPivot(Type.class, csTypeRef); |
| if (type instanceof CollectionType) { |
| return 1; |
| } |
| if (type != null) { |
| EObject esObject = type.getESObject(); |
| if ((esObject instanceof EDataType) && isPrimitiveInstanceClass((EDataType) esObject)) { |
| return 1; |
| } |
| } |
| return 0; // OCL legacy allows null even though UML lowerBound() default is 1. |
| } |
| return csMultiplicity.getLower(); |
| } |
| |
| public static @Nullable <T extends NamedElementCS> T getNamedElementCS(@NonNull Collection<T> namedElements, @NonNull String name) { |
| for (T namedElement : namedElements) { |
| if (name.equals(namedElement.getName())) { |
| return namedElement; |
| } |
| } |
| return null; |
| } |
| |
| /** This makes INode.getEndOffset from Xtext 2.5 available on 2.3 */ |
| public static int getEndOffset(@NonNull INode iNode) { |
| if (!(iNode instanceof AbstractNode)) { |
| return -1; |
| } |
| AbstractNode node = (AbstractNode) iNode; |
| BidiIterator<AbstractNode> iter = node .basicIterator(); |
| while(iter.hasPrevious()) { |
| INode prev = iter.previous(); |
| if (prev instanceof ILeafNode && !((ILeafNode) prev).isHidden()) { |
| return prev.getTotalEndOffset(); |
| } |
| } |
| return node.getTotalEndOffset(); |
| } |
| |
| public static boolean getQualifier(@NonNull List<String> qualifiers, @NonNull String trueString, @NonNull String falseString, boolean defaultValue) { |
| if (qualifiers.contains(trueString)) { |
| return true; |
| } |
| else if (qualifiers.contains(falseString)) { |
| return false; |
| } |
| else { |
| return defaultValue; |
| } |
| } |
| |
| /** |
| * Return the raw text associated with a csElement. |
| */ |
| public static @Nullable String getText(@NonNull ElementCS csElement) { |
| ICompositeNode node = NodeModelUtils.getNode(csElement); |
| return node != null ? NodeModelUtils.getTokenText(node) : null; |
| } |
| |
| public static @Nullable String getText(@NonNull ElementCS csElement, /*@NonNull*/ EReference feature) { |
| @SuppressWarnings("null")@NonNull List<INode> nodes = NodeModelUtils.findNodesForFeature(csElement, feature); |
| // assert (nodes.size() == 1; |
| if (nodes.isEmpty()) { |
| return null; |
| } |
| else if (nodes.size() == 1) { |
| return NodeModelUtils.getTokenText(nodes.get(0)); |
| } |
| else { |
| StringBuilder s = new StringBuilder(); |
| for (INode node : nodes) { |
| s.append(NodeModelUtils.getTokenText(node)); |
| } |
| return s.toString(); |
| } |
| } |
| |
| /** |
| * Return the logical text associated with a csElement. (EScaped identifers are unescaped.) |
| */ |
| public static @Nullable String getTextName(@NonNull ElementCS csElement) { |
| String text = getText(csElement); |
| if (text == null) { |
| return null; |
| } |
| int length = text.length(); |
| if ((length >= 3) && text.startsWith("_'") && text.endsWith("'")) { |
| return text.substring(2, length-1); |
| } |
| else { |
| return text; |
| } |
| } |
| |
| public static int getUpper(@NonNull TypedElementCS csTypedElement) { |
| TypedRefCS csTypeRef = csTypedElement.getOwnedType(); |
| if (csTypeRef == null) { |
| return 1; |
| } |
| MultiplicityCS csMultiplicity = csTypeRef.getOwnedMultiplicity(); |
| if (csMultiplicity == null) { |
| return 1; |
| } |
| return csMultiplicity.getUpper(); |
| } |
| |
| public static boolean hasSyntaxError(@NonNull List<Diagnostic> diagnostics) { |
| for (Diagnostic diagnostic : diagnostics) { |
| if (diagnostic instanceof LibraryDiagnostic) { |
| return true; |
| } |
| else if (diagnostic instanceof XtextSyntaxDiagnostic) { |
| return true; |
| } |
| else if (diagnostic instanceof ImportDiagnostic) { |
| return true; |
| } |
| else if (diagnostic.getClass().getName().equals("org.eclipse.ocl.xtext.essentialocl.utilities.EssentialOCLCSResource$RenamedDiagnostic")) { // FIXME Intyroduce an interface |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| public static boolean isInOperation(@NonNull ElementCS csElement) { |
| for (EObject eObject = csElement; eObject != null; eObject = eObject.eContainer()) { |
| if (eObject instanceof OperationCS) { |
| return true; |
| } |
| else if (eObject instanceof StructuredClassCS) { |
| return false; |
| } |
| } |
| return false; |
| } |
| |
| public static boolean isOrdered(@NonNull TypedElementCS csTypedElement) { |
| List<String> qualifiers = csTypedElement.getQualifiers(); |
| assert qualifiers != null; |
| return getQualifier(qualifiers, "ordered", "!ordered", false); |
| } |
| |
| public static boolean isPrimitiveInstanceClass(@NonNull EDataType esObject) { |
| Class<?> instanceClass = esObject.getInstanceClass(); |
| return (instanceClass == byte.class) || (instanceClass == char.class) || (instanceClass == double.class) || (instanceClass == float.class) |
| || (instanceClass == int.class) || (instanceClass == long.class) || (instanceClass == short.class); |
| } |
| |
| public static boolean isRequired(@Nullable TypedRefCS csTypeRef) { |
| if (csTypeRef != null) { |
| MultiplicityCS csMultiplicity = csTypeRef.getOwnedMultiplicity(); |
| if (csMultiplicity != null) { |
| int lower = csMultiplicity.getLower(); |
| if (lower > 0) { |
| return true; |
| } |
| } |
| } |
| return false; |
| } |
| |
| public static boolean isSpecialization(@NonNull TemplateBindingCS csTemplateBinding) { |
| TypedTypeRefCS csTypedTypeRef = csTemplateBinding.getOwningElement(); |
| Element type = csTypedTypeRef.getPivot(); |
| for (TemplateParameterSubstitutionCS csTemplateParameterSubstitution : csTemplateBinding.getOwnedSubstitutions()) { |
| TypeRefCS ownedActualParameter = csTemplateParameterSubstitution.getOwnedActualParameter(); |
| if (ownedActualParameter instanceof WildcardTypeRefCS) { |
| return true; |
| } |
| Type actualParameterClass = (Type) ownedActualParameter.getPivot(); |
| TemplateParameter templateParameter = actualParameterClass.isTemplateParameter(); |
| if (templateParameter == null) { |
| return true; |
| } |
| TemplateSignature signature = templateParameter.getOwningSignature(); |
| TemplateableElement template = signature.getOwningElement(); |
| if (template != type) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| public static boolean isUnique(@NonNull TypedElementCS csTypedElement) { |
| List<String> qualifiers = csTypedElement.getQualifiers(); |
| assert qualifiers != null; |
| return getQualifier(qualifiers, "unique", "!unique", true); |
| } |
| |
| public static void setLastPathElement(@NonNull PathNameCS ownedPathName, @NonNull Element asElement) { |
| List<PathElementCS> ownedPathElements = ownedPathName.getOwnedPathElements(); |
| int size = ownedPathElements.size(); |
| if (size > 0) { |
| PathElementCS pathElementCS = ownedPathElements.get(size-1); |
| pathElementCS.setReferredElement(asElement); |
| } |
| } |
| } |
