Refine search
if (field.getModifiers().contains(Modifier.STATIC)) { for (VariableDeclarator variable : field.getVariables()) { String variableName = variable.getNameAsString(); field.addModifier(Modifier.VOLATILE);
.findAll(FieldDeclaration.class) .stream() .collect(Collectors.toMap(declaration -> declaration.getVariable(0).getNameAsString(), Function.identity())); String name = declaration.getVariable(0).getNameAsString(); if (oldFields.get(name) == null) { VariableDeclarator declarator = declaration.getVariable(0); FieldDeclaration newField = old.getType(0) .addField(declarator.getType(), declarator.getNameAsString(), declaration.getModifiers().toArray(new Modifier[]{})); declaration.getJavadocComment().ifPresent(newField::setJavadocComment); for (Comment comment : declaration.getAllContainedComments()) { newField.setComment(comment); for (AnnotationExpr annotationExpr : declaration.getAnnotations()) { newField.addAnnotation(annotationExpr.clone());
/** * Generates something like * <code>private static final AtomicLongFieldUpdater<MpmcAtomicArrayQueueProducerIndexField> P_INDEX_UPDATER = AtomicLongFieldUpdater.newUpdater(MpmcAtomicArrayQueueProducerIndexField.class, "producerIndex");</code> * * @param type * @param name * @param initializer * @param modifiers * @return */ private static FieldDeclaration fieldDeclarationWithInitialiser(Type type, String name, Expression initializer, Modifier... modifiers) { FieldDeclaration fieldDeclaration = new FieldDeclaration(); VariableDeclarator variable = new VariableDeclarator(type, name, initializer); fieldDeclaration.getVariables().add(variable); EnumSet<Modifier> modifierSet = EnumSet.copyOf(Arrays.asList(modifiers)); fieldDeclaration.setModifiers(modifierSet); return fieldDeclaration; }
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; } } }
@Override public boolean doIsEquals(FieldDeclaration first, FieldDeclaration second) { if(!isSmallerHasEqualsInBigger(first.getVariables(),second.getVariables(),false)) return false; return true; } }
@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; }
if (fieldDeclaration.getVariables().size() != 1) { throw new RuntimeException("Cannot resolve a Field Declaration including multiple variable declarators. Resolve the single variable declarators"); ResolvedFieldDeclaration resolved = new JavaParserFieldDeclaration(fieldDeclaration.getVariable(0), typeSolver); if (resultClass.isInstance(resolved)) { return resultClass.cast(resolved);
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 boolean isStatic() { return wrappedNode.getModifiers().contains(Modifier.STATIC); }
public void index(FieldDeclaration fieldDeclaration, int typeId) { List<VariableDeclarator> variables = fieldDeclaration.getVariables(); for (VariableDeclarator variable : variables) { String name = variable.getNameAsString(); fieldDao.save(new Field(name, fieldDeclaration.getElementType().asString(), fieldDeclaration.isPublic(), fieldDeclaration.isStatic(), fieldDeclaration.isFinal(), fieldDeclaration.isTransient(), typeId)); } }
@Override public void visit(FieldDeclaration fd, List<EntityField> f) { if (fd.getAnnotations().stream().anyMatch(anno -> anno.getName().getName().equals("Column"))) { Class<?> type = null; switch (fd.getType().toString()) { case "String": type = String.class; break; case "Long": type = Long.class; break; case "Integer": type = Integer.class; break; case "boolean": type = boolean.class; break; } if (type == null) return; f.add(new EntityField( fd.getVariables().get(0).getId().getName(), type, fd.getAnnotations().stream().anyMatch(anno -> anno.getName().getName().equals("Id")))); } } }, entityFields);
public String getKey() { if (declaration instanceof FieldDeclaration) { FieldDeclaration field = (FieldDeclaration) declaration; if (field.getVariables().size() != 1) { throw new RuntimeException( "Multiple fields in a single manual field declaration is not yet supported: " + field.toString()); } return "F:" + field.getVariable(0).getNameAsString(); } else if (declaration instanceof MethodDeclaration) { MethodDeclaration method = (MethodDeclaration) declaration; return "M:" + method.getNameAsString() + ":" + method.getParameters().stream() .map(p -> p.getType().toString()).collect(Collectors.joining(",")); } else if (declaration instanceof ConstructorDeclaration) { ConstructorDeclaration constructor = (ConstructorDeclaration) declaration; return "C:" + constructor.getParameters().stream().map(p -> p.getType().toString()) .collect(Collectors.joining(",")); } throw new RuntimeException( "Unsupported manual member type encountered: " + declaration.getClass().getName()); }
public FieldImp parse(final String signature) { final StringBuilder sb = new StringBuilder(); sb.append("class A {\n"); sb.append(signature.endsWith(";") ? signature : signature.concat(";")); sb.append("\n}"); final FieldImp field = new FieldImp("NOT_DEFINED", null); final CompilationUnit compilationUnit = JavaParser.parse(sb.toString()); compilationUnit.getClassByName("A").ifPresent(clazz -> { clazz.getFields().forEach(fd -> { field.name(fd.getVariables().get(0).toString()); field.type(this.getType(fd)); field.visibility(this.getVisibility(fd)); field.modifiers(this.getModifiers(fd)); fd.getAnnotations().forEach(an -> this.getAnnotationField(an) .ifPresent(x -> field.annotation(x))); }); }); return field; }
val variable = fieldDecl.getVariables().get(0); val name = StreamSupport.stream(RelaxedPropertyNames.forCamelCase(variable.getNameAsString()).spliterator(), false) .map(Object::toString) if (fieldDecl.getJavadoc().isPresent()) { val description = fieldDecl.getJavadoc().get().getDescription().toText(); prop.setDescription(description); prop.setShortDescription(StringUtils.substringBefore(description, ".")); prop.setId(indexedName); val elementType = fieldDecl.getElementType().asString(); if (elementType.equals(String.class.getSimpleName()) || elementType.equals(Integer.class.getSimpleName())
FieldDeclaration fdTwo = (FieldDeclaration) inner; if (isEitherContains(fdOne.getVariables(), fdTwo.getVariables()) && fdOne.getType().equals(fdTwo.getType())) { result.add(mergeField(fdOne, fdTwo)); found = true;
protected void prepareFieldComment(FieldDeclaration fieldDeclaration, TypeDocMeta typeDocMeta) { if (fieldDeclaration.getVariables().stream().anyMatch(variable -> variable.getNameAsString().equals(typeDocMeta.getName()))) { String comment = adjustComment(fieldDeclaration); if (DfStringUtil.is_NotNull_and_NotEmpty(comment)) { if (DfStringUtil.is_Null_or_Empty(typeDocMeta.getComment()) || fieldDeclaration.getParentNode().map(parentNode -> { @SuppressWarnings("unchecked") TypeDeclaration<TypeDeclaration<?>> typeDeclaration = (TypeDeclaration<TypeDeclaration<?>>) parentNode; return typeDeclaration.getNameAsString().equals(clazz.getSimpleName()); }).orElse(false)) { typeDocMeta.setComment(comment); Matcher matcher = FIELD_COMMENT_END_PATTERN.matcher(saveFieldCommentSpecialExp(comment)); if (matcher.find()) { String description = matcher.group(1).trim(); typeDocMeta.setDescription(restoreFieldCommentSpecialExp(description)); } } } } }
NodeList<Modifier> modifiersInCorrectOrder; if (field != null) { modifiersInCorrectOrder = getModifiersInCorrectOrder(field.getModifiers()); isModifierListUnchanged = field.getModifiers().equals(modifiersInCorrectOrder); field.setModifiers(new NodeList<Modifier>()); field.setModifiers(modifiersInCorrectOrder); } else if (method != null) { modifiersInCorrectOrder = getModifiersInCorrectOrder(method.getModifiers());
private boolean isNullable(FieldDeclaration field) { return field.getAnnotations().stream() .map(AnnotationExpr::getNameAsString) .anyMatch(name -> name.equals("Nullable")); }
@Override public void visit(FieldDeclaration n, Void arg) { String name = n.getVariable(0).getName().asString(); String comment = ""; if (n.getComment().isPresent()) { comment = n.getComment().get().getContent(); } if (name.contains("=")) { name = name.substring(0, name.indexOf("=")).trim(); } commentMap.put(name, CommentUtils.parseCommentText(comment)); } }.visit(cu, null);