@Override default <T extends Annotation> Set<T> getAnnotations(Class<T> annotationType) { T[] annotationsByType = getJavaMember().getAnnotationsByType(annotationType); return new LinkedHashSet<>(asList(annotationsByType)); } }
options.addAll(Arrays.stream(scrapeFields(clazz)) .map(field -> { Annotation[] annotations = field.getAnnotationsByType(Option.class); if (annotations.length > 0) { return Pair.makePair((Option) annotations[0], field);
private static Map<Field, AnnotatedValueResolver> findFields( List<AnnotatedValueResolver> constructorAnnotatedResolvers, Map<Method, List<AnnotatedValueResolver>> methods, BeanFactoryId beanFactoryId, List<RequestObjectResolver> objectResolvers) { final TreeSet<AnnotatedValueResolver> uniques = uniqueResolverSet(); uniques.addAll(constructorAnnotatedResolvers); methods.values().forEach(uniques::addAll); final Builder<Field, AnnotatedValueResolver> builder = ImmutableMap.builder(); final Set<Field> fields = getAllFields(beanFactoryId.type); for (final Field field : fields) { final RequestConverter[] converters = field.getAnnotationsByType(RequestConverter.class); AnnotatedValueResolver.ofBeanField(field, beanFactoryId.pathParams, addToFirstIfExists(objectResolvers, converters)) .ifPresent(resolver -> { if (!uniques.add(resolver)) { warnRedundantUse(resolver, field.toGenericString()); return; } builder.put(field, resolver); }); } return builder.build(); }
public boolean isConditionallyRequired() { RequiredIf[] requiredIfs = this.field.getAnnotationsByType(RequiredIf.class); if (requiredIfs != null && requiredIfs.length > 0) { return true; } else { return false; } }
private Optional<JArchDynamicDetailShowDataAction> getArchDynamicDetailShowDataAction(String idDynamic) { return Arrays .stream(getClass().getDeclaredFields()) .filter(f -> f.getAnnotationsByType(JArchDynamicDetailShowDataAction.class) != null) .flatMap(f -> Arrays.stream(f.getAnnotationsByType(JArchDynamicDetailShowDataAction.class)).filter(f2 -> f2.id().equals(idDynamic))) .findAny(); }
@Override default <T extends Annotation> Set<T> getAnnotations(Class<T> annotationType) { T[] annotationsByType = getJavaMember().getAnnotationsByType(annotationType); return new LinkedHashSet<>(asList(annotationsByType)); } }
@Override default <T extends Annotation> Set<T> getAnnotations(Class<T> annotationType) { return new LinkedHashSet<>(Arrays.asList(getJavaMember().getAnnotationsByType(annotationType))); }
@Override default <T extends Annotation> Set<T> getAnnotations(Class<T> annotationType) { return new LinkedHashSet<>(Arrays.asList(getJavaMember().getAnnotationsByType(annotationType))); }
public Set<Condition> getIgnoredIfConditions() { IgnoredIf[] ignoredIfs = this.field.getAnnotationsByType(IgnoredIf.class); if (ignoredIfs == null || ignoredIfs.length <= 0) { return Collections.emptySet(); } else { Set<Condition> conditions = Sets.newHashSet(); for (IgnoredIf ignoredIf : ignoredIfs) { conditions.add(new Condition(ignoredIf)); } return Collections.unmodifiableSet(conditions); } }
private static void validateField(Field field, Object value, Runtime runtime, ClassLoader classLoader) { List<Annotation> annotationList = new LinkedList<>(); Class<?>[] classes = ConfigValidationAnnotations.class.getDeclaredClasses(); for (Class clazz : classes) { try { Annotation[] anots = field.getAnnotationsByType(clazz); annotationList.addAll(Arrays.asList(anots)); } catch (ClassCastException e) { } } processAnnotations(annotationList, field.getName(), value, runtime, classLoader); }
@Override default <T extends Annotation> Set<T> getAnnotations(Class<T> annotationType) { T[] annotationsByType = getJavaMember().getAnnotationsByType(annotationType); return new LinkedHashSet<>(asList(annotationsByType)); } }
@Override default <T extends Annotation> Set<T> getAnnotations(Class<T> annotationType) { T[] annotationsByType = getJavaMember().getAnnotationsByType(annotationType); return new LinkedHashSet<>(asList(annotationsByType)); } }
@Override default <T extends Annotation> Set<T> getAnnotations(Class<T> annotationType) { T[] annotationsByType = getJavaMember().getAnnotationsByType(annotationType); return new LinkedHashSet<>(asList(annotationsByType)); } }
@Override default <T extends Annotation> Set<T> getAnnotations(Class<T> annotationType) { return new LinkedHashSet<>(Arrays.asList(getJavaMember().getAnnotationsByType(annotationType))); }
@Override default <T extends Annotation> Set<T> getAnnotations(Class<T> annotationType) { T[] annotationsByType = getJavaMember().getAnnotationsByType(annotationType); return new LinkedHashSet<>(asList(annotationsByType)); } }
@Override default <T extends Annotation> Set<T> getAnnotations(Class<T> annotationType) { T[] annotationsByType = getJavaMember().getAnnotationsByType(annotationType); return new LinkedHashSet<>(asList(annotationsByType)); } }
private static ColumnsList createColumnsFromFieldsEntity(Class<?> clazzEntity) { ColumnsList listaColunaLista = new ColumnsList(); for (Field field : clazzEntity.getDeclaredFields()) { if (field.getClass().isInstance(IBaseEntity.class) || field.getName().equals("versao")) { continue; } JArchColumnDataTable[] colunasDataTable = field.getAnnotationsByType(JArchColumnDataTable.class); addColumnDataTable(clazzEntity, listaColunaLista, colunasDataTable, field.getName()); } return listaColunaLista; }
public static Optional<TransformationImpl> getTransformation(Field field, StandardEvaluationContext context) { return Stream.of(field.getAnnotationsByType(Transformation.class)) .map(TransformationImpl::new) .sorted((o1, o2) -> o1.compareTo(o2)) .filter(o -> TransformerUtils.evaluateCondition(o.getCondition(), context)) .findFirst(); } }
private void createFromFields(Class<?> classActionEntity, Map<String, FieldSearch> mapFieldSearch) { for (Field field : ReflectionUtils.getArrayFields(classActionEntity, true, true)) { JArchSearchFieldLookup[] searchFieldLookups = field.getAnnotationsByType(JArchSearchFieldLookup.class); Arrays .stream(searchFieldLookups) .forEach(a -> createFieldSearch(null, classActionEntity, a, field, mapFieldSearch)); JArchSearchTab[] searchTabs = field.getAnnotationsByType(JArchSearchTab.class); for (JArchSearchTab searchTab : searchTabs) { searchFieldLookups = searchTab.searchFieldLookups(); Arrays.stream(searchFieldLookups).forEach(a -> createFieldSearch(searchTab, classActionEntity, a, field, mapFieldSearch)); } } }
private static void removeMaskFieldSearch(Object entidade, Field field) { Arrays .stream(field.getAnnotationsByType(JArchSearchField.class)) .filter(c -> haveMask(c.type())) .findAny() .ifPresent(c -> removeMasks(entidade, field)); }