private static void removeStaticFieldsAndInitialisers(ClassOrInterfaceDeclaration node) { // Remove all the static initialisers for (InitializerDeclaration child : node.getChildNodesByType(InitializerDeclaration.class)) { child.remove(); } // Remove all static fields for (FieldDeclaration field : node.getFields()) { if (field.getModifiers().contains(Modifier.STATIC)) { field.remove(); continue; } } }
private static void removeStaticFieldsAndInitialisers(ClassOrInterfaceDeclaration node) { // Remove all the static initialisers for (InitializerDeclaration child : node.getChildNodesByType(InitializerDeclaration.class)) { child.remove(); } // Remove all static fields for (FieldDeclaration field : node.getFields()) { if (field.getModifiers().contains(Modifier.STATIC)) { field.remove(); continue; } } }
FieldDeclaration newField = old.getType(0) .addField(declarator.getType(), declarator.getNameAsString(), declaration.getModifiers().toArray(new Modifier[]{}));
if (field.getModifiers().contains(Modifier.STATIC)) {
if (field.getModifiers().contains(Modifier.STATIC)) {
@Override public boolean isStatic() { return wrappedNode.getModifiers().contains(Modifier.STATIC); }
@Override public boolean isStatic() { return wrappedNode.getModifiers().contains(Modifier.STATIC); }
@Override public AccessSpecifier accessSpecifier() { return Helper.toAccessLevel(wrappedNode.getModifiers()); }
@Override public AccessSpecifier accessSpecifier() { return Helper.toAccessLevel(wrappedNode.getModifiers()); }
private ModifierEnum[] getModifiers(final FieldDeclaration fd) { return fd.getModifiers() .stream() .map(mod -> { try { return ModifierEnum.valueOf(mod.name()); } catch (final Exception e) { return null; } }) .toArray(ModifierEnum[]::new); }
@Override @SuppressWarnings("ConstantConditions") public boolean apply(@Nullable FieldDeclaration fieldDeclaration) { int modifiers = checkNotNull(fieldDeclaration).getModifiers(); return ModifierSet.isStatic(modifiers) && ModifierSet.isFinal(modifiers); } };
private boolean hasTypeFields(NodeList<BodyDeclaration<?>> members) { boolean hasType = false; boolean hasTypeId = false; for (BodyDeclaration<?> bd : members) { if (bd instanceof FieldDeclaration) { FieldDeclaration f = (FieldDeclaration)bd; EnumSet<Modifier> m = f.getModifiers(); if (m.contains(Modifier.PUBLIC) && m.contains(Modifier.STATIC) && m.contains(Modifier.FINAL) // && // getTypeName(f.getType()).equals("int") ) { List<VariableDeclarator> vds = f.getVariables(); for (VariableDeclarator vd : vds) { if (vd.getType().equals(intType)) { String n = vd.getNameAsString(); if (n.equals("type")) hasType = true; if (n.equals("typeIndexID")) hasTypeId = true; if (hasTypeId && hasType) { return true; } } } } } } // end of for return false; }
@Override public void visit(final FieldDeclaration field, final ConfigurationMetadataProperty property) { if (field.getVariables().isEmpty()) { throw new IllegalArgumentException("Field " + field + " has no variable definitions"); } val var = field.getVariable(0); if (field.getModifiers().contains(Modifier.STATIC)) { LOGGER.debug("Field [{}] is static and will be ignored for metadata generation", var.getNameAsString()); return; } if (field.getJavadoc().isEmpty()) { LOGGER.error("Field [{}] has no Javadoc defined", field); } val creator = new ConfigurationMetadataPropertyCreator(indexNameWithBrackets, properties, groups, parentClass); val prop = creator.createConfigurationProperty(field, property.getName()); processNestedClassOrInterfaceTypeIfNeeded(field, prop); }
@Override public FieldDeclaration doMerge(FieldDeclaration first, FieldDeclaration second) { FieldDeclaration fd = new FieldDeclaration(); fd.setJavaDoc(mergeSingle(first.getJavaDoc(),second.getJavaDoc())); fd.setType(mergeSingle(first.getType(),second.getType())); fd.setModifiers(mergeModifiers(first.getModifiers(),second.getModifiers())); fd.setAnnotations(mergeCollections(first.getAnnotations(),second.getAnnotations())); fd.setVariables(mergeListNoDuplicate(first.getVariables(),second.getVariables(),true)); return fd; }
NodeList<Modifier> modifiersInCorrectOrder; if (field != null) { modifiersInCorrectOrder = getModifiersInCorrectOrder(field.getModifiers()); isModifierListUnchanged = field.getModifiers().equals(modifiersInCorrectOrder); field.setModifiers(new NodeList<Modifier>()); field.setModifiers(modifiersInCorrectOrder);
public static FieldDeclaration mergeField(FieldDeclaration one, FieldDeclaration two) { if (isAllNull(one, two)) return null; FieldDeclaration fd = null; if (isAllNotNull(one, two)) { fd = new FieldDeclaration(); fd.setType(mergeSelective(one.getType(), two.getType())); fd.setComment(mergeSelective(one.getComment(), two.getComment())); fd.setAnnotations(mergeListNoDuplicate(one.getAnnotations(), two.getAnnotations())); fd.setModifiers(mergeModifiers(one.getModifiers(), two.getModifiers())); fd.setJavaDoc(mergeSelective(one.getJavaDoc(), two.getJavaDoc())); fd.setVariables(mergeListNoDuplicate(one.getVariables(), two.getVariables())); LOG.info("merge FieldDeclaration --> {}", fd.getVariables()); } else { fd = findFirstNotNull(one, two); LOG.info("add FieldDeclaration --> {}", fd.getVariables()); } return fd; }
/** {@inheritDoc} */ @Override public void visit(FieldDeclaration field, ClassBuilder builder) { super.visit(field, builder); TypeFactory factory = new TypeFactory(packageName, imports); if (!skipFieldOrGetter(field.getModifiers())) { field.getVariables().forEach(variable -> builder.withField(new Field( isNullable(field), variable.getNameAsString(), factory.build(variable.getType().asString(), variable.getType() instanceof PrimitiveType) ))); } }