import com.github.javaparser.ast.body.BodyDeclaration; //导入依赖的package包/类
@Override
public Node visit(ClassOrInterfaceDeclaration _n, Object _arg) {
	List<AnnotationExpr> annotations = visit(_n.getAnnotations(), _arg);
	List<TypeParameter> typeParameters = visit(_n.getTypeParameters(), _arg);
	List<ClassOrInterfaceType> extendsList = visit(_n.getExtends(), _arg);
	List<ClassOrInterfaceType> implementsList = visit(_n.getImplements(), _arg);
       List<BodyDeclaration<?>> members = visit(_n.getMembers(), _arg);
	Comment comment = cloneNodes(_n.getComment(), _arg);

	ClassOrInterfaceDeclaration r = new ClassOrInterfaceDeclaration(
			_n.getRange(),
			_n.getModifiers(), annotations, _n.isInterface(), _n.getName(), typeParameters, extendsList, implementsList, members
	);
	r.setComment(comment);
	return r;
}
 

import com.github.javaparser.ast.body.BodyDeclaration; //导入依赖的package包/类
private static void addResourceType(List<String> supportedTypes, TypeSpec.Builder result,
    TypeDeclaration node) {
  if (!supportedTypes.contains(node.getName())) {
    return;
  }

  String type = node.getName();
  TypeSpec.Builder resourceType = TypeSpec.classBuilder(type).addModifiers(PUBLIC, STATIC, FINAL);

  for (BodyDeclaration field : node.getMembers()) {
    if (field instanceof FieldDeclaration) {
      addResourceField(resourceType, ((FieldDeclaration) field).getVariables().get(0),
          getSupportAnnotationClass(type));
    }
  }

  result.addType(resourceType.build());
}
 

import com.github.javaparser.ast.body.BodyDeclaration; //导入依赖的package包/类
private void printMembers(final NodeList<BodyDeclaration<?>> members, final Void arg) {
	BodyDeclaration<?> prev = null;

	members.sort((a, b) -> {
		if (a instanceof FieldDeclaration && b instanceof CallableDeclaration) {
			return 1;
		} else if (b instanceof FieldDeclaration && a instanceof CallableDeclaration) {
			return -1;
		} else if (a instanceof MethodDeclaration && !((MethodDeclaration) a).getModifiers().contains(Modifier.STATIC) && b instanceof ConstructorDeclaration) {
			return 1;
		} else if (b instanceof MethodDeclaration && !((MethodDeclaration) b).getModifiers().contains(Modifier.STATIC) && a instanceof ConstructorDeclaration) {
			return -1;
		} else {
			return 0;
		}
	});

	for (final BodyDeclaration<?> member : members) {
		if (prev != null && (!prev.isFieldDeclaration() || !member.isFieldDeclaration())) printer.println();
		member.accept(this, arg);
		printer.println();

		prev = member;
	}
}
 

import com.github.javaparser.ast.body.BodyDeclaration; //导入依赖的package包/类
protected NormalAnnotationExpr createOrFindAnnotation(BodyDeclaration<?> getter, String fullAnnotationName) {
	String name = AbstractGenerator.finalName(fullAnnotationName);
	//importIf(fullAnnotationName);

	for(AnnotationExpr annotationExpr : getter.getAnnotations()) {
		String annName = annotationExpr.getName().asString();
		if(annName.equals(fullAnnotationName) || name.equals(annName)) {
			return (NormalAnnotationExpr) annotationExpr;
		}
	}

	importIf(fullAnnotationName);
	String pkg = AbstractGenerator.packageName(fullAnnotationName);
	NodeList<MemberValuePair> nodes = NodeList.nodeList();
	//Name nm = new Name(new Name(pkg), name);
	NormalAnnotationExpr ax = new NormalAnnotationExpr(new Name(name), nodes);
	getter.addAnnotation(ax);
	return ax;
}
 

import com.github.javaparser.ast.body.BodyDeclaration; //导入依赖的package包/类
protected MarkerAnnotationExpr createOrFindMarkerAnnotation(BodyDeclaration<?> getter, String fullAnnotationName) {
	String name = AbstractGenerator.finalName(fullAnnotationName);
	importIf(fullAnnotationName);
	//getUnit().addImport(fullAnnotationName);

	for(AnnotationExpr annotationExpr : getter.getAnnotations()) {
		String annName = annotationExpr.getName().asString();
		if(annName.equals(fullAnnotationName) || name.equals(annName)) {
			return (MarkerAnnotationExpr) annotationExpr;
		}
	}

	String pkg = AbstractGenerator.packageName(fullAnnotationName);
	NodeList<MemberValuePair> nodes = NodeList.nodeList();
	//Name nm = new Name(new Name(pkg), name);
	MarkerAnnotationExpr ax = new MarkerAnnotationExpr(new Name(name));
	getter.addAnnotation(ax);
	return ax;
}
 

import com.github.javaparser.ast.body.BodyDeclaration; //导入依赖的package包/类
@Override
public void visit(ClassOrInterfaceDeclaration clazz, Object arg) {
    for (BodyDeclaration member : clazz.getMembers()) {
        if (member instanceof ClassOrInterfaceDeclaration)
            visit((ClassOrInterfaceDeclaration)member, arg);
        else if (member instanceof FieldDeclaration) {
            FieldDeclaration field = (FieldDeclaration)member;
            String type = null != field.getType() ? field.getType().toString() : "";
            if (type.equals("int")) {
                VariableDeclarator variable = field.getVariables().stream().findFirst().get();
                String name = variable.getId().toString();
                Integer value = null != variable.getInit() ? Integer.parseInt(variable.getInit().toString()) : 0;
                // decimal value of 0x7f000000, which is what AAPT starts numbering at - http://stackoverflow.com/a/6646113/311304
                if (value >= 2130706432) {
                    name = "R." + ((ClassOrInterfaceDeclaration)field.getParentNode()).getName() + "." + name;
                    transform.put(value, name);
                }
            }
        }
    }
}
 

import com.github.javaparser.ast.body.BodyDeclaration; //导入依赖的package包/类
/**
 *
 * @param is
 *      a github javaparser IfStatement
 * @param attributes
 *      the list of attributes of the class,
 *      to potentially get a type from the name
 * @param bd
 *      a body declaration
 * @return
 *      an IfStatement structure
 */
private IfStatement parseIfStatement(IfStmt is, List<Attribute> attributes, BodyDeclaration bd) {
    IfStatement ifSt = new IfStatement();
    List<Stmt> body = new ArrayList<>();
    ifSt.setCondition(parseExpression(is.getCondition(), attributes, bd.getBeginLine()));
    body.addAll(parseStatement(is.getThenStmt(), attributes, bd));
    if (is.getElseStmt() != null) {
        List<Stmt> elsStmts = new ArrayList<>();
        elsStmts.addAll(parseStatement(is.getElseStmt(), attributes, bd));
        ifSt.setElseStmt(elsStmts);
    }
    ifSt.setBody(body);
    ifSt.setLine(is.getBeginLine() - bd.getBeginLine());

    return ifSt;
}
 

import com.github.javaparser.ast.body.BodyDeclaration; //导入依赖的package包/类
private void extractInformation(String filename) throws ClassParserException {
	List<TypeDeclaration> types = cu.getTypes();
	for (TypeDeclaration type : types) {
		if (type instanceof ClassOrInterfaceDeclaration) {
			clazz = (ClassOrInterfaceDeclaration) type;
		}
		List<BodyDeclaration> members = type.getMembers();
		for (BodyDeclaration member : members) {
			if (member instanceof FieldDeclaration) {
				fields.add((FieldDeclaration) member);
			}
			else if (member instanceof ConstructorDeclaration) {
				constructors.add((ConstructorDeclaration) member);
			}
			else if (member instanceof MethodDeclaration) {
				methods.add((MethodDeclaration) member);
			}
		}
	}
	if (clazz == null) {
		throw new ClassParserException("No toplevel type declaration found in " + filename + ".");
	}
}
 

import com.github.javaparser.ast.body.BodyDeclaration; //导入依赖的package包/类
@Override
public Node visit(ClassOrInterfaceDeclaration _n, Object _arg) {
	JavadocComment javaDoc = cloneNodes(_n.getJavaDoc(), _arg);
	List<AnnotationExpr> annotations = visit(_n.getAnnotations(), _arg);
	List<TypeParameter> typeParameters = visit(_n.getTypeParameters(), _arg);
	List<ClassOrInterfaceType> extendsList = visit(_n.getExtends(), _arg);
	List<ClassOrInterfaceType> implementsList = visit(_n.getImplements(), _arg);
	List<BodyDeclaration> members = visit(_n.getMembers(), _arg);
	Comment comment = cloneNodes(_n.getComment(), _arg);

	ClassOrInterfaceDeclaration r = new ClassOrInterfaceDeclaration(
			_n.getBeginLine(), _n.getBeginColumn(), _n.getEndLine(), _n.getEndColumn(),
			_n.getModifiers(), annotations, _n.isInterface(), _n.getName(), typeParameters, extendsList, implementsList, members
	);
	r.setComment(comment);
	return r;
}
 

import com.github.javaparser.ast.body.BodyDeclaration; //导入依赖的package包/类
@Override public void visit(final AnnotationDeclaration n, final A arg) {
	visitComment(n.getComment(), arg);
	if (n.getJavaDoc() != null) {
		n.getJavaDoc().accept(this, arg);
	}
	if (n.getAnnotations() != null) {
		for (final AnnotationExpr a : n.getAnnotations()) {
			a.accept(this, arg);
		}
	}
	if (n.getMembers() != null) {
		for (final BodyDeclaration member : n.getMembers()) {
			member.accept(this, arg);
		}
	}
}
 

import com.github.javaparser.ast.body.BodyDeclaration; //导入依赖的package包/类
@Override public void visit(final AnnotationDeclaration n, final A arg) {
    jw.write(n); 
    visitComment(n.getComment(), arg);
    if (n.getJavaDoc() != null) {
        n.getJavaDoc().accept(this, arg);
    }
    if (n.getAnnotations() != null) {
        for (final AnnotationExpr a : n.getAnnotations()) {
            a.accept(this, arg);
        }
    }
    if (n.getMembers() != null) {
        for (final BodyDeclaration member : n.getMembers()) {
            member.accept(this, arg);
        }
    }
}
 

import com.github.javaparser.ast.body.BodyDeclaration; //导入依赖的package包/类
@Override public Node visit(final AnnotationDeclaration n, final A arg) {
	if (n.getJavaDoc() != null) {
		n.setJavaDoc((JavadocComment) n.getJavaDoc().accept(this, arg));
	}
	final List<AnnotationExpr> annotations = n.getAnnotations();
	if (annotations != null) {
		for (int i = 0; i < annotations.size(); i++) {
			annotations.set(i, (AnnotationExpr) annotations.get(i).accept(this, arg));
		}
		removeNulls(annotations);
	}
	final List<BodyDeclaration> members = n.getMembers();
	if (members != null) {
		for (int i = 0; i < members.size(); i++) {
			members.set(i, (BodyDeclaration) members.get(i).accept(this, arg));
		}
		removeNulls(members);
	}
	return n;
}
 

import com.github.javaparser.ast.body.BodyDeclaration; //导入依赖的package包/类
public static MethodDeclaration getMethodByPositionAndClassPosition(CompilationUnit compilationUnit,
                                                                     int methodPosition, int classPosition) {
    TypeDeclaration type = compilationUnit.getTypes().get(classPosition -1);

    int memberCount = 0;
    int methodCount = 0;
    for(BodyDeclaration bodyDeclaration : type.getMembers()) {
        if(bodyDeclaration instanceof MethodDeclaration){
            if(methodCount == methodPosition -1) {
                return (MethodDeclaration) type.getMembers().get(memberCount);
            }
            methodCount++;
        }
        memberCount++;
    }
    throw new IllegalArgumentException("Method not found at position " +methodPosition+ "in class " + classPosition);
}
 

import com.github.javaparser.ast.body.BodyDeclaration; //导入依赖的package包/类
@Override public void visit(final EnumDeclaration n, final A arg) {
	visitComment(n.getComment(), arg);
	visitAnnotations(n, arg);
	n.getNameExpr().accept(this, arg);
	if (n.getImplements() != null) {
		for (final ClassOrInterfaceType c : n.getImplements()) {
			c.accept(this, arg);
		}
	}
	if (n.getEntries() != null) {
		for (final EnumConstantDeclaration e : n.getEntries()) {
			e.accept(this, arg);
		}
	}
	if (n.getMembers() != null) {
           for (final BodyDeclaration<?> member : n.getMembers()) {
			member.accept(this, arg);
		}
	}
}
 

import com.github.javaparser.ast.body.BodyDeclaration; //导入依赖的package包/类
@Override public Node visit(final EnumConstantDeclaration n, final A arg) {
	visitComment(n, arg);
	final List<AnnotationExpr> annotations = n.getAnnotations();
	if (annotations != null) {
		for (int i = 0; i < annotations.size(); i++) {
			annotations.set(i, (AnnotationExpr) annotations.get(i).accept(this, arg));
		}
		removeNulls(annotations);
	}
	final List<Expression> args = n.getArgs();
	if (args != null) {
		for (int i = 0; i < args.size(); i++) {
			args.set(i, (Expression) args.get(i).accept(this, arg));
		}
		removeNulls(args);
	}
       final List<BodyDeclaration<?>> classBody = n.getClassBody();
	if (classBody != null) {
		for (int i = 0; i < classBody.size(); i++) {
               classBody.set(i, (BodyDeclaration<?>) classBody.get(i).accept(this, arg));
		}
		removeNulls(classBody);
	}
	return n;
}
 

import com.github.javaparser.ast.body.BodyDeclaration; //导入依赖的package包/类
@Override
public List<FieldDeclaration> getAllFields() {
    ArrayList<FieldDeclaration> fields = new ArrayList<>();
    for (BodyDeclaration member : wrappedNode.getMembers()) {
        if (member instanceof com.github.javaparser.ast.body.FieldDeclaration) {
            com.github.javaparser.ast.body.FieldDeclaration field = (com.github.javaparser.ast.body.FieldDeclaration) member;
            for (VariableDeclarator vd : field.getVariables()) {
                fields.add(new JavaParserFieldDeclaration(vd, typeSolver));
            }
        }
    }

    getAncestors().forEach(a -> {
        if (a.getTypeDeclaration() != this) {
            fields.addAll(a.getTypeDeclaration().getAllFields());
        }
    });

    return fields;
}
 

import com.github.javaparser.ast.body.BodyDeclaration; //导入依赖的package包/类
@Override
public void visit(ClassOrInterfaceDeclaration n, Object arg) {
  super.visit(n, arg);
  final EnumSet<Modifier> modifiers = n.getModifiers();
  if (!modifiers.contains(Modifier.PRIVATE)) {
    final List<BodyDeclaration<?>> members = n.getMembers();
    final SimpleName simpleName = n.getName();
    final String clazz = simpleName.getId();
    // String clazz = n.getName();
    this.className = this.pkg + '.' + clazz;
    log.debug("class {}", this.className);
    int i = 0;
    for (final BodyDeclaration<?> body : members) {
      if (body instanceof MethodDeclaration) {
        MethodDeclaration methodDeclaration = (MethodDeclaration) body;
        this.getParameterNames(methodDeclaration, n.isInterface());
        i++;
      } else if (body instanceof ConstructorDeclaration) {
        // Constructor
      } else if (body instanceof ClassOrInterfaceDeclaration) {
        final ClassOrInterfaceDeclaration classOrInterfaceDeclaration =
            (ClassOrInterfaceDeclaration) body;
        String name = classOrInterfaceDeclaration.getName().getIdentifier();
        String key = this.pkg + '.' + name;
        name = this.originClassName + '.' + name;
        for (MethodParameterNames mpn : this.parameterNamesList) {
          if (mpn != null && mpn.className != null && mpn.className.equals(key)) {
            mpn.className = name;
          }
        }
      }
    }

    if (i > 0 && this.names.className != null) {
      this.parameterNamesList.add(this.names);
      this.names = new MethodParameterNames();
    }
  }
}
 

import com.github.javaparser.ast.body.BodyDeclaration; //导入依赖的package包/类
private static void changeMethods(CompilationUnit cu) {
    List<TypeDeclaration> types = cu.getTypes();
    for (TypeDeclaration type : types) {
        List<BodyDeclaration> members = type.getMembers();
        for (BodyDeclaration member : members) {
            if (member instanceof MethodDeclaration) {
                MethodDeclaration method = (MethodDeclaration) member;
                changeMethod(method);
            }
        }
    }
}
 

import com.github.javaparser.ast.body.BodyDeclaration; //导入依赖的package包/类
public void removePropertyNameConstants() {
	for(BodyDeclaration<?> d : new ArrayList<>(m_rootType.getMembers())) {
		if(d instanceof FieldDeclaration) {
			removePropertyNameConstant((FieldDeclaration) d);
		}
	}
}
 

import com.github.javaparser.ast.body.BodyDeclaration; //导入依赖的package包/类
/**
 * Scan the class and try to find its mapped table or other related data.
 */
public void scanAndRegister() {
	TypeDeclaration<?> rootType = m_rootType;
	if(null == rootType)
		return;

	//-- We need to find the annotations that map the table.
	for(AnnotationExpr annotationExpr : rootType.getAnnotations()) {
		String name = annotationExpr.getName().asString();
		if("Table".equals(name)) {
			//m_type = ClassWrapperType.tableClass;
			handleTableAnnotation(annotationExpr);
		} else if("MappedSuperclass".equals(name)) {
			m_type = ClassWrapperType.baseClass;
		} else if("Embeddable".equals(name)) {
			m_type = ClassWrapperType.embeddableClass;
		}
	}

	//-- Find everything that seems to belong to some column in the database
	for(BodyDeclaration<?> d : m_rootType.getMembers()) {
		if(d instanceof FieldDeclaration) {
			handleFieldDeclaration((FieldDeclaration) d);
		} else if(d instanceof MethodDeclaration) {
			MethodDeclaration md = (MethodDeclaration) d;
			handleMethodDeclaration(md);
		}
	}
}