static Builder newBuilder(TypeElement enclosingElement) { TypeMirror typeMirror = enclosingElement.asType(); boolean isView = isSubtypeOfType(typeMirror, VIEW_TYPE); boolean isActivity = isSubtypeOfType(typeMirror, ACTIVITY_TYPE); boolean isDialog = isSubtypeOfType(typeMirror, DIALOG_TYPE); TypeName targetType = TypeName.get(typeMirror); if (targetType instanceof ParameterizedTypeName) { targetType = ((ParameterizedTypeName) targetType).rawType; } String packageName = getPackage(enclosingElement).getQualifiedName().toString(); String className = enclosingElement.getQualifiedName().toString().substring( packageName.length() + 1).replace('.', '$'); ClassName bindingClassName = ClassName.get(packageName, className + "_ViewBinding"); boolean isFinal = enclosingElement.getModifiers().contains(Modifier.FINAL); return new Builder(targetType, bindingClassName, isFinal, isView, isActivity, isDialog); }
.build(); String packageName = MoreElements.getPackage(type).getQualifiedName().toString(); String className = String.format("%sAdapter", type.getSimpleName()); TypeSpec adapterClass = TypeSpec.classBuilder(className)
String packageName = MoreElements.getPackage(type).getQualifiedName().toString(); executeName = StringUtils.capitalize(executeName); String className = String.format("%s%sHandler%s", type.getSimpleName(), executeName, "");
private AutoValueExtension.Context createContext(TypeElement type) { String packageName = MoreElements.getPackage(type).getQualifiedName().toString(); Set<ExecutableElement> allMethods = MoreElements.getLocalAndInheritedMethods(type, elements); Set<ExecutableElement> methods = methodsToImplement(type, allMethods); Map<String, ExecutableElement> properties = new LinkedHashMap<String, ExecutableElement>(); for (ExecutableElement e : methods) { properties.put(e.getSimpleName().toString(), e); } return new TestContext(processingEnvironment, packageName, type, properties); }
protected RemoteBuilder(Messager messager, Element remoterInterfaceElement) { this.messager = messager; this.remoterInterfaceElement = remoterInterfaceElement; if (remoterInterfaceElement != null) { this.remoterInterfacePackageName = getPackage(remoterInterfaceElement).getQualifiedName().toString(); this.remoterInterfaceClassName = remoterInterfaceElement.getSimpleName().toString(); } }
static Builder newBuilder(TypeElement typeElement) { ClassName annotatedClassName = ClassName.get(typeElement); String packageName = getPackage(typeElement).getQualifiedName().toString(); String annotatedClassNameString = typeElement.getQualifiedName().toString().substring( packageName.length() + 1).replace('.', '$'); ClassName generatedClassName = ClassName.get(packageName, annotatedClassNameString + PREFIX); return new Builder(annotatedClassName, generatedClassName); }
static boolean methodVisibleFromPackage(ExecutableElement method, PackageElement pkg) { // We use Visibility.ofElement rather than .effectiveVisibilityOfElement because it doesn't // really matter whether the containing class is visible. If you inherit a public method // then you have a public method, regardless of whether you inherit it from a public class. Visibility visibility = Visibility.ofElement(method); switch (visibility) { case PRIVATE: return false; case DEFAULT: return getPackage(method).equals(pkg); default: return true; } }
/** * Returns the {@link ClassName} for the Proxy */ private ClassName getProxyClassName(TypeMirror param) { Element element = getBindingManager().getElement(param.toString()); return ClassName.get(getPackage(element).getQualifiedName().toString(), element.getSimpleName() + ClassBuilder.PROXY_SUFFIX); }
/** * Returns the {@link ClassName} for the Stub */ private ClassName getStubClassName(TypeMirror param) { Element element = getBindingManager().getElement(param.toString()); return ClassName.get(getPackage(element).getQualifiedName().toString(), element.getSimpleName() + ClassBuilder.STUB_SUFFIX); }
String getFactoryName() { CharSequence packageName = getPackage(targetType()).getQualifiedName(); StringBuilder builder = new StringBuilder(packageName); if (packageName.length() > 0) { builder.append('.'); } if (className().isPresent()) { builder.append(className().get()); } else { for (String enclosingSimpleName : targetEnclosingSimpleNames()) { builder.append(enclosingSimpleName).append('_'); } builder.append(targetType().getSimpleName()).append("Factory"); } return builder.toString(); }
static Builder newBuilder(TypeElement enclosingElement) { TypeMirror typeMirror = enclosingElement.asType(); boolean isView = isSubtypeOfType(typeMirror, VIEW_TYPE); boolean isActivity = isSubtypeOfType(typeMirror, ACTIVITY_TYPE); boolean isDialog = isSubtypeOfType(typeMirror, DIALOG_TYPE); TypeName targetType = TypeName.get(typeMirror); if (targetType instanceof ParameterizedTypeName) { targetType = ((ParameterizedTypeName) targetType).rawType; } String packageName = getPackage(enclosingElement).getQualifiedName().toString(); String className = enclosingElement.getQualifiedName().toString().substring( packageName.length() + 1).replace('.', '$'); ClassName bindingClassName = ClassName.get(packageName, className + "_ViewBinding"); boolean isFinal = enclosingElement.getModifiers().contains(Modifier.FINAL); return new Builder(targetType, bindingClassName, isFinal, isView, isActivity, isDialog); }
private static ImmutableSet<ExecutableElement> getLocalAndInheritedMethods( TypeElement type, Overrides overrides) { SetMultimap<String, ExecutableElement> methodMap = LinkedHashMultimap.create(); getLocalAndInheritedMethods(getPackage(type), type, methodMap); // Find methods that are overridden. We do this using `Elements.overrides`, which means // that it is inherently a quadratic operation, since we have to compare every method against // every other method. We reduce the performance impact by (a) grouping methods by name, since // a method cannot override another method with a different name, and (b) making sure that // methods in ancestor types precede those in descendant types, which means we only have to // check a method against the ones that follow it in that order. Set<ExecutableElement> overridden = new LinkedHashSet<ExecutableElement>(); for (Collection<ExecutableElement> methods : methodMap.asMap().values()) { List<ExecutableElement> methodList = ImmutableList.copyOf(methods); for (int i = 0; i < methodList.size(); i++) { ExecutableElement methodI = methodList.get(i); for (int j = i + 1; j < methodList.size(); j++) { ExecutableElement methodJ = methodList.get(j); if (overrides.overrides(methodJ, methodI, type)) { overridden.add(methodI); } } } } Set<ExecutableElement> methods = new LinkedHashSet<ExecutableElement>(methodMap.values()); methods.removeAll(overridden); return ImmutableSet.copyOf(methods); }
Element element = declaredType.asElement(); packageName = getPackage(element).getQualifiedName().toString(); simpleName = element.getSimpleName().toString(); typeArguments = from(declaredType.getTypeArguments())
return false; if (!MoreElements.methodVisibleFromPackage(overridden, MoreElements.getPackage(overrider))) {