StopWatchLogIterator.java

/* Copyright (c) 2008-2009 HomeAway, Inc.
 * All rights reserved.  http://www.perf4j.org
 *
 * 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.
 */
package org.perf4j.helpers;

import org.perf4j.StopWatch;

import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.Scanner;

/**
 * The StopWatchLogIterator class takes input from a Reader and parses it so that deserialized StopWatch instances can
 * be returned with each call to next(). Log messages that are not recognized as StopWatch calls are just ignored.
 *
 * @author Alex Devine
 */
public class StopWatchLogIterator implements Iterator<StopWatch> {
    /**
     * The input scanner that pulls from the input stream.
     */
    private Scanner inputScanner;
    /**
     * This StopWatchParser is used to pull out StopWatches from the input stream.
     */
    private StopWatchParser stopWatchParser;
    /**
     * State variable points to the next StopWatch to be returned.
     */
    private StopWatch nextStopWatch = null;
    /**
     * State variable keeps track of whether or not there is a next StopWatch. Null means the next state is currently
     * unknown, and the inputScanner will need to be read to determine if there is a next.
     */
    private Boolean hasNext = null;

    /**
     * Creates a new StopWatchLogIterator to parse input from the specified Readable instance.
     *
     * @param log The log containing the data to be parsed.
     */
    public StopWatchLogIterator(Readable log) {
        inputScanner = new Scanner(log);
        stopWatchParser = newStopWatchParser();
    }

    public boolean hasNext() {
        //if I don't know the state of next, pull the next log to determine the state of next
        if (hasNext == null) {
            nextStopWatch = getNext();
            hasNext = (nextStopWatch != null);
        }
        return hasNext;
    }

    public StopWatch next() {
        //if I already determined I don't have a next, throw an exception
        if (Boolean.FALSE.equals(hasNext)) {
            throw new NoSuchElementException();
        }

        //if I don't know what to return yet, find out - note this only happens if I call next() before a call
        //to hasNext().
        if (nextStopWatch == null) {
            nextStopWatch = getNext();

            //if there's still nothing I'm done
            if (nextStopWatch == null) {
                hasNext = false;
                throw new NoSuchElementException();
            }
        }

        //before I return, clear the state of the variables used to determine the next value.
        StopWatch retVal = nextStopWatch;
        hasNext = null;
        nextStopWatch = null;
        return retVal;
    }

    /**
     * Remove is not supported.
     *
     * @throws UnsupportedOperationException Always thrown.
     */
    public void remove() {
        throw new UnsupportedOperationException();
    }

    /**
     * This helper method could potentially be overridden to return a different type of StopWatchParser that is used
     * to parse the strings read by this class.
     *
     * @return A new StopWatchParser to use to parse log messages.
     */
    protected StopWatchParser newStopWatchParser() {
        return new StopWatchParser();
    }

    /**
     * Helper method uses the scanner to find the next StopWatch from the input. This method may block on input.
     *
     * @return The next parsed StopWatch from the input stream, or null if there are no more StopWatches.
     */
    private StopWatch getNext() {
        String line;
        while ((line = inputScanner.findInLine(stopWatchParser.getPattern())) == null && inputScanner.hasNextLine()) {
            inputScanner.nextLine();
        }

        return (line != null) ?
               stopWatchParser.parseStopWatchFromLogMatch(inputScanner.match()) :
               null; //there are no more lines to read if line is null
    }
}