Java Scheduler类代码示例

import org.netbeans.modules.parsing.spi.Scheduler; //导入依赖的package包/类
@Override
protected ParserResultTask createParserTask(FileObject file, FoldProcessor processor) {
    final ParserResultTask wrapped = super.createParserTask(file, processor);
    return new JavaParserResultTask(JavaSource.Phase.RESOLVED, TaskIndexingMode.ALLOWED_DURING_SCAN) {
        
        @Override
        public void run(Parser.Result result, SchedulerEvent event) {
            wrapped.run(result, event);
        }
        
        @Override
        public int getPriority() {
            return wrapped.getPriority();
        }
        
        @Override
        public Class<? extends Scheduler> getSchedulerClass() {
            return wrapped.getSchedulerClass();
        }
        
        @Override
        public void cancel() {
            wrapped.cancel();
        }
    };
}
 

import org.netbeans.modules.parsing.spi.Scheduler; //导入依赖的package包/类
@Override
public void attachScheduler(SchedulerControl s, boolean attach) {
    final Source now = getSourceControl().getSource();
    final Scheduler sched;
    SchedL l;
    synchronized (scheduledSources) {
        sched = s.getScheduler();
        l = scheduledSources.get(sched);
        if (attach && l == null) {
            l = new SchedL(s);
            scheduledSources.put(sched, l);
        }
    }
    if (l != null) {
        l.attachSource(sched, now, attach);
    }
}
 

import org.netbeans.modules.parsing.spi.Scheduler; //导入依赖的package包/类
@Override
public Class<? extends Scheduler> findStandardScheduler(String schedulerName) {
    switch (schedulerName) {
        case "CURSOR_SENSITIVE_TASK_SCHEDULER": // NOI18N
            return CursorSensitiveScheduler.class;
        
        case "EDITOR_SENSITIVE_TASK_SCHEDULER": // NOI18N
            return CurrentDocumentScheduler.class;
            
        case "SELECTED_NODES_SENSITIVE_TASK_SCHEDULER": // NOI18N
            return SelectedNodesScheduler.class;
            
        default:
            return null;
    }
}
 

import org.netbeans.modules.parsing.spi.Scheduler; //导入依赖的package包/类
@Override
public Map<Class<? extends Scheduler>,SchedulerEvent> createSchedulerEvents(
        @NonNull final Source source,
        @NonNull final Iterable<? extends Scheduler> schedulers,
        @NonNull final SourceModificationEvent sourceModificationEvent) {
    Parameters.notNull("source", source);   //NOI18N
    Parameters.notNull("schedulers", schedulers);   //NOI18N
    Parameters.notNull("sourceModificationEvent", sourceModificationEvent); //NOI18N
    final Map<Class<? extends Scheduler>,SchedulerEvent> result = new HashMap<Class<? extends Scheduler>, SchedulerEvent>();
    for (Scheduler scheduler : schedulers) {
        final SchedulerEvent schedulerEvent = SchedulerAccessor.get ().createSchedulerEvent (scheduler, sourceModificationEvent);
        if (schedulerEvent != null) {
            result.put (scheduler.getClass (), schedulerEvent);
        }
    }
    synchronized (TaskProcessor.INTERNAL_LOCK) {
        source.schedulerEvents = result;
    }
    return Collections.unmodifiableMap(result);
}
 

import org.netbeans.modules.parsing.spi.Scheduler; //导入依赖的package包/类
void refresh (EmbeddingProvider embeddingProvider, Class<? extends Scheduler> schedulerType) {
    List<Embedding> _embeddings = TaskProcessor.callEmbeddingProvider(embeddingProvider, getSnapshot ());
    List<Embedding> oldEmbeddings;
    synchronized (TaskProcessor.INTERNAL_LOCK) {
        oldEmbeddings = embeddingProviderToEmbedings.get (embeddingProvider);
        updateEmbeddings (_embeddings, oldEmbeddings, true, schedulerType);
        embeddingProviderToEmbedings.put (embeddingProvider, _embeddings);            
        upToDateEmbeddingProviders.add (embeddingProvider);
        if (this.embeddings != null) {
            final Embedding insertBefore = findNextEmbedding(providerOrder, embeddingProviderToEmbedings, embeddingProvider);
            this.embeddings.removeAll(oldEmbeddings);
            int index = insertBefore == null ? -1 : this.embeddings.indexOf(insertBefore);
            this.embeddings.addAll(index == -1 ? this.embeddings.size() : index, _embeddings);
        }
    }
}
 

import org.netbeans.modules.parsing.spi.Scheduler; //导入依赖的package包/类
public void scheduleTasks (Class<? extends Scheduler> schedulerType) {
    //S ystem.out.println("scheduleTasks " + schedulerType);
    final List<SchedulerTask> remove = new ArrayList<SchedulerTask> ();
    final List<Pair<SchedulerTask,Class<? extends Scheduler>>> add = new ArrayList<Pair<SchedulerTask,Class<? extends Scheduler>>> ();
    Collection<SchedulerTask> tsks = createTasks();
    synchronized (TaskProcessor.INTERNAL_LOCK) {
        for (SchedulerTask task : tsks) {
            if (schedulerType == null || task instanceof EmbeddingProvider) {
                if (!pendingTasks.remove (task)) {
                    remove.add (task);
                }                   
                add.add (Pair.<SchedulerTask,Class<? extends Scheduler>>of(task,null));
            } else if (task.getSchedulerClass () == schedulerType) {
                if (!pendingTasks.remove (task)) {
                    remove.add (task);
                }
                add.add (Pair.<SchedulerTask,Class<? extends Scheduler>>of(task,schedulerType));
            }
        }
    }        
    if (!add.isEmpty ()) {
        LOG.fine("Change tasks for source " + source + " - add: " + add + ", remove " + remove);
        TaskProcessor.updatePhaseCompletionTask(add, remove, source, this);
    }
}
 

import org.netbeans.modules.parsing.spi.Scheduler; //导入依赖的package包/类
public void unscheduleTasks (Class<? extends Scheduler> schedulerType) {
    //S ystem.out.println("unscheduleTasks " + schedulerType);
    final List<SchedulerTask> remove = new ArrayList<SchedulerTask> ();
    synchronized (TaskProcessor.INTERNAL_LOCK) {
        if (tasks != null) {
            for (SchedulerTask task : tasks) {
                if (schedulerType == null ||
                    task.getSchedulerClass () == schedulerType ||
                    task instanceof EmbeddingProvider
                ) {
                    remove.add (task);
                }
            }
        }
    }
    if (!remove.isEmpty ()) {
        TaskProcessor.removePhaseCompletionTasks(remove, source);
    }
}
 

import org.netbeans.modules.parsing.spi.Scheduler; //导入依赖的package包/类
public void testCancel_cancel_in_task_run() throws Exception {        
    TaskProcessor.addPhaseCompletionTasks(
        Collections.singleton(Pair.<SchedulerTask,Class<? extends Scheduler>>of(
            task,
            task.getSchedulerClass())),
        cache,
        false);
    assertTrue("TestTask started.", task.awaitStart(true));  //NOI18N
    TaskProcessor.addPhaseCompletionTasks(
        Collections.singleton(Pair.<SchedulerTask,Class<? extends Scheduler>>of(
            cancelTask,
            cancelTask.getSchedulerClass())),
        cache,
        false);
    assertTrue("Task cancelled", task.isABCancelled()); //NOI18N
    assertTrue("Task cancelled", task.isCSCancelled()); //NOI18N
    task.signalProgress();
    assertTrue("Test task finished", task.awaitDone(true)); //NOI18N
}
 

import org.netbeans.modules.parsing.spi.Scheduler; //导入依赖的package包/类
public void testScheduleEventsNonNull_218756() throws Exception {
    final Modification mod = Modification.getDefault();
    mod.expect(Task1.class, 0);
    mod.expect(Task2.class, 0);
    for (Scheduler scheduler : Utilities.getEnvFactory().getSchedulers(Lookup.getDefault())) {
        if (scheduler instanceof BaseScheduler) {
            ((BaseScheduler) scheduler).schedule (source);
        }
    }
    assertTrue(mod.await());        
    mod.expect(Task1.class, 1);
    mod.expect(Task2.class, 1);
    mod.doChange();
    assertTrue(mod.await());
    
}
 

import org.netbeans.modules.parsing.spi.Scheduler; //导入依赖的package包/类
public org.netbeans.modules.csl.navigation.ElementScanningTask getTask() {
    
    return new ElementScanningTask() {
        public @Override int getPriority() {
            return 20000;
        }
        public @Override Class<? extends Scheduler> getSchedulerClass() {
            return CSLNavigatorScheduler.class;
        }
        @Override public void run(final ParserResult result, final SchedulerEvent event) {
            runWithCancelService(new Runnable() {
                @Override
                public void run() {
                    resume();
                    StructureItem root = computeStructureRoot(result.getSnapshot().getSource());
                    FileObject file = result.getSnapshot().getSource().getFileObject();

                    if (root != null && file != null) {
                        Document doc = result.getSnapshot().getSource().getDocument(false);
                        BaseDocument bd = doc instanceof BaseDocument ? (BaseDocument)doc : null;
                        refresh(root, file, bd);
                    }
                }
            });
        }
    };
    
}
 

import org.netbeans.modules.parsing.spi.Scheduler; //导入依赖的package包/类
public static void reschedule() {
    for (Scheduler s : Lookup.getDefault().lookupAll(Scheduler.class)) {
        if (s instanceof GsfFoldScheduler) {
            GsfFoldScheduler gsfScheduler = (GsfFoldScheduler) s;
            gsfScheduler.schedule(new SchedulerEvent(gsfScheduler) {});
        }
    }
}
 

import org.netbeans.modules.parsing.spi.Scheduler; //导入依赖的package包/类
public void attachSource(
        @NonNull final Scheduler sched,
        @NonNull final Source s,
        final boolean attach) {
    assert Thread.holdsLock(sched);
    if (source != null) {
        assert attach || source == s : String.format(
            "attach: %b, source:%s(%d), s:%s(%d)",  //NOI18N
            attach,
            source,
            System.identityHashCode(source),
            s,
            System.identityHashCode(s));
        if (weakListener != null) {
            assert eventSource != null;
            final DataObject dobj = eventSource.get();
            if (dobj != null) {
                dobj.removePropertyChangeListener(weakListener);
            }
        }
        weakListener = null;
        eventSource = null;
        source = null;
    }
    if (attach) {
        final FileObject fo = s.getFileObject();
        if (fo != null) {
            try {
                final DataObject dobj = DataObject.find(fo);
                eventSource = new WeakReference<>(dobj);
                weakListener = WeakListeners.propertyChange(this, dobj);
                dobj.addPropertyChangeListener(weakListener);
            } catch (DataObjectNotFoundException ex) {
                //No DataObject for file - ignore
            }
        }
        this.source = s;
    }
}
 

import org.netbeans.modules.parsing.spi.Scheduler; //导入依赖的package包/类
public static <T extends Scheduler> T getScheduler(Class<T> clazz) {
    for (Scheduler scheduler : Utilities.getEnvFactory().getSchedulers(Lookup.getDefault())) {
        if (clazz.isInstance(scheduler)) {
            return (T)scheduler;
        }
    }
    throw new IllegalStateException("Scheduler not found");
}
 

import org.netbeans.modules.parsing.spi.Scheduler; //导入依赖的package包/类
@Override
public void setSchedulerEvent(
        final @NonNull Source source,
        final @NonNull Scheduler scheduler,
        final @NonNull SchedulerEvent event) {
    Parameters.notNull("source", source);           //NOI18N
    Parameters.notNull("scheduler", scheduler);     //NOI18N
    Parameters.notNull("event", event);             //NOI18N
    synchronized (TaskProcessor.INTERNAL_LOCK) {
        if (source.schedulerEvents == null) {
            source.schedulerEvents = new HashMap<Class<? extends Scheduler>, SchedulerEvent>();
        }
        source.schedulerEvents.put(scheduler.getClass(), event);
    }
}
 

import org.netbeans.modules.parsing.spi.Scheduler; //导入依赖的package包/类
@Override
public SchedulerEvent getSchedulerEvent (Source source, Class<? extends Scheduler> schedulerType) {
    if (schedulerType == null) {
        return null;
    }
    if (source.schedulerEvents == null)
        return null;
    return source.schedulerEvents.get (schedulerType);
}