Java Code Examples for org.openide.util.Mutex#ExceptionAction

/**
 * Runs given action both in Project read lock and synchronized on given cache
 * @param protectedCache Synchronized cache list, e.g. sourceLists, binaryLists, etc.
 * @param action Action to run
 * @return created or cached module list
 * @throws java.io.IOException
 */
private static ModuleList runProtected(final Object protectedCache, final Mutex.ExceptionAction<ModuleList> action) throws IOException {
    try {
        LOG.log(Level.FINER, "runProtected: sync 0");
        return ProjectManager.mutex().readAccess(new Mutex.ExceptionAction<ModuleList>() {
            public ModuleList run() throws Exception {
                LOG.log(Level.FINER, "runProtected: sync 1");
                synchronized (protectedCache) {
                    return action.run();
                }
            }
        });
    } catch (MutexException e){
        throw (IOException) e.getException();
    }
}
 

public DeferredTask (
        @NonNull final Collection<Source> sources,
        @NonNull final Mutex.ExceptionAction<Void> task,
        @NonNull final ScanSync sync,
        @NonNull final Lookup context) {
    assert sources != null;
    assert task != null;
    assert sync != null;
    assert context != null;

    this.sources = sources;
    this.task = task;
    this.sync = sync;
    this.context = context;
}
 

@Override
public <T> T writeAccess(Mutex.ExceptionAction<T> action) throws MutexException {
    return doEventAccess(action);         
}
 

@Override
public <T> T readAccess(Mutex.ExceptionAction<T> action) throws MutexException {
    return doEventAccess(action);
}
 

@Override
public <T> T writeAccess(Mutex.ExceptionAction<T> action) throws MutexException {
    return getDelegate().writeAccess(action);
}
 

@Override
public <T> T readAccess(Mutex.ExceptionAction<T> action) throws MutexException {
    return getDelegate().readAccess(action);
}
 

@Override
public <T> T writeAccess(Mutex.ExceptionAction<T> action) throws MutexException {
    return handle();
}
 

@Override
public <T> T readAccess(Mutex.ExceptionAction<T> action) throws MutexException {
    return handle();
}
 

@NonNull
public static Future<Void> runWhenScanFinished (
        @NonNull final Mutex.ExceptionAction<Void> task,
        @NonNull final Collection<Source> sources) throws ParseException {
    assert task != null;
    assert sources != null;
    final ScanSync sync = new ScanSync (task);
    final DeferredTask r = new DeferredTask (sources, task, sync, Lookup.getDefault());
    //0) Add speculatively task to be performed at the end of background scan
    todo.add (r);
    boolean indexing = TaskProcessor.getIndexerBridge().isIndexing();
    if (indexing) {
        return sync;
    }
    //1) Try to aquire javac lock, if successfull no task is running
    //   perform the given taks synchronously if it wasn't already performed
    //   by background scan.
    final boolean locked = lock.readLock().tryLock();
    if (locked) {
        try {
            LOG.log(
                Level.FINE,
                "runWhenScanFinished:entry",    //NOI18N
                task);
            if (todo.remove(r)) {
                try {
                    TaskProcessor.runUserTask(task, sources);
                } finally {
                    sync.taskFinished();
                }
            }
            LOG.log(
                Level.FINE,
                "runWhenScanFinished:exit",     //NOI18N
                task);
        } finally {
            lock.readLock().unlock();
        }
    }
    return sync;
}
 

public ScanSync (final Mutex.ExceptionAction<Void> task) {
    assert task != null;
    this.task = task;
    this.sync = new CountDownLatch (1);
    this.canceled = new AtomicBoolean (false);
}
 

<T> T writeAccess(Mutex.ExceptionAction<T> action) throws MutexException; 

<T> T readAccess(Mutex.ExceptionAction<T> action) throws MutexException;