TagClass

package org.codehaus.mojo.taglist.tags;

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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.
 */

import java.util.ArrayList;
import java.util.Iterator;
import java.util.Locale;

import org.codehaus.mojo.taglist.beans.TagReport;

/**
 * Class that define a classification of tags.
 * <p>
 * Each tag class contains 1 or more tags.  This allows a user to define
 * one tag "name" for display purposes, while still checking the files for
 * multiple tag rules.
 * <p>
 *  Example
 *  <pre>
 *   &lt;tagClass&gt;
 *    &lt;displayName&gt;Action Items&lt;/displayName&gt;
 *    &lt;tags&gt;
 *     &lt;tag&gt;
 *      &lt;matchString&gt;todo&lt;/matchString&gt;
 *      &lt;matchType&gt;ignoreCase&lt;/matchType&gt;
 *     &lt;/tag&gt;
 *    &lt;/tags&gt;
 *   &lt;/tagClass&gt;
 *  </pre>
 *
 */
public class TagClass {
    /**
     * The tag class's name.
     */
    private final String classDisplayName;

    /**
     * The tag report for this tag class.
     */
    private final TagReport classTagReport;

    /**
     * The container of tags that make up this tag class.
     */
    private final ArrayList<AbsTag> tags = new ArrayList<>();

    /**
     * The int value for no tag match found.
     */
    public static final int NO_MATCH = AbsTag.NO_MATCH;

    /**
     * The last tag to successfully match.
     */
    private AbsTag lastSuccessfulTagMatch = null;

    /**
     * A unique ID counter for the tag classes.
     */
    private static int uniqueTcCounter = 1;

    /**
     * Constructor.
     *
     * @param displayName the string to display as the name for this tag class.
     */
    public TagClass(final String displayName) {
        classDisplayName = displayName;

        // Assign a unique ID for this tag class and update the global counter.
        int uniqueId = uniqueTcCounter++;

        classTagReport = new TagReport(displayName, "tag_class_" + uniqueId);
    }

    /** Access the tag report for this tag class.
     *
     * @return the tag class's tag report.
     */
    public TagReport getTagReport() {
        return (classTagReport);
    }

    /** Add a tag to this tag class.
     *
     * @param tag the tag to add to the tag class.
     */
    public void addTag(AbsTag tag) {
        if (tag != null) {
            tags.add(tag);

            classTagReport.addTagString(tag.tagString);
        }
    }

    /** Get the index of the first tag contained from within a string.
     * <p>
     *  The tag class will check each for its tags until a match is found
     *  within the specified string.  If no match is found, this function will
     *  return TagClass.NO_MATCH for the index.
     *
     *  @param currentLine the string for the current line being scanned.
     *  @param locale the Locale of the currentLine.
     *  @return the index within the string of the matched tag, or TagClass.NO_MATCH
     *  if not match was found.
     */
    public int tagMatchContains(final String currentLine, final Locale locale) {
        int index = NO_MATCH;

        // Reset the last tag match
        lastSuccessfulTagMatch = null;

        for (AbsTag tag : tags) {
            // Check if the string contain this tag
            index = tag.contains(currentLine, locale);

            if (index != NO_MATCH) {
                // Store the last match
                lastSuccessfulTagMatch = tag;

                // Stop checking
                break;
            }
        }

        return index;
    }

    /** Check if a string starts with a tag from this tag class.
     * <p>
     *  The tag class will check each of its tags until the start of the string
     *  matched one of the tags.  If not match if found, false is returned.
     *
     *  @param currentLine the string for the current line being scanned.
     *  @param locale the Locale of the currentLine.
     *  @return true if the string starts with a tag within this tag class.
     *  Otherwise false is returned.
     */
    public boolean tagMatchStartsWith(final String currentLine, final Locale locale) {
        boolean match = false;

        Iterator<AbsTag> itr = tags.iterator();

        // Loop while there are more tags and there has not been a match.
        while (itr.hasNext() && !match) {
            AbsTag tag = itr.next();

            // Check if the string starts with this tag
            match = tag.startsWith(currentLine, locale);
        }

        return match;
    }

    /** Return the tag string for the last successfully matched tag.
     *
     * @return string of the last matched tag.
     */
    public String getLastTagMatchString() {
        if (lastSuccessfulTagMatch == null) {
            return ("");
        } else {
            return (lastSuccessfulTagMatch.tagString);
        }
    }

    /** Return the length of the last matched tag.
     * <p>
     * Normally this is the length of the tag; however, some tags
     * are dynamic.  For example a regular expression tag might be
     * 10 characters; however, the matched string may only be 5.
     * <p>
     * Calling this function allows the tag object to return the
     * correct length for the last matched tag.
     *
     * @return the length of the last matched tag.
     */
    public int getLastTagMatchStringLength() {
        if (lastSuccessfulTagMatch == null) {
            return (0);
        } else {
            return (lastSuccessfulTagMatch.getLastTagMatchLength());
        }
    }

    /** Get the display name of this tag class.
     *
     * @return the tag class display name.
     */
    public String getDisplayName() {
        return (classDisplayName);
    }
}