private void handleBaseBuilder() { if (!MoreTypes.isTypeOf(Object.class, baseBuilder.asType())) { final List<ExecutableElement> constructors = ElementFilter.constructorsIn(baseBuilder.getEnclosedElements()); Optional<ExecutableElement> constructor = constructors.stream().filter(c -> c.getParameters().size() == 0).findAny(); if (constructor.isPresent()) { elements.add(modelFactory.fromDelegateConstructor(constructor.get(), false)); } else { constructor = constructors.stream().filter(c -> c.getParameters().size() == 1 && Types.CONTEXT.equals(TypeName.get(c.getParameters().get(0).asType()))).findAny(); if (constructor.isPresent()) { elements.add(modelFactory.fromDelegateConstructor(constructor.get(), true)); } else { final AnnotationMirror mirror = baseAnnotation.getAnnotationMirrors().stream() .filter(m -> MoreTypes.isTypeOf(Configuration.class, m.getAnnotationType())) .findAny().orElseThrow(IllegalArgumentException::new); messager.printMessage(Diagnostic.Kind.ERROR, "Classes used as base builder must have a constructor which takes no arguments, " + "or exactly one argument of type Class", baseAnnotation, mirror, mirror.getElementValues().entrySet().stream() .filter(entry -> entry.getKey().getSimpleName().toString().equals("builderSuperClass")).findAny().map(Map.Entry::getValue).orElse(null)); throw new IllegalArgumentException(); } } handleBaseBuilderMethods(); } }
@Override public Boolean visitByte(byte b, TypeMirror expectedType) { return MoreTypes.isTypeOf(Byte.TYPE, expectedType); }
@Override public Boolean visitFloat(float f, TypeMirror expectedType) { return MoreTypes.isTypeOf(Float.TYPE, expectedType); }
@Override public Boolean visitBoolean(boolean b, TypeMirror expectedType) { return MoreTypes.isTypeOf(Boolean.TYPE, expectedType); }
@Override public Boolean visitLong(long l, TypeMirror expectedType) { return MoreTypes.isTypeOf(Long.TYPE, expectedType); }
@Override public Boolean visitDouble(double d, TypeMirror expectedType) { return MoreTypes.isTypeOf(Double.TYPE, expectedType); }
@Override public Boolean visitShort(short s, TypeMirror expectedType) { return MoreTypes.isTypeOf(Short.TYPE, expectedType); } };
@Override public Boolean visitChar(char c, TypeMirror expectedType) { return MoreTypes.isTypeOf(Character.TYPE, expectedType); }
@Override public Boolean visitInt(int i, TypeMirror expectedType) { return MoreTypes.isTypeOf(Integer.TYPE, expectedType); }
@Override protected Boolean defaultAction(Object o, TypeMirror expectedType) { return MoreTypes.isTypeOf(o.getClass(), expectedType); }
/** {@code true} if {@code type} is a {@link Provider}. */ static boolean isProvider(TypeMirror type) { return MoreTypes.isType(type) && MoreTypes.isTypeOf(Provider.class, type); }
@Override public Boolean visitArray(ArrayType array, Void p) { return clazz.isArray() && isTypeOf(clazz.getComponentType(), array.getComponentType()); }
@Nonnull public static CodeBlock createUnmodifiableStatement(@Nonnull TypeMirror type, @Nonnull String variable) { if (type.getKind() == TypeKind.ARRAY) { return CodeBlock.of("$T.copyOf($N, $N.length)", Arrays.class, variable, variable); } if (MoreTypes.isTypeOf(List.class, type)) { return CodeBlock.of("new $T<>($N)", ArrayList.class, variable); } if (MoreTypes.isTypeOf(Set.class, type)) { return CodeBlock.of("new $T<>($N)", HashSet.class, variable); } if (MoreTypes.isTypeOf(Map.class, type)) { return CodeBlock.of("new $T<>($N)", HashMap.class, variable); } return CodeBlock.of("$N", variable); } }
public StoreMethodModel(ExecutableElement element, StoreModel storeModel) { this.element = element; this.storeModel = storeModel; List<TypeName> states = FluentIterable.from(storeModel.getStoreImplModels()) .transform(new Function<StoreImplModel, TypeName>() { @Override public TypeName apply(StoreImplModel input) { return input.getState(); } }).toList(); returnType = MoreTypes.asDeclared(element.getReturnType()); if (states.contains(ClassName.get(returnType))) { kind = Kind.GETTER; isBindable = element.getAnnotation(Bindable.class) != null; } else if (getName().equals(DispatcherModel.DISPATCH_METHOD_NAME)) { kind = Kind.DISPATCH; } else if (MoreTypes.isTypeOf(OBSERVE_METHOD_CLASS, returnType.asElement().asType()) && states.contains(ClassName.get(returnType.getTypeArguments().get(0)))) { if (element.getParameters() != null && !element.getParameters().isEmpty() && MoreTypes.isTypeOf(BACKPRESSURE_STRATEGY_PARAM_CLASS, element.getParameters().get(0).asType())) { bpsParamName = element.getParameters().get(0).getSimpleName().toString(); kind = Kind.OBSERVE_WITH_BPS; } else { kind = Kind.OBSERVE; } } else { kind = Kind.UNKNOWN; } }
private boolean isValidContentSlot(VariableElement field) { if (isTypeOf(NestedSlot.class, field.asType())) { if (!hasModifiers(PRIVATE, STATIC).apply(field)) { return true; } logger.mandatoryWarning() .context(field) .log("Content slots cannot be static or private."); } return false; }
private DeclaredType getHandlerTypeMirror() { if (handlerTypeMirror == null) { Optional<DeclaredType> optionalSuperType = nonObjectSuperclass(utils.getTypes(), utils.getElements(), getEventTypeMirror()); while (optionalSuperType.isPresent()) { DeclaredType superType = optionalSuperType.get(); if (isTypeOf(Event.class, superType)) { handlerTypeMirror = extractHandlerTypeFromEvent(superType); break; } else { optionalSuperType = nonObjectSuperclass(utils.getTypes(), utils.getElements(), superType); } } } return handlerTypeMirror; }