Java TaskListener类代码示例

import com.sun.source.util.TaskListener; //导入依赖的package包/类
public static void add(ProcessingEnvironment env, Runnable r) {
    // ensure this class in this class loader can access javac internals
    try {
        JavacTask task = JavacTask.instance(env);
        TaskListener l = ((BasicJavacTask) task).getTaskListeners().iterator().next();
        // The TaskListener is an instanceof TestClose, but when using the
        // default class loaders. the taskListener uses a different
        // instance of Class<TestClose> than the anno processor.
        // If you try to evaluate
        //      TestClose tc = (TestClose) (l).
        // you get the following somewhat confusing error:
        //   java.lang.ClassCastException: TestClose cannot be cast to TestClose
        // The workaround is to access the fields of TestClose with reflection.
        Field f = l.getClass().getField("runnables");
        @SuppressWarnings("unchecked")
        List<Runnable> runnables = (List<Runnable>) f.get(l);
        runnables.add(r);
    } catch (Throwable t) {
        t.printStackTrace();
    }
}
 

import com.sun.source.util.TaskListener; //导入依赖的package包/类
/**
 * Fork a new compilation task; if possible the compilation context from previous executions is
 * retained (see comments in ReusableContext as to when it's safe to do so); otherwise a brand
 * new context is created.
 */
public JavacTask getTask() {
    if (task == null) {
        ReusableContext context = env.context();
        String opts = options == null ? "" :
                StreamSupport.stream(options.spliterator(), false).collect(Collectors.joining());
        context.clear();
        if (!context.polluted && (context.opts == null || context.opts.equals(opts))) {
            //we can reuse former context
            env.info().ctxReusedCount++;
        } else {
            env.info().ctxDroppedCount++;
            //it's not safe to reuse context - create a new one
            context = env.setContext(new ReusableContext());
        }
        context.opts = opts;
        JavacTask javacTask = ((JavacTool)env.javaCompiler()).getTask(out, env.fileManager(),
                diagsCollector, options, null, sources, context);
        javacTask.setTaskListener(context);
        for (TaskListener l : listeners) {
            javacTask.addTaskListener(l);
        }
        task = javacTask;
    }
    return task;
}
 

import com.sun.source.util.TaskListener; //导入依赖的package包/类
public static void add(ProcessingEnvironment env, Runnable r) {
    try {
        JavacTask task = JavacTask.instance(env);
        TaskListener l = ((BasicJavacTask) task).getTaskListeners().iterator().next();
        // The TaskListener is an instanceof TestClose, but when using the
        // default class loaders. the taskListener uses a different
        // instance of Class<TestClose> than the anno processor.
        // If you try to evaluate
        //      TestClose tc = (TestClose) (l).
        // you get the following somewhat confusing error:
        //   java.lang.ClassCastException: TestClose cannot be cast to TestClose
        // The workaround is to access the fields of TestClose with reflection.
        Field f = l.getClass().getField("runnables");
        @SuppressWarnings("unchecked")
        List<Runnable> runnables = (List<Runnable>) f.get(l);
        runnables.add(r);
    } catch (Throwable t) {
        t.printStackTrace();
    }
}
 

import com.sun.source.util.TaskListener; //导入依赖的package包/类
private void runLastRound(PrintWriter xout,
                          int roundNumber,
                          boolean errorStatus,
                          TaskListener taskListener) throws IOException {
    roundNumber++;
    List<ClassSymbol> noTopLevelClasses = List.nil();
    Set<TypeElement> noAnnotations =  Collections.emptySet();
    printRoundInfo(xout, roundNumber, noTopLevelClasses, noAnnotations, true);

    Set<Element> emptyRootElements = Collections.emptySet(); // immutable
    RoundEnvironment renv = new JavacRoundEnvironment(true,
                                                      errorStatus,
                                                      emptyRootElements,
                                                      JavacProcessingEnvironment.this);
    if (taskListener != null)
        taskListener.started(new TaskEvent(TaskEvent.Kind.ANNOTATION_PROCESSING_ROUND));

    try {
        discoveredProcs.iterator().runContributingProcs(renv);
    } finally {
        if (taskListener != null)
            taskListener.finished(new TaskEvent(TaskEvent.Kind.ANNOTATION_PROCESSING_ROUND));
    }
}
 

import com.sun.source.util.TaskListener; //导入依赖的package包/类
/** Run a processing round. */
void run(boolean lastRound, boolean errorStatus) {
    printRoundInfo(lastRound);

    TaskListener taskListener = context.get(TaskListener.class);
    if (taskListener != null)
        taskListener.started(new TaskEvent(TaskEvent.Kind.ANNOTATION_PROCESSING_ROUND));

    try {
        if (lastRound) {
            filer.setLastRound(true);
            Set<Element> emptyRootElements = Collections.emptySet(); // immutable
            RoundEnvironment renv = new JavacRoundEnvironment(true,
                    errorStatus,
                    emptyRootElements,
                    JavacProcessingEnvironment.this);
            discoveredProcs.iterator().runContributingProcs(renv);
        } else {
            discoverAndRunProcs(context, annotationsPresent, topLevelClasses, packageInfoFiles);
        }
    } finally {
        if (taskListener != null)
            taskListener.finished(new TaskEvent(TaskEvent.Kind.ANNOTATION_PROCESSING_ROUND));
    }

    nMessagerErrors = messager.errorCount();
}
 

import com.sun.source.util.TaskListener; //导入依赖的package包/类
public void add(TaskListener listener) {
    for (TaskListener l: listeners) {
        if (ccw.unwrap(l) == listener)
            throw new IllegalStateException();
    }
    listeners = Arrays.copyOf(listeners, listeners.length + 1);
    listeners[listeners.length - 1] = ccw.wrap(listener);
}
 

import com.sun.source.util.TaskListener; //导入依赖的package包/类
public void remove(TaskListener listener) {
    for (int i = 0; i < listeners.length; i++) {
        if (ccw.unwrap(listeners[i]) == listener) {
            TaskListener[] newListeners = new TaskListener[listeners.length - 1];
            System.arraycopy(listeners, 0, newListeners, 0, i);
            System.arraycopy(listeners, i + 1, newListeners, i, newListeners.length - i);
            listeners = newListeners;
            break;
        }
    }
}
 

import com.sun.source.util.TaskListener; //导入依赖的package包/类
@Override
public void started(TaskEvent e) {
    // guard against listeners being updated by a listener
    TaskListener[] ll = this.listeners;
    for (TaskListener l: ll)
        l.started(e);
}
 

import com.sun.source.util.TaskListener; //导入依赖的package包/类
@Override
public void finished(TaskEvent e) {
    // guard against listeners being updated by a listener
    TaskListener[] ll = this.listeners;
    for (TaskListener l: ll)
        l.finished(e);
}
 

import com.sun.source.util.TaskListener; //导入依赖的package包/类
@Override
public void setTaskListener(TaskListener tl) {
    MultiTaskListener mtl = MultiTaskListener.instance(context);
    if (taskListener != null)
        mtl.remove(taskListener);
    if (tl != null)
        mtl.add(tl);
    taskListener = tl;
}
 

import com.sun.source.util.TaskListener; //导入依赖的package包/类
public void remove(TaskListener listener) {
    for (int i = 0; i < listeners.length; i++) {
        if (ccw.unwrap(listeners[i]) == listener) {
            if (listeners.length == 1) {
                listeners = EMPTY_LISTENERS;
            } else {
                TaskListener[] newListeners = new TaskListener[listeners.length - 1];
                System.arraycopy(listeners, 0, newListeners, 0, i);
                System.arraycopy(listeners, i + 1, newListeners, i, newListeners.length - i);
                listeners = newListeners;
            }
            break;
        }
    }
}
 

import com.sun.source.util.TaskListener; //导入依赖的package包/类
@Override @DefinedBy(Api.COMPILER_TREE)
public void started(TaskEvent e) {
    // guard against listeners being updated by a listener
    TaskListener[] ll = this.listeners;
    for (TaskListener l: ll)
        l.started(e);
}
 

import com.sun.source.util.TaskListener; //导入依赖的package包/类
@Override @DefinedBy(Api.COMPILER_TREE)
public void finished(TaskEvent e) {
    // guard against listeners being updated by a listener
    TaskListener[] ll = this.listeners;
    for (TaskListener l: ll)
        l.finished(e);
}
 

import com.sun.source.util.TaskListener; //导入依赖的package包/类
@Override @DefinedBy(Api.COMPILER_TREE)
public void setTaskListener(TaskListener tl) {
    MultiTaskListener mtl = MultiTaskListener.instance(context);
    if (taskListener != null)
        mtl.remove(taskListener);
    if (tl != null)
        mtl.add(tl);
    taskListener = tl;
}