* executor. Each event can be added and dispatched as separate phases.
   *
   * <p>This class is very similar to {@link SequentialExecutor} with the exception that events can
   * be added without necessarily executing immediately.
   */
  private static final class PerListenerQueue<L> implements Runnable {
    final L listener;
    final Executor executor;

    @GuardedBy("this")

    // it.
    executeListener(runnable, executor);
  }

  /**
   * Runs this execution list, executing all existing pairs in the order they were added. However,
   * note that listeners added after this point may be executed before those previously added, and
   * note that the execution order of all listeners is ultimately chosen by the implementations of
   * the supplied executors.
   *

          log.log(
              Level.SEVERE,
              "RuntimeException while executing runnable "
                  + runnable
                  + " with executor "
                  + executor,
              e);
        }
      }
    }
  }

  // A version of the execution list that doesn't reverse the stack in execute().
  private static final class NewExecutionListWithoutReverse {

 *
 */
public interface ContextEnabled {
    /**
     * Set a new shared context <code>Map</code> to a mojo before executing it.
     *
     * @param pluginContext a new <code>Map</code>
     */
    void setPluginContext(Map pluginContext);

    /**
     * @return a <code>Map</code> stored in the plugin container's context.
     */

    @SuppressWarnings("unused")
    Class<?> ensureLoaded = LockSupport.class;
  }

  private static final class DoNothingRunnable implements Runnable {
    @Override
    public void run() {}
  }
  // The thread executing the task publishes itself to the superclass' reference and the thread
  // interrupting sets DONE when it has finished interrupting.
  private static final Runnable DONE = new DoNothingRunnable();

            return pb.start().waitFor();
        } catch (IOException e) {
            invokerRequest.logger().error("IO problem while executing command: " + cmdAndArguments, e);
            return 127;
        } catch (InterruptedException e) {
            invokerRequest.logger().error("Interrupted while executing command: " + cmdAndArguments, e);
            return 127;
        }
    }

          // can't know without submitting something to the executor) so queue to run iteratively.
          // Task must be null, since each execution on this executor can only produce one more
          // execution.
          checkState(submittingTaskQueue.nextTask == null);
          submittingTaskQueue.nextTask = task;

  virtual void Release() = 0;

  // Creates an operation builder and ties it to this context.
  // The returned object can be used for setting operation's attributes,
  // adding inputs and finally executing (immediately or lazily as in tracing)
  // it in this context.
  virtual AbstractOperation* CreateOperation() = 0;

  // Registers a function with this context, after this the function is

    /**
     * Determines if the OS on which Maven is executing matches the
     * given OS family.
     *
     * @param family the family to check for
     * @return true if the OS matches
     *
     */
    public static boolean isFamily(String family) {
        return isFamily(family, OS_NAME);
    }

    /**
     * Determines if the OS on which Maven is executing matches the

@Experimental
public interface MavenInvoker<R extends MavenInvokerRequest<? extends MavenOptions>> extends Invoker<R> {
    /**
     * Invokes Maven using the provided MavenInvokerRequest.
     * This method is responsible for executing the Maven build process
     * based on the information contained in the request.
     *
     * @param invokerRequest the request containing all necessary information for the Maven invocation