Java FullIdent.getText方法代码示例

import com.puppycrawl.tools.checkstyle.api.FullIdent; //导入方法依赖的package包/类
/**
 * Processes one of the collected "new" tokens when walking tree
 * has finished.
 * @param newTokenAst the "new" token.
 */
private void postProcessLiteralNew(DetailAST newTokenAst) {
    final DetailAST typeNameAst = newTokenAst.getFirstChild();
    final AST nameSibling = typeNameAst.getNextSibling();
    if (nameSibling.getType() != TokenTypes.ARRAY_DECLARATOR) {
        // ast != "new Boolean[]"
        final FullIdent typeIdent = FullIdent.createFullIdent(typeNameAst);
        final String typeName = typeIdent.getText();
        final String fqClassName = getIllegalInstantiation(typeName);
        if (fqClassName != null) {
            final int lineNo = newTokenAst.getLineNo();
            final int colNo = newTokenAst.getColumnNo();
            log(lineNo, colNo, MSG_KEY, fqClassName);
        }
    }
}
 

import com.puppycrawl.tools.checkstyle.api.FullIdent; //导入方法依赖的package包/类
/**
 * Check import statements.
 * @param className name of the class
 * @return value of illegal instantiated type
 */
private String checkImportStatements(String className) {
    String illegalType = null;
    // import statements
    for (FullIdent importLineText : imports) {
        String importArg = importLineText.getText();
        if (importArg.endsWith(".*")) {
            importArg = importArg.substring(0, importArg.length() - 1)
                    + className;
        }
        if (CommonUtils.baseClassName(importArg).equals(className)
                && illegalClasses.contains(importArg)) {
            illegalType = importArg;
            break;
        }
    }
    return illegalType;
}
 

import com.puppycrawl.tools.checkstyle.api.FullIdent; //导入方法依赖的package包/类
/**
 * Shares processing...
 *
 * @param ident the import to process.
 * @param isStatic whether the token is static or not.
 * @param previous previous non-static but current is static (above), or
 *                  previous static but current is non-static (under).
 */
private void doVisitToken(FullIdent ident, boolean isStatic,
        boolean previous) {
    final String name = ident.getText();
    final int groupIdx = getGroupNumber(name);
    final int line = ident.getLineNo();

    if (groupIdx > lastGroup) {
        if (!beforeFirstImport && separated && line - lastImportLine < 2
            && !isInSameGroup(groupIdx, isStatic)) {
            log(line, MSG_SEPARATION, name);
        }
    }
    else if (isInSameGroup(groupIdx, isStatic)) {
        doVisitTokenInSameGroup(isStatic, previous, name, line);
    }
    else {
        log(line, MSG_ORDERING, name);
    }
    if (isSeparatorInGroup(groupIdx, isStatic, line)) {
        log(line, MSG_SEPARATED_IN_GROUP, name);
    }

    lastGroup = groupIdx;
    lastImport = name;
}
 

import com.puppycrawl.tools.checkstyle.api.FullIdent; //导入方法依赖的package包/类
@Override
public void visitToken(DetailAST aAST) {
	final FullIdent imp;
	if ( aAST.getType() == TokenTypes.IMPORT ) {
		imp = FullIdent.createFullIdentBelow( aAST );
	}
	else {
		// handle case of static imports of method names
		imp = FullIdent.createFullIdent( aAST.getFirstChild().getNextSibling() );
	}
	final String text = imp.getText();
	if ( isIllegalImport( text ) ) {
		final String message = buildError( text );
		log( aAST.getLineNo(), aAST.getColumnNo(), message, text );
	}
}
 

import com.puppycrawl.tools.checkstyle.api.FullIdent; //导入方法依赖的package包/类
/**
 * Check import statements.
 * @param className name of the class
 * @return value of illegal instantiated type
 */
private String checkImportStatements(String className) {
    String illegalType = null;
    // import statements
    for (FullIdent importLineText : imports) {
        String importArg = importLineText.getText();
        if (importArg.endsWith(".*")) {
            importArg = importArg.substring(0, importArg.length() - 1)
                    + className;
        }
        if (CommonUtils.baseClassName(importArg).equals(className)
                && classes.contains(importArg)) {
            illegalType = importArg;
            break;
        }
    }
    return illegalType;
}
 

import com.puppycrawl.tools.checkstyle.api.FullIdent; //导入方法依赖的package包/类
private void addImport(DetailAST ast) {
	DetailAST nameAST;
	FullIdent full;
	nameAST = ast.getLastChild().getPreviousSibling();
	full = FullIdent.createFullIdent(nameAST);
	String currentImport = full.getText();
	this.currentClass.addImport(currentImport, ast);
	logger.fine("import: " + currentImport);
}
 

import com.puppycrawl.tools.checkstyle.api.FullIdent; //导入方法依赖的package包/类
private void addPackagename(DetailAST ast) {
	DetailAST nameAST;
	FullIdent full;
	nameAST = ast.getLastChild().getPreviousSibling();
	full = FullIdent.createFullIdent(nameAST);
	String packageName = full.getText();
	this.currentClass.setPackageName(packageName);
	logger.fine("package name: " + packageName);
}
 

import com.puppycrawl.tools.checkstyle.api.FullIdent; //导入方法依赖的package包/类
/**
 * Registers given import. This allows us to track imported classes.
 * @param imp import definition.
 */
public void registerImport(DetailAST imp) {
    final FullIdent ident = FullIdent.createFullIdent(
        imp.getLastChild().getPreviousSibling());
    final String fullName = ident.getText();
    if (fullName.charAt(fullName.length() - 1) != '*') {
        final int lastDot = fullName.lastIndexOf(DOT);
        importedClassPackage.put(fullName.substring(lastDot + 1), fullName);
    }
}
 

import com.puppycrawl.tools.checkstyle.api.FullIdent; //导入方法依赖的package包/类
/**
 * Determines if an AST is a formal param of type Object.
 * @param paramNode the AST to check
 * @return true if firstChild is a parameter of an Object type.
 */
private static boolean isObjectParam(DetailAST paramNode) {
    final DetailAST typeNode = paramNode.findFirstToken(TokenTypes.TYPE);
    final FullIdent fullIdent = FullIdent.createFullIdentBelow(typeNode);
    final String name = fullIdent.getText();
    return "Object".equals(name) || "java.lang.Object".equals(name);
}
 

import com.puppycrawl.tools.checkstyle.api.FullIdent; //导入方法依赖的package包/类
/**
 * Perform processing for an package token.
 * @param ast the package token
 */
private void processPackageDef(DetailAST ast) {
    final DetailAST packageNameAST = ast.getLastChild()
            .getPreviousSibling();
    final FullIdent packageIdent =
            FullIdent.createFullIdent(packageNameAST);
    pkgName = packageIdent.getText();
}
 

import com.puppycrawl.tools.checkstyle.api.FullIdent; //导入方法依赖的package包/类
/**
 * Tests whether a method's first parameter is an Object.
 * @param methodDefAst the method definition AST to test.
 *     Precondition: ast is a TokenTypes.METHOD_DEF node.
 * @return true if ast has first parameter of type Object.
 */
private static boolean isFirstParameterObject(DetailAST methodDefAst) {
    final DetailAST paramsNode = methodDefAst.findFirstToken(TokenTypes.PARAMETERS);

    // parameter type "Object"?
    final DetailAST paramNode =
        paramsNode.findFirstToken(TokenTypes.PARAMETER_DEF);
    final DetailAST typeNode = paramNode.findFirstToken(TokenTypes.TYPE);
    final FullIdent fullIdent = FullIdent.createFullIdentBelow(typeNode);
    final String name = fullIdent.getText();
    return "Object".equals(name) || "java.lang.Object".equals(name);
}
 

import com.puppycrawl.tools.checkstyle.api.FullIdent; //导入方法依赖的package包/类
/**
 * Returns import text.
 * @param ast ast node that represents import
 * @return String that represents importing class
 */
private static String getImportText(DetailAST ast) {
    final FullIdent imp;
    if (ast.getType() == TokenTypes.IMPORT) {
        imp = FullIdent.createFullIdentBelow(ast);
    }
    else {
        // know it is a static import
        imp = FullIdent.createFullIdent(ast
                .getFirstChild().getNextSibling());
    }
    return imp.getText();
}
 

import com.puppycrawl.tools.checkstyle.api.FullIdent; //导入方法依赖的package包/类
/**
 * Gets the full import identifier.  If the import is a starred import and
 * it's not excluded then a violation is logged.
 * @param startingDot the starting dot for the import statement
 */
private void logsStarredImportViolation(DetailAST startingDot) {
    final FullIdent name = FullIdent.createFullIdent(startingDot);
    final String importText = name.getText();
    if (importText.endsWith(STAR_IMPORT_SUFFIX) && !excludes.contains(importText)) {
        log(startingDot.getLineNo(), MSG_KEY, importText);
    }
}
 

import com.puppycrawl.tools.checkstyle.api.FullIdent; //导入方法依赖的package包/类
/**
 * Converts FullIdent to Token.
 * @param fullIdent full ident to convert.
 */
public Token(FullIdent fullIdent) {
    text = fullIdent.getText();
    lineNo = fullIdent.getLineNo();
    columnNo = fullIdent.getColumnNo();
}
 

import com.puppycrawl.tools.checkstyle.api.FullIdent; //导入方法依赖的package包/类
public static String getTypeName(final DetailAST ast) {
    final FullIdent ident = CheckUtils.createFullType(ast.findFirstToken(TokenTypes.TYPE));
    return ident.getText();
}