private TypeName returnType() { return methodInfo .returnTypeInfo() .typeName(); }
public static FieldMethod code(Property property, AnnotationInfo fieldAnnotation) { SimpleTypeInfo returnTypeInfo = property.returnTypeInfo(); return returnTypeInfo.isInfoOf(Optional.class) ? OptionalMethod.code(property, fieldAnnotation, returnTypeInfo) : StandardMethod.code(property, fieldAnnotation, returnTypeInfo); }
@Override public final int hashCode() { return Objects.hashCode(packageInfo(), simpleName()); }
public boolean isSubType(Class<?> maybeSuperType) { try { String qualifiedName = qualifiedName(); Class<?> theClass = Class.forName(qualifiedName); return maybeSuperType.isAssignableFrom(theClass); } catch (ClassNotFoundException e) { return isInfoOf(maybeSuperType); } }
@Override public MustacheObject toMustache() { return Mustaches.toMustacheHelper() .add("package", packageInfo().orNull()) .add("name", getDeclaredName()) .add("simpleName", simpleName()) .add("qualifiedName", toString()) .add("rawName", getRawName()) .add("varName", varName()) .add("primitive", isPrimitive()) .toMustache(); }
public Set<ImportInfo> toImportInfo() { Set<ImportInfo> importInfoSet = newHashSet(); PackageInfoToImportInfo toImportInfo = new PackageInfoToImportInfo(nameInfo()); Optional<ImportInfo> maybeImportInfo = packageInfo() .transform(toImportInfo); if (maybeImportInfo.isPresent()) { ImportInfo importInfo = maybeImportInfo.get(); importInfoSet.add(importInfo); } List<TypeParameterInfo> typeParameterInfoList = typeParameterInfoList(); for (TypeParameterInfo typeParameterInfo : typeParameterInfoList) { Set<ImportInfo> importInfo = typeParameterInfo.toSimpleTypeInfo() .toImportInfo(); importInfoSet.addAll(importInfo); } return importInfoSet; }
@Override public boolean isEqual(SimpleTypeInfo that) { return Testables.isEqualHelper() .equal(packageInfo(), that.packageInfo()) .equal(nameInfo(), that.nameInfo()) .equal(typeParameterInfoList(), that.typeParameterInfoList()) .result(); }
void recordBuilderCode(Body body) { SimpleTypeInfo returnTypeInfo = property.returnTypeInfo(); if (returnTypeInfo.isPrimitive()) { body.add(".$L(record.$LValue())", property.name(), returnTypeInfo.simpleName()); } else { body.add(".$L(record.<$T> get())", property.name(), returnTypeInfo.typeName()); } }
@Override NameInfo nameInfo() { return delegate.nameInfo(); }
private TypeName toTypeName0(SimpleTypeInfo simpleTypeInfo, Function<TypeParameterInfo, TypeName> f) { NameInfo nameInfo = simpleTypeInfo.nameInfo(); Optional<PackageInfo> packageInfo = simpleTypeInfo.packageInfo(); ClassName className = nameInfo.toClassName(packageInfo.get()); TypeName[] genericTypeNameArray = simpleTypeInfo.getTypeParameterInfoIterable() .transform(f) .toImmutableList() .toArray(new TypeName[] {}); return genericTypeNameArray.length == 0 ? className : ParameterizedTypeName.get(className, genericTypeNameArray); }
public String getRawName() { String simpleName = nameInfo().getSimpleName(); StringBuilder name = new StringBuilder(simpleName); List<TypeParameterInfo> typeParameterInfoList = typeParameterInfoList(); TypeParameterInfoMap map = TypeParameterInfoMap.mapOf(typeParameterInfoList); name.append(map.toStringRaw()); return name.toString(); }
public String qualifiedName() { String res = nameInfo().toString(); Optional<? extends PackageInfo> packageInfo = packageInfo(); if (packageInfo.isPresent()) { PackageInfo pkg = packageInfo.get(); res = pkg.toImportInfo(nameInfo()) .toString(); } return res; }
@Override SimpleTypeInfoKind kind() { return delegate.kind(); }
@AutoFunctional public boolean hasReturnTypeInfo(SimpleTypeInfo typeInfo) { return returnTypeInfo().equals(typeInfo); }
@Override public SimpleTypeInfo build() { SimpleTypeInfo simpleTypeInfo = SimpleTypeInfo.newType() .packageInfo(Optional.fromNullable(packageInfo)) .nameInfo(name) .typeParameterInfoList(typeParameterInfoList) .build(); if (primitive) { simpleTypeInfo = SimpleTypeInfo.newPrimitive() .packageInfo(Optional.fromNullable(packageInfo)) .nameInfo(name) .typeParameterInfoList(typeParameterInfoList) .build(); } if (typeVariable) { simpleTypeInfo = SimpleTypeInfo.newTypeVariable() .packageInfo(Optional.fromNullable(packageInfo)) .nameInfo(name) .typeParameterInfoList(typeParameterInfoList) .build(); } return new ForwardingSimpleTypeInfo(simpleTypeInfo, typeInfo); }
@Override List<TypeParameterInfo> typeParameterInfoList() { return delegate.typeParameterInfoList(); }
private static SimpleTypeInfo named(String name) { return SimpleTypeInfo.newPrimitive() .packageInfo(Optional.<PackageInfo> absent()) .nameInfo(NameInfo.of(name)) .typeParameterInfoList(ImmutableList.<TypeParameterInfo> of()) .build(); }
@Override Optional<PackageInfo> packageInfo() { return component.packageInfo(); }
@Override public SimpleTypeInfo toSimpleTypeInfo() { return component.toSimpleTypeInfo().toArray(); }