| /******************************************************************************* |
| * Copyright (c) 2004, 2006 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v2.0 |
| * which accompanies this distribution, and is available at |
| * https://www.eclipse.org/legal/epl-2.0/ |
| * |
| * Contributors: |
| * Miguel Garcia (Tech Univ Hamburg-Harburg) - customization for EMF Generics |
| *******************************************************************************/ |
| |
| package org.eclipse.emf.emfatic.core.generics.util; |
| |
| import java.util.ArrayList; |
| import java.util.Iterator; |
| import java.util.List; |
| |
| import org.eclipse.emf.common.util.Diagnostic; |
| import org.eclipse.emf.ecore.EClassifier; |
| import org.eclipse.emf.ecore.EDataType; |
| import org.eclipse.emf.ecore.EGenericType; |
| import org.eclipse.emf.ecore.ETypeParameter; |
| import org.eclipse.emf.ecore.EcoreFactory; |
| import org.eclipse.emf.ecore.EcorePackage; |
| import org.eclipse.emf.ecore.util.Diagnostician; |
| |
| public class GenericsUtil { |
| |
| public static EGenericType getEGenericType(EClassifier resC) { |
| EGenericType resG = EcoreFactory.eINSTANCE.createEGenericType(); |
| resG.setEClassifier(resC); |
| return resG; |
| } |
| |
| public static EGenericType getEListOf(EClassifier elementType) { |
| EGenericType res = EcoreFactory.eINSTANCE.createEGenericType(); |
| EDataType eL = EcorePackage.eINSTANCE.getEEList(); |
| res.setEClassifier(eL); |
| EGenericType gtElementType = getEGenericType(elementType); |
| res.getETypeArguments().add(gtElementType); |
| return res; |
| } |
| |
| public static EGenericType getEListOf(EGenericType elementType) { |
| EGenericType res = EcoreFactory.eINSTANCE.createEGenericType(); |
| EDataType eL = EcorePackage.eINSTANCE.getEEList(); |
| res.setEClassifier(eL); |
| res.getETypeArguments().add(elementType); |
| return res; |
| } |
| |
| public static EGenericType getRefToTypeParam(ETypeParameter refedTP) { |
| EGenericType res = EcoreFactory.eINSTANCE.createEGenericType(); |
| res.setETypeParameter(refedTP); |
| return res; |
| } |
| |
| public static EGenericType getUnboundedWildcard() { |
| EGenericType res = EcoreFactory.eINSTANCE.createEGenericType(); |
| return res; |
| } |
| |
| public static EGenericType getUpperBoundedWildcard(EGenericType gt) { |
| EGenericType res = EcoreFactory.eINSTANCE.createEGenericType(); |
| res.setEUpperBound(gt); |
| return res; |
| } |
| |
| public static EGenericType getLowerBoundedWildcard(EGenericType gt) { |
| EGenericType res = EcoreFactory.eINSTANCE.createEGenericType(); |
| res.setELowerBound(gt); |
| return res; |
| } |
| |
| public static EGenericType getParameterizedType(EClassifier declaredType, List<EGenericType> typeArgs) { |
| EGenericType res = getEGenericType(declaredType); |
| res.getETypeArguments().addAll(typeArgs); |
| return res; |
| } |
| |
| /** |
| * from org.eclipse.emf.ecore.provider.EGenericItemProvider |
| */ |
| public static String getText(EGenericType eGenericType) { |
| ETypeParameter eTypeParameter = eGenericType.getETypeParameter(); |
| if (eTypeParameter != null) { |
| String name = eTypeParameter.getName(); |
| return name == null ? "null" : name; |
| } else { |
| EClassifier eClassifier = eGenericType.getEClassifier(); |
| if (eClassifier != null) { |
| List<EGenericType> eTypeArguments = eGenericType.getETypeArguments(); |
| if (eTypeArguments.isEmpty()) { |
| String name = eClassifier.getName(); |
| return name == null ? "null" : name; |
| } else { |
| StringBuilder result = new StringBuilder(); |
| result.append(eClassifier.getName()); |
| result.append('<'); |
| for (Iterator<EGenericType> i = eTypeArguments.iterator();;) { |
| result.append(getText(i.next())); |
| if (i.hasNext()) { |
| result.append(", "); |
| } else { |
| break; |
| } |
| } |
| result.append('>'); |
| return result.toString(); |
| } |
| } else { |
| EGenericType eUpperBound = eGenericType.getEUpperBound(); |
| if (eUpperBound != null) { |
| return "? extends " + getText(eUpperBound); |
| } else { |
| EGenericType eLowerBound = eGenericType.getELowerBound(); |
| if (eLowerBound != null) { |
| return "? super " + getText(eLowerBound); |
| } else { |
| return "?"; |
| } |
| } |
| } |
| } |
| } |
| |
| /** |
| * from org.eclipse.emf.ecore.provider.ETypeParameterItemProvider |
| */ |
| public static String getText(ETypeParameter eTypeParameter) { |
| if (eTypeParameter.getEBounds().isEmpty()) { |
| String name = eTypeParameter.getName(); |
| return name == null ? "null" : name; |
| } else { |
| StringBuilder result = new StringBuilder(); |
| result.append(eTypeParameter.getName()); |
| result.append(" extends "); |
| for (Iterator<EGenericType> i = eTypeParameter.getEBounds().iterator(); i.hasNext();) { |
| result.append(getText(i.next())); |
| if (i.hasNext()) { |
| result.append(" & "); |
| } |
| } |
| return result.toString(); |
| } |
| } |
| |
| public static boolean isRefToTypeParam(EGenericType type) { |
| boolean res = type.getEClassifier() == null; |
| res &= type.getETypeParameter() != null; |
| return res; |
| } |
| |
| public static boolean isWildcard(EGenericType type) { |
| boolean res = type.getEClassifier() == null; |
| res &= type.getETypeParameter() == null; |
| return res; |
| } |
| |
| public static boolean isParameterizedType(EGenericType type) { |
| boolean res = (type.getEClassifier() != null) && (type.getETypeArguments().size() > 0); |
| return res; |
| } |
| |
| public static boolean isRefToClassifier(EGenericType type) { |
| boolean res = isParameterizedType(type) || isRefToNonGeneric(type) || isRawTypeReference(type); |
| return res; |
| } |
| |
| public static boolean isRawTypeReference(EGenericType type) { |
| boolean res = (type.getEClassifier() != null) && (type.getETypeArguments().size() == 0) |
| && (type.getEClassifier().getETypeParameters().size() > 0); |
| return res; |
| } |
| |
| public static boolean isRefToNonGeneric(EGenericType type) { |
| boolean res = (type.getEClassifier() != null) && (type.getEClassifier().getETypeParameters().size() == 0); |
| return res; |
| } |
| |
| public static boolean isUnboundedWildcard(EGenericType type) { |
| boolean res = isWildcard(type) && (type.getEUpperBound() == null) && (type.getELowerBound() == null); |
| return res; |
| } |
| |
| public static boolean isUpperBoundedWildcard(EGenericType type) { |
| boolean res = isWildcard(type) && (type.getEUpperBound() != null); |
| return res; |
| } |
| |
| public static boolean isLowerBoundedWildcard(EGenericType type) { |
| boolean res = isWildcard(type) && (type.getELowerBound() != null); |
| return res; |
| } |
| |
| public static boolean isWellFormed(EGenericType gt) { |
| Diagnostician diagnostician = new Diagnostician(); |
| final Diagnostic diagnostic = diagnostician.validate(gt); |
| boolean res = (diagnostic.getSeverity() == Diagnostic.OK); |
| return res; |
| } |
| |
| public static List<String> getDiagnosticMsgs(EGenericType gt) { |
| List<String> res = new ArrayList<String>(); |
| Diagnostician diagnostician = new Diagnostician(); |
| final Diagnostic diagnostic = diagnostician.validate(gt); |
| if (diagnostic.getSeverity() == Diagnostic.OK) { |
| return res; |
| } |
| for (Diagnostic childDiagnostic : diagnostic.getChildren()) { |
| String msg = childDiagnostic.getMessage(); |
| res.add(msg); |
| } |
| return res; |
| } |
| |
| } |