protected void handleEGenericType( EGenericType genericType, Set<EPackage> visitedPackages, Set<Object> visited) { if (genericType != null && visited.add(genericType)) { handleEClassifier(genericType.getEClassifier(), visitedPackages, visited); handleEClassifier(genericType.getERawType(), visitedPackages, visited); handleEGenericType(genericType.getELowerBound(), visitedPackages, visited); handleEGenericType(genericType.getEUpperBound(), visitedPackages, visited); handleEGenericTypes(genericType.getETypeArguments(), visitedPackages, visited); handleETypeParameter(genericType.getETypeParameter(), visitedPackages, visited); } }
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 "?"; } } } } }
/** * * <!-- begin-user-doc --> * <!-- end-user-doc --> * * @generated NOT */ @Override protected EStructuralFeature getChildFeature(Object object, Object child) { EGenericType eGenericType = (EGenericType) object; if (child instanceof EObject) { EObject eObject = (EObject) child; if (eObject.eContainer() == eGenericType) { // If it's really a contained child, return the feature for it. // return eObject.eContainingFeature(); } } if (eGenericType.getEClassifier() != null) { // You can only add type arguments if there are type parameters not yet used up. // return eGenericType.getETypeArguments().size() < eGenericType.getEClassifier().getETypeParameters().size() ? EcorePackage.Literals.EGENERIC_TYPE__ETYPE_ARGUMENTS : null; } else if (eGenericType.getETypeParameter() != null) { // You cannot add any children for a type parameter. // return null; } else if (eGenericType.eContainer() instanceof EGenericType) { // Only if you are contained by a generic type can you have bounds, // and only if there is no classifier or type parameter // and in that case the lower bound is returned only if that's the one that's set. // return eGenericType.getELowerBound() != null ? EcorePackage.Literals.EGENERIC_TYPE__EUPPER_BOUND : EcorePackage.Literals.EGENERIC_TYPE__EUPPER_BOUND; } else { // Otherwise you can't make it a child. // return null; } }