public static boolean areEquivalent(String left, String right) { if ((left == null) && (right == null)) return true; if ((left == null) || (right == null)) return false; if (left.equals(right)) return true; left = stripGenerics(left); right = stripGenerics(right); String l = toSimpleName(left); String r = toSimpleName(right); String lp = getPackage(left); String rp = getPackage(right); if (l.equals(r)) { return !(!lp.isEmpty() && !rp.isEmpty()); } return false; }
public static boolean isBasicType(String idType) { return isPrimitive(idType) || Arrays.asList("Boolean", "Byte", "Double", "Float", "Integer", "Long", "Short", "String").contains( idType); }
@Override public boolean hasImport(final String type) { String resultType = type; if (Types.isArray(type)) { resultType = Types.stripArray(type); } if (Types.isGeneric(type)) { resultType = Types.stripGenerics(type); } return getImport(resultType) != null; }
public static String getGenericsTypeParameter(final String type) { if (isGeneric(type)) { return stripArray(type).replaceFirst("^[^<]*<(.*?)>$", "$1"); } return ""; }
private static boolean validateNameWithGenerics(String name) { return isGeneric(name) || validateName(name) || WILDCARD_AWARE_TYPE_PATTERN.matcher(name).matches(); }
if (Types.isArray(result)) original = Types.stripArray(result); result = Types.stripArray(result); if (Types.isGeneric(result)) original = Types.stripGenerics(result); result = Types.stripGenerics(result); if (Types.isPrimitive(result)) if (Types.isSimpleName(result)) if (!hasImport(type) && Types.isJavaLang(type)) if (Types.areEquivalent(result, imprt.getQualifiedName())) if (Types.isSimpleName(result)) if (Types.isQualified(result)) break; if (Types.isSimpleName(result))
@Override public AnnotationElementSource setType(final String typeName) String simpleName = Types.toSimpleName(typeName); if (Types.isArray(typeName)) String arrayType = Types.stripArray(typeName); int arrayDimension = Types.getArrayDimension(typeName); if (Types.isPrimitive(arrayType)) String[] className = Types.tokenizeClassName(typeName); Name name = ast.newName(className); type = ast.newSimpleType(name);
if (isGeneric(stripArray(type))) result = stripGenerics(result); String[] tokens = tokenizeClassName(result); if (tokens != null) if (isGeneric(type)) StringTokenizer tok = new StringTokenizer(getGenericsTypeParameter(type), ","); while (tok.hasMoreTokens()) while (incompleteGenerics(typeParameter) && tok.hasMoreElements()) simpleType = toSimpleName(matcher.group(2)); if (matcher.start(1) >= 0) if (isArray(result))
if (Types.isGeneric(type)) String typeD = Types.stripGenerics(type); String simpleTypeDName = Types.toSimpleName(typeD); addImport(type); for (String typeP : Types.splitGenerics(type)) Type t = TypeImpl.fromString(Types.toSimpleName(typeP.trim()), body.getAST()); pt.typeArguments().add(t); final SimpleName simpleName = body.getAST().newSimpleName(Types.toSimpleName(type)); final Type superType; Import imprt = addImport(type); if (imprt == null && !Types.isSimpleName(type)) final Name qualifier = body.getAST().newName(Types.getPackage(type)); superType = body.getAST().newNameQualifiedType(qualifier, simpleName);
if (Types.isArray(result)) result = Types.stripArray(result); if (Types.isGeneric(result)) result = Types.stripGenerics(result); if (Types.isPrimitive(result)) if (Types.isQualified(result)) if (Types.isJavaLang(result)) if (Types.isQualified(result)) return result;
public static String stripGenerics(final String type) { final String componentType; final int arrayDimensions; if (isArray(type)) { arrayDimensions = getArrayDimension(type); componentType = stripArray(type); } else { arrayDimensions = 0; componentType = type; } if (isGeneric(componentType)) { final StringBuilder result = new StringBuilder(componentType.replaceFirst("^([^<]*)<.*?>$", "$1")); for (int i = 0; i < arrayDimensions; i++) { result.append("[]"); } return result.toString(); } return type; }
private void setPropertiesFromName(JavaClassModel model, String qualifiedName) { model.setQualifiedName(qualifiedName); model.setSimpleName(Types.toSimpleName(qualifiedName)); model.setPackageName(Types.getPackage(qualifiedName)); }
private boolean validImport(final String type) { String className = Types.toSimpleName(type); // check if this class name is equal to the class to import if (className.equals(getName())) { return false; } // check if any import has the same class name for (final Import imprt : getImports()) { String importClassName = imprt.getSimpleName(); if (importClassName.equals(className)) { return false; } } return !Strings.isNullOrEmpty(type) && !Types.isPrimitive(type) && !Strings.isNullOrEmpty(Types.getPackage(type)); }
@SuppressWarnings("unchecked") @Override public Import addImport(final String className) { String strippedClassName = Types.stripGenerics(Types.stripArray(className)); if (Types.isGeneric(className)) { for (String genericPart : Types.splitGenerics(className)) { if (Types.isQualified(genericPart)) addImport(genericPart); } } Import imprt; if (!hasImport(strippedClassName) && validImport(strippedClassName)) { imprt = new ImportImpl(this).setName(strippedClassName); unit.imports().add(imprt.getInternal()); } else if (hasImport(strippedClassName)) { imprt = getImport(strippedClassName); } else { imprt = null; } return imprt; }
@Override public Import addImport(final String className) { String strippedClassName = Types.stripGenerics(Types.stripArray(className)); Import imprt; if (Types.isSimpleName(strippedClassName) && !hasImport(strippedClassName)) { throw new IllegalArgumentException("Cannot import class without a package [" + strippedClassName + "]"); } if (!hasImport(strippedClassName) && validImport(strippedClassName)) { imprt = new ImportImpl(this).setName(strippedClassName); unit.imports().add(imprt.getInternal()); } else if (hasImport(strippedClassName)) { imprt = getImport(strippedClassName); } else { throw new IllegalArgumentException("Attempted to import the illegal type [" + strippedClassName + "]"); } return imprt; }
@Override public String getSimpleName() { return Types.toSimpleName(getQualifiedName()); }
public static <O extends JavaType<O>> String rebuildGenericNameWithArrays(String resolvedTypeName, Type<O> type) { StringBuilder resolvedType = new StringBuilder(stripArray(resolvedTypeName)); resolvedType.append(getGenerics(type.toString())); for (int j = 0; j < getArrayDimension(type.getName()); j++) { resolvedType.append("[]"); } return resolvedType.toString(); }
@Override public FieldSource<O> setType(String typeName) { O origin = getOrigin(); Type<O> innerType = new TypeImpl<O>(origin, null, typeName); Import imprt = getOrigin().addImport(innerType); String resolvedType = (imprt != null) ? Types.rebuildGenericNameWithArrays(imprt.getSimpleName(), innerType) : typeName; if (Types.isJavaLang(resolvedType)) { resolvedType = Types.toSimpleName(typeName); } org.eclipse.jdt.core.dom.Type fieldType = TypeImpl.fromString(resolvedType, this.ast); field.setType(fieldType); return this; }
private AnnotationSource<O> addAnnotation(final AnnotationTargetSource<O, T> target, final List<?> modifiers, final String className) { if (!target.getOrigin().hasImport(className) && Types.isQualified(className)) { target.getOrigin().addImport(className); } return addAnnotation(target, modifiers).setName(Types.toSimpleName(className)); }
@Override public String getName() { String result = type.toString(); if (isParameterized()) { // strip type parameters after stripping array dimensions if (isArray()) { result = Types.stripArray(result); } result = Types.stripGenerics(result); // restore array dimensions for (int i = 0, dim = getArrayDimensions(); i < dim; i++) { result += "[]"; } return result; } for (int i = 0, dim = getExtraDimensions(); i < dim; i++) { result += "[]"; } return result; }