static String getEventHandlerInstanceName(ClassName eventHandlerClassName) { final String eventHandlerName = eventHandlerClassName.simpleName(); return eventHandlerName.substring(0, 1).toLowerCase(Locale.ROOT) + eventHandlerName.substring(1) + "Handler"; }
public static String getClassName(TypeElement typeElement) throws ClassNotFoundException { return ClassName.get(typeElement).simpleName(); }
public static Builder classBuilder(ClassName className) { return classBuilder(checkNotNull(className, "className == null").simpleName()); }
private static String getComponentName(String componentClassName, String qualifiedSpecClassName) { return getComponentTypeName(componentClassName, qualifiedSpecClassName).simpleName(); }
private void importableType(ClassName className) { if (className.packageName().isEmpty()) { return; } ClassName topLevelClassName = className.topLevelClassName(); String simpleName = topLevelClassName.simpleName(); ClassName replaced = importableTypes.put(simpleName, topLevelClassName); if (replaced != null) { importableTypes.put(simpleName, replaced); // On collision, prefer the first inserted. } }
static TypeName getEventNativeType(TypeName typeName) { if (typeName instanceof ParameterizedTypeName) { return TypeName.get(byte[].class); } String simpleName = ((ClassName) typeName).simpleName(); if (simpleName.equals(Utf8String.class.getSimpleName())) { return TypeName.get(byte[].class); } else { return getNativeType(typeName); } }
/** Returns a parameterized type equivalent to {@code type}. */ static ParameterizedTypeName get(ParameterizedType type, Map<Type, TypeVariableName> map) { ClassName rawType = ClassName.get((Class<?>) type.getRawType()); ParameterizedType ownerType = (type.getOwnerType() instanceof ParameterizedType) && !Modifier.isStatic(((Class<?>) type.getRawType()).getModifiers()) ? (ParameterizedType) type.getOwnerType() : null; List<TypeName> typeArguments = TypeName.list(type.getActualTypeArguments(), map); return (ownerType != null) ? get(ownerType, map).nestedClass(rawType.simpleName(), typeArguments) : new ParameterizedTypeName(null, rawType, typeArguments); } }
@Override public TypeName visitDeclared(DeclaredType t, Void p) { ClassName rawType = ClassName.get((TypeElement) t.asElement()); TypeMirror enclosingType = t.getEnclosingType(); TypeName enclosing = (enclosingType.getKind() != TypeKind.NONE) && !t.asElement().getModifiers().contains(Modifier.STATIC) ? enclosingType.accept(this, null) : null; if (t.getTypeArguments().isEmpty() && !(enclosing instanceof ParameterizedTypeName)) { return rawType; } List<TypeName> typeArgumentNames = new ArrayList<>(); for (TypeMirror mirror : t.getTypeArguments()) { typeArgumentNames.add(get(mirror, typeVariables)); } return enclosing instanceof ParameterizedTypeName ? ((ParameterizedTypeName) enclosing).nestedClass( rawType.simpleName(), typeArgumentNames) : new ParameterizedTypeName(null, rawType, typeArgumentNames); }
public static Builder annotationBuilder(ClassName className) { return annotationBuilder(checkNotNull(className, "className == null").simpleName()); }
public static Builder interfaceBuilder(ClassName className) { return interfaceBuilder(checkNotNull(className, "className == null").simpleName()); }
public static Builder enumBuilder(ClassName className) { return enumBuilder(checkNotNull(className, "className == null").simpleName()); }
/** * Returns the Java type of the abstract adapter class generated for a corresponding {@code * protoType}. Returns null if {@code protoType} is not using a custom proto adapter. */ public @Nullable ClassName abstractAdapterName(ProtoType protoType) { TypeName profileJavaName = profile.getTarget(protoType); if (profileJavaName == null) return null; ClassName javaName = nameToJavaName.get(protoType); Type type = schema.getType(protoType); return type instanceof EnumType ? javaName.peerClass(javaName.simpleName() + "Adapter") : javaName.peerClass("Abstract" + javaName.simpleName() + "Adapter"); }
/** * Write a companion class for {@code type} that extends {@link StaticInjection}. */ private void generateStaticInjection(TypeElement type, List<Element> fields) throws IOException { ClassName typeName = ClassName.get(type); ClassName adapterClassName = adapterName(ClassName.get(type), STATIC_INJECTION_SUFFIX); TypeSpec.Builder result = TypeSpec.classBuilder(adapterClassName.simpleName()) .addOriginatingElement(type) .addJavadoc(AdapterJavadocs.STATIC_INJECTION_TYPE, type) .addModifiers(PUBLIC, FINAL) .superclass(StaticInjection.class); for (Element field : fields) { result.addField(memberBindingField(false, field)); } result.addMethod(attachMethod(null, fields, false, typeName, null, true)); result.addMethod(staticInjectMethod(fields, typeName)); String packageName = getPackage(type).getQualifiedName().toString(); JavaFile javaFile = JavaFile.builder(packageName, result.build()) .addFileComment(AdapterJavadocs.GENERATED_BY_DAGGER) .build(); javaFile.writeTo(processingEnv.getFiler()); }
private static String getTypeNameString(ClassName className) { ClassName enclosingClass = className.enclosingClassName(); if (enclosingClass == null) { return className.toString(); } return enclosingClass.toString() + "$" + className.simpleName(); } }
private TypeSpec createType(int sdk, boolean debuggable) { TypeSpec.Builder result = TypeSpec.classBuilder(bindingClassName.simpleName()) .addModifiers(PUBLIC); if (isFinal) {
private TypeSpec classProviders(ClassName className, List<MethodSpec> methodSpecs) { return TypeSpec.classBuilder(className.simpleName() + "Actionable") .addModifiers(Modifier.PUBLIC) .addAnnotation(AnnotationSpec.builder(Generated.class) .addMember("value", "$S", ActionsProcessor.class.getCanonicalName()) .addMember("comments", "$S", "Generated code from RxCache. Don't modify. Or modify. It doesn't matter.") .build()) .addMethods(methodSpecs) .build(); }
if (requiresRemoval) { TypeName listenerClassName = bestGuess(listenerClass.type()); listenerField = fieldName + ((ClassName) listenerClassName).simpleName(); result.addField(listenerClassName, listenerField, PRIVATE);
@Override protected TypeSpec.Builder createClassBuilder() { return TypeSpec.classBuilder(getClassDetail().getGeneratedClassName()) .superclass(ParameterizedTypeName.get( getClassDetail().getSuperClassName(), TypeVariableName.get(getClassDetail().getTypeElement().asType()), TypeVariableName.get(getClassDetail().getViewTypeParameterClassName().simpleName()))) .addModifiers(Modifier.PUBLIC) .addAnnotation(Keep.class); }
@Override CodeWriter emit(CodeWriter out) throws IOException { if (enclosingType != null) { enclosingType.emit(out); out.emit("."); if (isAnnotated()) { out.emit(" "); emitAnnotations(out); } out.emit(rawType.simpleName()); } else { rawType.emit(out); } if (!typeArguments.isEmpty()) { out.emitAndIndent("<"); boolean firstParameter = true; for (TypeName parameter : typeArguments) { if (!firstParameter) out.emitAndIndent(", "); parameter.emit(out); firstParameter = false; } out.emitAndIndent(">"); } return out; }
@Before public void ListUp() { mDiffTypeSpecWrappingInt = new TypeSpec.DeclaredTypeSpec( ClassNames.DIFF, ClassNames.DIFF.packageName() + "." + ClassNames.DIFF.simpleName(), () -> new TypeSpec(TypeName.OBJECT), ImmutableList.of(), ImmutableList.of(new TypeSpec(TypeName.INT.box()))); }