import com.github.javaparser.ast.Modifier; //导入依赖的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.Modifier; //导入依赖的package包/类
@Test
public void testGetClassNameFromMethod() {
    //Code from: https://github.com/javaparser/javaparser/wiki/Manual
    CompilationUnit cu = new CompilationUnit();
    // set the package
    cu.setPackageDeclaration(new PackageDeclaration(Name.parse("com.aspectsecurity.example")));

    // or a shortcut
    cu.setPackageDeclaration("com.aspectsecurity.example");

    // create the type declaration
    ClassOrInterfaceDeclaration type = cu.addClass("GeneratedClass");

    // create a method
    EnumSet<Modifier> modifiers = EnumSet.of(Modifier.PUBLIC);
    MethodDeclaration method = new MethodDeclaration(modifiers, new VoidType(), "main");
    modifiers.add(Modifier.STATIC);
    method.setModifiers(modifiers);
    type.addMember(method);

    assertEquals("GeneratedClass", saa.getClassNameFromMethod(method));
}
 

import com.github.javaparser.ast.Modifier; //导入依赖的package包/类
/***
 * @param modifiers
 * @return
 */
public static List<Modifier> castStringToModifiers(String modifiers) {
    List<Modifier> castModifiers = new ArrayList<Modifier>();

    if(modifiers.toLowerCase().contains(",")) {
        String content = modifiers.substring(modifiers.indexOf("[") + 1, modifiers.indexOf("]"));
        String[] modifierList = content.split(",");

        for(String modifier : modifierList) {
            modifier = modifier.trim();
            modifier = "[" + modifier + "]";
            castModifiers.add(getModifier(modifier));
        }
    } else {
        castModifiers.add(getModifier(modifiers));
    }

    return castModifiers;
}
 

import com.github.javaparser.ast.Modifier; //导入依赖的package包/类
/**
 * It adds all the attributes need to be added to the existing compilation unit.
 */
private void addAttributesToCompilationUnit() {
    if(attributesToBeAdded.size() > 0) {
        ClassOrInterfaceDeclaration type = getFileType();

        attributesToBeAdded.stream().forEach(attribute -> {
            EnumSet<Modifier> modifiers = null;
            for (Modifier modifier : attribute.getAccessModifiers()) {
                modifiers = EnumSet.of(modifier);
            }

            VariableDeclarator vd = new VariableDeclarator(JavaParser.parseType(attribute.getDataType()), attribute.getName());
            FieldDeclaration fd = new FieldDeclaration();
            fd.setModifiers(modifiers);
            fd.addVariable(vd);

            type.addMember(fd);
        });
    }
}
 

import com.github.javaparser.ast.Modifier; //导入依赖的package包/类
/**
 * It returns the access modifier of a given sign.
 */
public static List<Modifier> getAccessModifier(String sign) {
    List<Modifier> modifiers = new ArrayList<>();

    Modifier modifier = null;

    if(sign.equals("-")) {
        modifier = Modifier.PRIVATE;
    } else if (sign.equals("#")) {
        modifier = Modifier.PROTECTED;
    } else if (sign.equals("+")) {
        modifier = Modifier.PUBLIC;
    }

    modifiers.add(modifier);

    return modifiers;
}
 

import com.github.javaparser.ast.Modifier; //导入依赖的package包/类
/**
 * It adds all the attributes need to be added to the existing compilation unit.
 */
private void addAttributesToCompilationUnit() {
    if(attributesToBeAdded.size() > 0) {
        ClassOrInterfaceDeclaration type = getFileType();

        attributesToBeAdded.stream().forEach(attribute -> {
            EnumSet<Modifier> modifiers = null;
            for (Modifier modifier : attribute.getAccessModifiers()) {
                modifiers = EnumSet.of(modifier);
            }

            VariableDeclarator vd = new VariableDeclarator(JavaParser.parseType(attribute.getDataType()), attribute.getName());
            FieldDeclaration fd = new FieldDeclaration();
            fd.setModifiers(modifiers);
            fd.addVariable(vd);

            type.addMember(fd);
            ((ClassStructure)existingAbstractStructure).addAttribute(attribute);
        });
    }
}
 

import com.github.javaparser.ast.Modifier; //导入依赖的package包/类
private void getParameterNames(MethodDeclaration methodDeclaration, boolean isInterface) {
  final EnumSet<Modifier> modifiers = methodDeclaration.getModifiers();
  if (isInterface || modifiers.contains(Modifier.PUBLIC)) {
    String methodName = methodDeclaration.getName().getIdentifier();
    List<Parameter> parameters = methodDeclaration.getParameters();
    names.className = this.className;
    List<List<ParameterName>> parameterNames =
        names.names.computeIfAbsent(methodName, k -> new ArrayList<>(4));

    final List<ParameterName> temp = new ArrayList<>();
    for (final Parameter parameter : parameters) {
      ParameterName parameterName = new ParameterName();
      String type = parameter.getType().toString();
      String name = parameter.getName().getIdentifier();
      if (name.contains("[]")) {
        type = type + "[]";
        name = name.replace("[]", "");
      }
      parameterName.type = type;
      parameterName.name = name;
      temp.add(parameterName);
    }
    parameterNames.add(temp);
  }
}
 

import com.github.javaparser.ast.Modifier; //导入依赖的package包/类
public MethodDeclaration(final EnumSet<Modifier> modifiers, 
                         final List<AnnotationExpr> annotations,
                         final List<TypeParameter> typeParameters, 
                         final Type elementType,
                         final List<ArrayBracketPair> arrayBracketPairsAfterElementType,
                         final String name,
                         final List<Parameter> parameters, 
                         final List<ArrayBracketPair> arrayBracketPairsAfterParameterList,
                         final List<ReferenceType> throws_, 
                         final BlockStmt body) {
    super(annotations);
    setModifiers(modifiers);
    setTypeParameters(typeParameters);
    setElementType(elementType);
    setName(name);
    setParameters(parameters);
    setArrayBracketPairsAfterElementType(arrayBracketPairsAfterElementType);
    setArrayBracketPairsAfterParameterList(arrayBracketPairsAfterParameterList);
    setThrows(throws_);
    setBody(body);
}
 

import com.github.javaparser.ast.Modifier; //导入依赖的package包/类
public static CodeStubBuilder fromCode(String code) {
  CompilationUnit cu = JavaParser.parse(code);

  for (TypeDeclaration<?> type : cu.getTypes()) {

    if (type instanceof ClassOrInterfaceDeclaration
            && type.getModifiers().contains(Modifier.PUBLIC)) {

      String className = type.getNameAsString();
      return new CodeStubBuilder(className);
    }
  }

  throw new IllegalArgumentException("Task instance's code did not contain any public class");
}
 

import com.github.javaparser.ast.Modifier; //导入依赖的package包/类
/**
 * @param accessModifiers
 * @param returnType
 * @param name
 * @param parameters
 */
public MethodStructure(List<Modifier> accessModifiers, String returnType, String name, List<ParameterStructure> parameters) {
    this.accessModifiers = accessModifiers;
    this.returnType = returnType;
    this.name = name;
    this.parameters = parameters;
}
 

import com.github.javaparser.ast.Modifier; //导入依赖的package包/类
/**
 * It returns the sign of a given access modifier
 */
private String getSignOfAccessModifier(List<Modifier> modifiers) {
    String sign = "";
    Modifier modifier = modifiers.get(0);

    if(modifier.equals(Modifier.PRIVATE)) {
        sign = "-";
    } else if (modifier.equals(Modifier.PROTECTED)) {
        sign = "#";
    } else if (modifier.equals(Modifier.PUBLIC)) {
        sign = "+";
    }

    return sign;
}
 

import com.github.javaparser.ast.Modifier; //导入依赖的package包/类
/***
 * This methods return the equivalent access modifier in Modifier Class Type
 * @param modifier
 * @return the given modifier in Modifier.Class format
 */
public static Modifier getModifier(String modifier) {
    Modifier originalModifier = null;

    switch (modifier) {
        case "[PUBLIC]":
            originalModifier = Modifier.PUBLIC;
            break;
        case "[PRIVATE]":
            originalModifier = Modifier.PRIVATE;
            break;
        case "[PROTECTED]":
            originalModifier = Modifier.PROTECTED;
            break;
        case "[ABSTRACT]":
            originalModifier = Modifier.ABSTRACT;
            break;
        case "[STATIC]":
            originalModifier = Modifier.STATIC;
            break;
        case "[FINAL]":
            originalModifier = Modifier.FINAL;
            break;
        case "[SYNCHRONIZED]":
            originalModifier = Modifier.SYNCHRONIZED;
            break;
        case "[]":
            originalModifier = Modifier.PUBLIC;
            break;
        default:
            System.out.println("***** SOMETHING GOES WRONG!" + modifier);
            break;
    }

    return originalModifier;
}
 

import com.github.javaparser.ast.Modifier; //导入依赖的package包/类
/**
 * It adds all the methods need to be added to the existing compilation unit.
 */
private void addMethodsToCompilationUnit() {
    if(methodsToBeAdded.size() > 0) {
        ClassOrInterfaceDeclaration type = getFileType();

        methodsToBeAdded.stream().forEach(method -> {
            EnumSet<Modifier> modifiers = null;
            for (Modifier modifier : method.getAccessModifiers()) {
                modifiers = EnumSet.of(modifier);
            }

            MethodDeclaration md = new MethodDeclaration();
            md.setName(method.getName());
            md.setModifiers(modifiers);

            if (method.getReturnType().equals("void")) {
                md.setType(new VoidType());
            } else {
                md.setType(JavaParser.parseType(method.getReturnType()));
            }

            if (method.getParameters().size() > 0) {
                method.getParameters().stream().forEach(p -> {
                    Parameter param = new Parameter(JavaParser.parseType(p.getDataType()), p.getName());
                    md.addParameter(param);
                });
            }

            type.addMember(md);
        });
    }
}
 

import com.github.javaparser.ast.Modifier; //导入依赖的package包/类
/**
 * It adds all the methods need to be added to the existing compilation unit.
 */
private void addMethodsToCompilationUnit() {
    if(methodsToBeAdded.size() > 0) {
        ClassOrInterfaceDeclaration type = getFileType();

        methodsToBeAdded.stream().forEach(method -> {
            EnumSet<Modifier> modifiers = null;
            for (Modifier modifier : method.getAccessModifiers()) {
                modifiers = EnumSet.of(modifier);
            }

            MethodDeclaration md = new MethodDeclaration();
            md.setName(method.getName());
            md.setModifiers(modifiers);

            if (method.getReturnType().equals("void")) {
                md.setType(new VoidType());
            } else {
                md.setType(JavaParser.parseType(method.getReturnType()));
            }

            if (method.getParameters().size() > 0) {
                method.getParameters().stream().forEach(p -> {
                    Parameter param = new Parameter(JavaParser.parseType(p.getDataType()), p.getName());
                    md.addParameter(param);
                });
            }

            type.addMember(md);
            ((ClassStructure)existingAbstractStructure).addMethod(method);
        });
    }
}
 

import com.github.javaparser.ast.Modifier; //导入依赖的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.Modifier; //导入依赖的package包/类
public void index(TypeDeclaration<?> type, int cuId) {
    EnumSet<Modifier> modifiers = type.getModifiers();
    boolean isInterface = type instanceof ClassOrInterfaceDeclaration && ((ClassOrInterfaceDeclaration) type).isInterface();
    boolean isAnnotation = type instanceof AnnotationDeclaration;
    boolean isEnumeration = type instanceof EnumDeclaration;
    boolean isClass = !isAnnotation && !isEnumeration && !isInterface;
    
    Type t = new Type(type.getNameAsString(), type.isPublic(), type.isStatic(), modifiers.contains(FINAL), modifiers.contains(ABSTRACT), isClass, isInterface, isEnumeration, isAnnotation, cuId);
    int typeId = typeDao.save(t);

    for (BodyDeclaration member : type.getMembers()) {
        bodyDeclarationIndexer.index(member, typeId);
    }
}
 

import com.github.javaparser.ast.Modifier; //导入依赖的package包/类
private void handleFieldDeclaration(FieldDeclaration d) {
	List<ColumnWrapper> list = new ArrayList<>();
	for(VariableDeclarator vd : d.getVariables()) {
		String fieldName = vd.getName().asString();
		String fieldPrefix = m_generator.getFieldPrefix();
		if(null != fieldPrefix) {
			if(fieldName.startsWith(fieldPrefix)) {
				fieldName = fieldName.substring(fieldPrefix.length());
			}
		}

		if(d.getModifiers().contains(Modifier.STATIC) || d.getModifiers().contains(Modifier.FINAL)) {
			//- Skip
		} else {
			if("opentopublic".equals(fieldName)) {
				System.out.println("GOTCHA");
			}
			ColumnWrapper cw = findColumnByPropertyName(fieldName);
			if(null == cw) {
				cw = new ColumnWrapper(this);
				m_allColumnWrappers.add(cw);
				cw.setPropertyName(fieldName);
			}
			cw.setFieldDeclarator(d, vd);
			list.add(cw);
			cw.setPropertyType(vd.getType());
		}
	}

	for(AnnotationExpr annotationExpr : d.getAnnotations()) {
		for(ColumnWrapper columnWrapper : list) {
			handleDatabaseAnnotation(columnWrapper, annotationExpr);
		}
	}
}
 

import com.github.javaparser.ast.Modifier; //导入依赖的package包/类
private void regenerateEquals() {
	importIf("java.util.Objects");
	EnumSet<Modifier> modifiers = EnumSet.of(Modifier.PUBLIC);
	MethodDeclaration eq = new MethodDeclaration(modifiers, new PrimitiveType(Primitive.BOOLEAN), "equals");
	eq.setModifiers(modifiers);
	createOrFindMarkerAnnotation(eq, "java.lang.Override");

	Parameter param = new Parameter(new ClassOrInterfaceType("Object"), "o");
	eq.addParameter(param);

	ClassOrInterfaceDeclaration rootType = getRootType();
	rootType.addMember(eq);

	BlockStmt block = new BlockStmt();
	block.addStatement(JavaParser.parseStatement("if(o == this)\nreturn true;"));
	block.addStatement(JavaParser.parseStatement("if(o == null || getClass() != o.getClass())\n\t\t\treturn false;"));
	block.addStatement(JavaParser.parseStatement(getSimpleName() + " that = (" + getSimpleName() + ") o;"));

	StringBuilder sb = new StringBuilder();
	sb.append("return ");
	int count = 0;
	for(ColumnWrapper cw : m_allColumnWrappers) {
		String propName = cw.getPropertyName();
		String fieldPrefix = g().getFieldPrefix();
		if(fieldPrefix != null) {
			propName = fieldPrefix + propName;
		}

		sb.append("\t");
		if(count++ > 0)
			sb.append("&& ");
		sb.append("Objects.equals(").append(propName).append(", that.").append(propName).append(")");
		sb.append("\n");
	}
	sb.append(";");
	System.out.println(sb.toString());
	block.addStatement(JavaParser.parseStatement(sb.toString()));
	eq.setBody(block);
}
 

import com.github.javaparser.ast.Modifier; //导入依赖的package包/类
private void regenerateHashcode() {
	importIf("java.util.Objects");
	EnumSet<Modifier> modifiers = EnumSet.of(Modifier.PUBLIC);
	MethodDeclaration eq = new MethodDeclaration(modifiers, new PrimitiveType(Primitive.INT), "hashCode");
	eq.setModifiers(modifiers);
	createOrFindMarkerAnnotation(eq, "java.lang.Override");

	ClassOrInterfaceDeclaration rootType = getRootType();
	rootType.addMember(eq);

	BlockStmt block = new BlockStmt();
	eq.setBody(block);

	StringBuilder sb = new StringBuilder();
	sb.append("return Objects.hash(");
	int count = 0;
	for(ColumnWrapper cw : m_allColumnWrappers) {
		String propName = cw.getPropertyName();
		String fieldPrefix = g().getFieldPrefix();
		if(fieldPrefix != null) {
			propName = fieldPrefix + propName;
		}
		if(count++ > 0)
			sb.append(", ");
		sb.append(propName);
	}
	sb.append(");");
	block.addStatement(JavaParser.parseStatement(sb.toString()));
}
 

import com.github.javaparser.ast.Modifier; //导入依赖的package包/类
private List<String> resolveJavaParserModifiers(EnumSet<Modifier> modifiers) {
    final List<String> modifierList = new ArrayList<String>();
    for (Modifier modifier : modifiers) {
        modifierList.add(modifier.toString().toLowerCase().trim());
    }
    return modifierList;
}