Java tutorial
/* * Copyright 2011 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except * in compliance with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software distributed under the License * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express * or implied. See the License for the specific language governing permissions and limitations under * the License. */ // ////////////////////////////////////////////////////////////////////////////// // checkstyle: Checks Java source code for adherence to a set of rules. // Copyright (C) 2001-2005 Oliver Burn // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 2.1 of the License, or (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public // License along with this library; if not, write to the Free Software // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA // ////////////////////////////////////////////////////////////////////////////// package com.google.gwt.checkstyle; import com.puppycrawl.tools.checkstyle.checks.header.RegexpHeaderCheck; import com.puppycrawl.tools.checkstyle.api.DetailAST; import com.puppycrawl.tools.checkstyle.api.Utils; import org.apache.commons.beanutils.ConversionException; import java.util.Arrays; import java.util.regex.Pattern; import java.util.regex.PatternSyntaxException; /** * Custom version of {@link RegexpHeaderCheck} that has hooks for a custom log handler (see * {@link CustomLogHandler}). * <p> * This is an exact copy of {@link RegexpHeaderCheck} with three exceptions: * <ol> * <li>{@link CustomLogHandler} has been added for custom log callbacks.</li> * <li>{@link #doChecks(CustomLogHandler)} has been added for custom checks. This method is an exact * copy of {@link RegexpHeaderCheck#beginTree(DetailAST)} except all log calls have been replaced * with a call to a custom log handler.</li> * <li>{@link #beginTree(DetailAST)} has been refactored to call * {@link #doChecks(CustomLogHandler)}. * </ol> */ public class CustomRegexpHeaderCheck extends RegexpHeaderCheck { /** * Custom log handler callback. */ abstract static class CustomLogHandler { abstract void log(int aLine, String aKey); abstract void log(int aLine, String aKey, Object aObject); } // empty array to avoid instantiations. private static final int[] EMPTY_INT_ARRAY = new int[0]; // the header lines to repeat (0 or more) in the check, sorted. private int[] mMultiLines = EMPTY_INT_ARRAY; // the compiled regular expressions private Pattern[] mHeaderRegexps; /** * {@inheritDoc} */ public void beginTree(DetailAST aRootAST) { doChecks(new CustomLogHandler() { @Override void log(int aLine, String aKey) { CustomRegexpHeaderCheck.this.log(aLine, aKey); } @Override void log(int aLine, String aKey, Object aObject) { CustomRegexpHeaderCheck.this.log(aLine, aKey, aObject); } }); } /** * Check the current file using the same method as {@link RegexpHeaderCheck#beginTree(DetailAST)} * but pass all logging calls through a custom log handler (@see {@link CustomLogHandler}). * * @param logHandler the custom log handler, or <code>null</code> to suppress logging. */ public void doChecks(CustomLogHandler logHandler) { // With the exception of the logging hooks, the following is copied from // RegexpHeaderCheck.beginTree(). final int headerSize = getHeaderLines().length; final int fileSize = getLines().length; if (headerSize - mMultiLines.length > fileSize) { if (logHandler != null) { logHandler.log(1, "gwtheader.missing", null); } } else { int headerLineNo = 0; int i; for (i = 0; (headerLineNo < headerSize) && (i < fileSize); i++) { boolean isMatch = isMatch(i, headerLineNo); while (!isMatch && isMultiLine(headerLineNo)) { headerLineNo++; isMatch = (headerLineNo == headerSize) || isMatch(i, headerLineNo); } if (!isMatch) { if (logHandler != null) { logHandler.log(i + 1, "gwtheader.mismatch", getHeaderLines()[headerLineNo]); } break; // stop checking } if (!isMultiLine(headerLineNo)) { headerLineNo++; } } if (i == fileSize) { // if file finished, but we have at least one non-multi-line // header isn't completed for (; headerLineNo < headerSize; headerLineNo++) { if (!isMultiLine(headerLineNo)) { if (logHandler != null) { logHandler.log(1, "gwtheader.missing"); } break; } } } } } /** * {@inheritDoc} */ @Override public void setHeader(String aHeader) { super.setHeader(aHeader); initHeaderRegexps(); } /** * {@inheritDoc} */ @Override public void setHeaderFile(String aFileName) throws ConversionException { super.setHeaderFile(aFileName); initHeaderRegexps(); } /** * {@inheritDoc} */ @Override public void setMultiLines(int[] aList) { if ((aList == null) || (aList.length == 0)) { mMultiLines = EMPTY_INT_ARRAY; return; } mMultiLines = new int[aList.length]; System.arraycopy(aList, 0, mMultiLines, 0, aList.length); Arrays.sort(mMultiLines); } /** * Initializes {@link #mHeaderRegexps} from {@link AbstractHeaderCheck#getHeaderLines()}. */ private void initHeaderRegexps() { final String[] headerLines = getHeaderLines(); if (headerLines != null) { mHeaderRegexps = new Pattern[headerLines.length]; for (int i = 0; i < headerLines.length; i++) { try { // todo: Not sure if chache in Utils is still necessary mHeaderRegexps[i] = Utils.getPattern(headerLines[i]); } catch (final PatternSyntaxException ex) { throw new ConversionException( "line " + i + " in header specification" + " is not a regular expression"); } } } } /** * Checks if a code line matches the required header line. * * @param aLineNo the line number to check against the header * @param aHeaderLineNo the header line number. * @return true if and only if the line matches the required header line. */ private boolean isMatch(int aLineNo, int aHeaderLineNo) { final String line = getLines()[aLineNo]; return mHeaderRegexps[aHeaderLineNo].matcher(line).find(); } /** * @param aLineNo a line number * @return if <code>aLineNo</code> is one of the repeat header lines. */ private boolean isMultiLine(int aLineNo) { return (Arrays.binarySearch(mMultiLines, aLineNo + 1) >= 0); } }