org.netbeans.modules.java.j2semodule.MainClassUpdater Maven / Gradle / Ivy
The newest version!
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0
*
* 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 org.netbeans.modules.java.j2semodule;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.io.IOException;
import java.net.URL;
import java.util.Collection;
import java.util.Optional;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.lang.model.element.TypeElement;
import javax.swing.SwingUtilities;
import org.netbeans.api.annotations.common.NonNull;
import org.netbeans.api.java.classpath.ClassPath;
import org.netbeans.api.java.classpath.JavaClassPathConstants;
import org.netbeans.api.java.platform.JavaPlatformManager;
import org.netbeans.api.java.source.*;
import org.netbeans.api.project.Project;
import org.netbeans.api.project.ProjectManager;
import org.netbeans.modules.java.api.common.SourceRoots;
import org.netbeans.modules.java.api.common.ant.UpdateHelper;
import org.netbeans.modules.java.api.common.project.ProjectProperties;
import org.netbeans.spi.java.classpath.support.ClassPathSupport;
import org.netbeans.spi.project.support.ant.AntProjectHelper;
import org.netbeans.spi.project.support.ant.EditableProperties;
import org.netbeans.spi.project.support.ant.PropertyEvaluator;
import org.openide.filesystems.FileChangeAdapter;
import org.openide.filesystems.FileChangeListener;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileRenameEvent;
import org.openide.filesystems.FileUtil;
import org.openide.loaders.DataObject;
import org.openide.util.Exceptions;
import org.openide.util.Mutex;
import org.openide.util.MutexException;
import org.openide.util.RequestProcessor;
import org.openide.util.WeakListeners;
/**
*
* @author Tomas Zezula
*/
final class MainClassUpdater extends FileChangeAdapter implements PropertyChangeListener {
private static final RequestProcessor RP = new RequestProcessor ("main-class-updater",1); //NOI18N
private static final Logger LOG = Logger.getLogger(MainClassUpdater.class.getName());
private static final int NEW = 0;
private static final int STARTED = 1;
private static final int FINISHED = 2;
private final Project project;
private final PropertyEvaluator eval;
private final UpdateHelper helper;
private final SourceRoots sourceRoots;
private final String mainClassPropName;
private final AtomicInteger state;
//@GuardedBy("this")
private FileObject currentFo;
//@GuardedBy("this")
private DataObject currentDo;
//@GuardedBy("this")
private FileChangeListener foListener;
//@GuardedBy("this")
private PropertyChangeListener doListener;
//@GuardedBy("this")
private long lc = 0;
/** Creates a new instance of MainClassUpdater */
MainClassUpdater(
@NonNull final Project project,
@NonNull final PropertyEvaluator eval,
@NonNull final UpdateHelper helper,
@NonNull final SourceRoots sourceRoots,
@NonNull final String mainClassPropName) {
assert project != null;
assert eval != null;
assert helper != null;
assert sourceRoots != null;
assert mainClassPropName != null;
this.project = project;
this.eval = eval;
this.helper = helper;
this.sourceRoots = sourceRoots;
this.mainClassPropName = mainClassPropName;
this.state = new AtomicInteger(NEW);
}
void start () {
RP.submit(() -> {
if (state.compareAndSet(NEW, STARTED)) {
eval.addPropertyChangeListener(MainClassUpdater.this);
addFileChangeListener ();
} else {
throw new IllegalStateException("Current State: " + state.get()); //NOI18N
}
});
}
public void stop() {
RP.submit(() -> {
if (state.compareAndSet(STARTED, FINISHED)) {
synchronized (MainClassUpdater.this) {
if (currentFo != null && foListener != null) {
currentFo.removeFileChangeListener(foListener);
}
if (currentDo != null && doListener != null) {
currentDo.removePropertyChangeListener(doListener);
}
}
} else {
throw new IllegalStateException("Current State: " + state.get()); //NOI18N
}
});
}
@Override
public void propertyChange(PropertyChangeEvent evt) {
if (DataObject.PROP_PRIMARY_FILE.equals(evt.getPropertyName())) {
final FileObject newFile = (FileObject) evt.getNewValue();
final FileObject oldFile = (FileObject) evt.getOldValue();
handleMainClassMoved(oldFile, newFile);
} else if (this.mainClassPropName.equals(evt.getPropertyName())) {
//Go out of the ProjectManager.MUTEX, see #118722
RP.post(MainClassUpdater.this::addFileChangeListener);
}
}
@Override
public void fileRenamed (final FileRenameEvent evt) {
handleMainClassMoved(evt.getFile(), evt.getFile());
}
private void handleMainClassMoved(final FileObject oldFile, final FileObject newFile) {
if (!project.getProjectDirectory().isValid()) {
return;
}
final FileObject _current;
synchronized (this) {
_current = this.currentFo;
}
if (oldFile == _current) {
Runnable r = () -> {
try {
final String oldMainClass = ProjectManager.mutex().readAccess((Mutex.ExceptionAction) () -> eval.getProperty(mainClassPropName));
Collection> main = SourceUtils.getMainClasses(newFile);
String newMainClass = null;
if (!main.isEmpty()) {
ElementHandle mainHandle = main.iterator().next();
newMainClass = mainHandle.getQualifiedName();
}
if (newMainClass != null && !newMainClass.equals(oldMainClass) && helper.requestUpdate() &&
// XXX ##84806: ideally should update nbproject/configs/*.properties in this case:
eval.getProperty(ProjectProperties.PROP_PROJECT_CONFIGURATION_CONFIG) == null) {
final String newMainClassFinal = newMainClass;
ProjectManager.mutex().writeAccess((Mutex.ExceptionAction) () -> {
EditableProperties props = helper.getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH);
props.put (mainClassPropName, newMainClassFinal);
helper.putProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH, props);
ProjectManager.getDefault().saveProject (project);
return null;
});
}
} catch (IOException | MutexException e) {
Exceptions.printStackTrace(e);
}
};
if (SwingUtilities.isEventDispatchThread()) {
r.run();
} else {
SwingUtilities.invokeLater(r);
}
}
}
private void addFileChangeListener () {
final long clc;
synchronized (MainClassUpdater.this) {
if (currentFo != null && foListener != null) {
currentFo.removeFileChangeListener(foListener);
foListener = null;
currentFo = null;
}
if (currentDo != null && doListener != null) {
currentDo.removePropertyChangeListener(doListener);
doListener = null;
currentDo = null;
}
clc = ++lc;
}
final String mainClassName = eval.getProperty(mainClassPropName);
if (mainClassName != null) {
FileObject[] roots = sourceRoots.getRoots();
if (roots.length>0) {
final ClassPath bootCp = Optional.ofNullable(ClassPath.getClassPath(roots[0], ClassPath.BOOT))
.orElse(JavaPlatformManager.getDefault().getDefaultPlatform().getBootstrapLibraries());
final ClassPath compileCp = Optional.ofNullable(ClassPath.getClassPath(roots[0], ClassPath.COMPILE))
.orElse(ClassPath.EMPTY);
final ClassPath systemModules = ClassPath.getClassPath(roots[0], JavaClassPathConstants.MODULE_BOOT_PATH);
final ClassPath modulePath = ClassPath.getClassPath(roots[0], JavaClassPathConstants.MODULE_COMPILE_PATH);
final ClassPath allUnnamed = ClassPath.getClassPath(roots[0], JavaClassPathConstants.MODULE_CLASS_PATH);
final ClassPath moduleSourcePath = ClassPath.getClassPath(roots[0], JavaClassPathConstants.MODULE_SOURCE_PATH);
final ClasspathInfo cpInfo = new ClasspathInfo.Builder(bootCp)
.setClassPath(compileCp)
.setModuleBootPath(systemModules)
.setModuleCompilePath(modulePath)
.setModuleClassPath(allUnnamed)
.setModuleSourcePath(moduleSourcePath)
.build();
final JavaSource js = JavaSource.create(cpInfo);
// execute immediately, or delay if cannot find main class
ScanUtils.postUserActionTask(js, (CompilationController c) -> {
c.toPhase(JavaSource.Phase.ELEMENTS_RESOLVED);
TypeElement te = ScanUtils.checkElement(c, c.getElements().getTypeElement(mainClassName));
if (te != null) {
final ClassPath allSources = ClassPathSupport.createClassPath(roots);
final FileObject fo = SourceUtils.getFile(
te,
new ClasspathInfo.Builder(bootCp)
.setClassPath(compileCp)
.setSourcePath(allSources)
.setModuleBootPath(systemModules)
.setModuleCompilePath(modulePath)
.setModuleClassPath(allUnnamed)
.setModuleSourcePath(moduleSourcePath)
.build());
final boolean owned = allSources.contains(fo);
synchronized (MainClassUpdater.this) {
if (lc == clc && fo != null && owned) {
currentFo = fo;
foListener = WeakListeners.create(FileChangeListener.class, MainClassUpdater.this, currentFo);
currentFo.addFileChangeListener(foListener);
currentDo = DataObject.find(currentFo);
doListener = org.openide.util.WeakListeners.propertyChange(MainClassUpdater.this, currentDo);
currentDo.addPropertyChangeListener(doListener);
}
}
}
});
}
}
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy