dart/editor/tools/plugins/com.google.dart.engine/src/com/google/dart/engine/internal/index/operation/OperationQueue.java

/*
 * Copyright (c) 2013, the Dart project authors.
 * 
 * Licensed under the Eclipse Public License v1.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.eclipse.org/legal/epl-v10.html
 * 
 * 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 com.google.dart.engine.internal.index.operation;

import com.google.common.collect.Lists;
import com.google.dart.engine.source.Source;
import com.google.dart.engine.utilities.translation.DartOmit;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

/**
 * Instances of the {@link OperationQueue} represent a queue of operations against the index that
 * are waiting to be performed.
 * 
 * @coverage dart.engine.index
 */
@DartOmit
public class OperationQueue {
  /**
   * The non-query operations that are waiting to be performed.
   */
  private final LinkedList<IndexOperation> nonQueryOperations = Lists.newLinkedList();

  /**
   * The query operations that are waiting to be performed.
   */
  private final LinkedList<IndexOperation> queryOperations = Lists.newLinkedList();

  /**
   * {@code true} if query operations should be returned by {@link #dequeue(long)} or {code false}
   * if not.
   */
  private boolean processQueries = true;

  /**
   * Initialize a newly created operation queue to be empty.
   */
  public OperationQueue() {
    super();
  }

  /**
   * If this queue is not empty, then remove the next operation from the head of this queue and
   * return it. If this queue is empty (see {@link #setProcessQueries(boolean)}, then the behavior
   * of this method depends on the value of the argument. If the argument is less than or equal to
   * zero (<code>0</code>), then {@code null} will be returned immediately. If the argument is
   * greater than zero, then this method will wait until at least one operation has been added to
   * this queue or until the given amount of time has passed. If, at the end of that time, this
   * queue is empty, then {@code null} will be returned. If this queue is not empty, then the first
   * operation will be removed and returned.
   * <p>
   * Note that {@code null} can be returned, even if a positive timeout is given.
   * <p>
   * Note too that this method's timeout is not treated the same way as the timeout value used for
   * {@link Object#wait(long)}. In particular, it is not possible to cause this method to wait for
   * an indefinite period of time.
   * 
   * @param timeout the maximum number of milliseconds to wait for an operation to be available
   *          before giving up and returning {@code null}
   * @return the operation that was removed from the queue
   * @throws InterruptedException if the thread on which this method is running was interrupted
   *           while it was waiting for an operation to be added to the queue
   */
  public IndexOperation dequeue(long timeout) throws InterruptedException {
    synchronized (nonQueryOperations) {
      if (nonQueryOperations.isEmpty() && (!processQueries || queryOperations.isEmpty())) {
        if (timeout <= 0L) {
          return null;
        }
        waitForOperationAvailable(timeout);
      }
      if (!nonQueryOperations.isEmpty()) {
        return nonQueryOperations.removeFirst();
      }
      if (processQueries && !queryOperations.isEmpty()) {
        return queryOperations.removeFirst();
      }
      return null;
    }
  }

  /**
   * Add the given operation to the tail of this queue.
   * 
   * @param operation the operation to be added to the queue
   */
  public void enqueue(IndexOperation operation) {
    synchronized (nonQueryOperations) {
      if (operation instanceof ClearOperation) {
        queryOperations.clear();
        nonQueryOperations.clear();
      }
      if (operation instanceof RemoveSourceOperation) {
        Source source = ((RemoveSourceOperation) operation).getSource();
        removeForSource(source, nonQueryOperations);
        removeForSource(source, queryOperations);
      }
      if (operation.isQuery()) {
        queryOperations.add(operation);
      } else {
        nonQueryOperations.add(operation);
      }
      notifyOperationAvailable();
    }
  }

  /**
   * Return a list containing all of the operations that are currently on the queue. Modifying this
   * list will not affect the state of the queue.
   * 
   * @return all of the operations that are currently on the queue
   */
  public List<IndexOperation> getOperations() {
    List<IndexOperation> operations = Lists.newArrayList();
    synchronized (nonQueryOperations) {
      operations.addAll(nonQueryOperations);
      operations.addAll(queryOperations);
    }
    return operations;
  }

  /**
   * Set whether the receiver's {@link #dequeue(long)} method should return query operations.
   * 
   * @param processQueries {@code true} if the receiver's {@link #dequeue(long)} method should
   *          return query operations or {@code false} if query operations should be queued but not
   *          returned by the receiver's {@link #dequeue(long)} method until this method is called
   *          with a value of {@code true}.
   */
  public void setProcessQueries(boolean processQueries) {
    synchronized (nonQueryOperations) {
      if (this.processQueries != processQueries) {
        this.processQueries = processQueries;
        if (processQueries && !queryOperations.isEmpty()) {
          notifyOperationAvailable();
        }
      }
    }
  }

  /**
   * Return the number of operations on the queue.
   * 
   * @return the number of operations on the queue
   */
  public int size() {
    synchronized (nonQueryOperations) {
      return nonQueryOperations.size() + queryOperations.size();
    }
  }

  private void notifyOperationAvailable() {
    nonQueryOperations.notifyAll();
  }

  /**
   * Removes operations that should be removed when given {@link Source} is removed.
   */
  private void removeForSource(Source source, LinkedList<IndexOperation> operations) {
    for (Iterator<IndexOperation> iter = operations.listIterator(); iter.hasNext();) {
      IndexOperation indexOperation = iter.next();
      if (indexOperation.removeWhenSourceRemoved(source)) {
        iter.remove();
      }
    }
  }

  private void waitForOperationAvailable(long timeout) throws InterruptedException {
    nonQueryOperations.wait(timeout);
  }
}