Java CommonUtils.endsWithChar方法代码示例

import com.puppycrawl.tools.checkstyle.utils.CommonUtils; //导入方法依赖的package包/类
@Override
public void visitToken(DetailAST ast) {
    if (CommonUtils.endsWithChar(ast.getText(), 'l')) {
        log(ast.getLineNo(),
            ast.getColumnNo() + ast.getText().length() - 1,
            MSG_KEY);
    }
}
 

import com.puppycrawl.tools.checkstyle.utils.CommonUtils; //导入方法依赖的package包/类
/**
 * Sets the list of package groups and the order they should occur in the
 * file.
 *
 * @param packageGroups a comma-separated list of package names/prefixes.
 */
public void setGroups(String... packageGroups) {
    groups = new Pattern[packageGroups.length];

    for (int i = 0; i < packageGroups.length; i++) {
        String pkg = packageGroups[i];
        final Pattern grp;

        // if the pkg name is the wildcard, make it match zero chars
        // from any name, so it will always be used as last resort.
        if (WILDCARD_GROUP_NAME.equals(pkg)) {
            // matches any package
            grp = Pattern.compile("");
        }
        else if (CommonUtils.startsWithChar(pkg, '/')) {
            if (!CommonUtils.endsWithChar(pkg, '/')) {
                throw new IllegalArgumentException("Invalid group");
            }
            pkg = pkg.substring(1, pkg.length() - 1);
            grp = Pattern.compile(pkg);
        }
        else {
            final StringBuilder pkgBuilder = new StringBuilder(pkg);
            if (!CommonUtils.endsWithChar(pkg, '.')) {
                pkgBuilder.append('.');
            }
            grp = Pattern.compile("^" + Pattern.quote(pkgBuilder.toString()));
        }

        groups[i] = grp;
    }
}
 

import com.puppycrawl.tools.checkstyle.utils.CommonUtils; //导入方法依赖的package包/类
/**
 * Creates a full package name from the package names on the stack.
 * @return the full name of the current package.
 */
private String getPackageName() {
    final StringBuilder buf = new StringBuilder(256);
    final Iterator<String> iterator = packageStack.descendingIterator();
    while (iterator.hasNext()) {
        final String subPackage = iterator.next();
        buf.append(subPackage);
        if (!CommonUtils.endsWithChar(subPackage, '.') && iterator.hasNext()) {
            buf.append('.');
        }
    }
    return buf.toString();
}
 

import com.puppycrawl.tools.checkstyle.utils.CommonUtils; //导入方法依赖的package包/类
/**
 * Finds whether the given argument is character or entity reference.
 * @param ent the possible entity to look for.
 * @return whether the given argument a character or entity reference
 */
public static boolean isReference(String ent) {
    boolean reference = false;

    if (ent.charAt(0) != '&' || !CommonUtils.endsWithChar(ent, ';')) {
        reference = false;
    }
    else if (ent.charAt(1) == '#') {
        // prefix is "&#"
        int prefixLength = 2;

        int radix = BASE_10;
        if (ent.charAt(2) == 'x') {
            prefixLength++;
            radix = BASE_16;
        }
        try {
            Integer.parseInt(
                ent.substring(prefixLength, ent.length() - 1), radix);
            reference = true;
        }
        catch (final NumberFormatException ignored) {
            reference = false;
        }
    }
    else {
        final String name = ent.substring(1, ent.length() - 1);
        for (String element : ENTITIES) {
            if (name.equals(element)) {
                reference = true;
                break;
            }
        }
    }
    return reference;
}
 

import com.puppycrawl.tools.checkstyle.utils.CommonUtils; //导入方法依赖的package包/类
/**
 * Checks a set of tags for matching parameters.
 *
 * @param tags the tags to check
 * @param parent the node which takes the parameters
 * @param reportExpectedTags whether we should report if do not find
 *            expected tag
 */
private void checkParamTags(final List<JavadocTag> tags,
        final DetailAST parent, boolean reportExpectedTags) {
    final List<DetailAST> params = getParameters(parent);
    final List<DetailAST> typeParams = CheckUtils
            .getTypeParameters(parent);

    // Loop over the tags, checking to see they exist in the params.
    final ListIterator<JavadocTag> tagIt = tags.listIterator();
    while (tagIt.hasNext()) {
        final JavadocTag tag = tagIt.next();

        if (!tag.isParamTag()) {
            continue;
        }

        tagIt.remove();

        final String arg1 = tag.getFirstArg();
        boolean found = removeMatchingParam(params, arg1);

        if (CommonUtils.startsWithChar(arg1, '<') && CommonUtils.endsWithChar(arg1, '>')) {
            found = searchMatchingTypeParameter(typeParams,
                    arg1.substring(1, arg1.length() - 1));

        }

        // Handle extra JavadocTag
        if (!found) {
            log(tag.getLineNo(), tag.getColumnNo(), MSG_UNUSED_TAG,
                    "@param", arg1);
        }
    }

    // Now dump out all type parameters/parameters without tags :- unless
    // the user has chosen to suppress these problems
    if (!allowMissingParamTags && reportExpectedTags) {
        for (DetailAST param : params) {
            log(param, MSG_EXPECTED_TAG,
                JavadocTagInfo.PARAM.getText(), param.getText());
        }

        for (DetailAST typeParam : typeParams) {
            log(typeParam, MSG_EXPECTED_TAG,
                JavadocTagInfo.PARAM.getText(),
                "<" + typeParam.findFirstToken(TokenTypes.IDENT).getText()
                + ">");
        }
    }
}