org.eclipse.core.internal.resources.WorkspacePreferences Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of aspectjtools Show documentation
Show all versions of aspectjtools Show documentation
AspectJ tools most notably contains the AspectJ compiler (AJC). AJC applies aspects to Java classes during
compilation, fully replacing Javac for plain Java classes and also compiling native AspectJ or annotation-based
@AspectJ syntax. Furthermore, AJC can weave aspects into existing class files in a post-compile binary weaving step.
This library is a superset of AspectJ weaver and hence also of AspectJ runtime.
/*******************************************************************************
* Copyright (c) 2000, 2015 IBM Corporation and others.
*
* This program and the accompanying materials
* are made available under the terms of the Eclipse Public License 2.0
* which accompanies this distribution, and is available at
* https://www.eclipse.org/legal/epl-2.0/
*
* SPDX-License-Identifier: EPL-2.0
*
* Contributors:
* IBM Corporation - initial API and implementation
* James Blackburn (Broadcom Corp.) - ongoing development
* Lars Vogel - Bug 473427
*******************************************************************************/
package org.eclipse.core.internal.resources;
import java.util.*;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.Preferences;
/**
* This class provides the same interface as WorkspaceDescription
* but instead of changing/obtaining values from its internal state, it
* changes/obtains properties in/from the workspace plug-in's preferences.
*
* Note: for performance reasons, some frequently called accessor methods are
* reading a cached value from the super class instead of reading the
* corresponding property preference store. To keep the cache synchronized with
* the preference store, a property change listener is used.
*/
public class WorkspacePreferences extends WorkspaceDescription {
public final static String PROJECT_SEPARATOR = "/"; //$NON-NLS-1$
private Preferences preferences;
/**
* Helper method that converts a string string array {"string1","
* string2",..."stringN"} to a string in the form "string1,string2,...
* stringN".
*/
public static String convertStringArraytoString(String[] array) {
if (array == null || array.length == 0)
return ""; //$NON-NLS-1$
StringBuilder sb = new StringBuilder();
for (String element : array) {
sb.append(element);
sb.append(PROJECT_SEPARATOR);
}
sb.deleteCharAt(sb.length() - 1);
return sb.toString();
}
/**
* Helper method that converts a string in the form "string1,string2,...
* stringN" to a string array {"string1","string2",..."stringN"}.
*/
public static String[] convertStringToStringArray(String string, String separator) {
List list = new ArrayList<>();
for (StringTokenizer tokenizer = new StringTokenizer(string, separator); tokenizer.hasMoreTokens();)
list.add(tokenizer.nextToken());
return list.toArray(new String[list.size()]);
}
/**
* Helper method that copies all attributes from a workspace description
* object to another.
*/
private static void copyFromTo(WorkspaceDescription source, WorkspaceDescription target) {
target.setAutoBuilding(source.isAutoBuilding());
target.setBuildOrder(source.getBuildOrder());
target.setMaxBuildIterations(source.getMaxBuildIterations());
target.setApplyFileStatePolicy(source.isApplyFileStatePolicy());
target.setFileStateLongevity(source.getFileStateLongevity());
target.setMaxFileStates(source.getMaxFileStates());
target.setMaxFileStateSize(source.getMaxFileStateSize());
target.setKeepDerivedState(source.isKeepDerivedState());
target.setSnapshotInterval(source.getSnapshotInterval());
target.setOperationsPerSnapshot(source.getOperationsPerSnapshot());
target.setDeltaExpiration(source.getDeltaExpiration());
target.setMaxConcurrentBuilds(source.getMaxConcurrentBuilds());
}
public WorkspacePreferences() {
super("Workspace"); //$NON-NLS-1$
this.preferences = ResourcesPlugin.getPlugin().getPluginPreferences();
final String version = preferences.getString(ICoreConstants.PREF_VERSION_KEY);
if (!ICoreConstants.PREF_VERSION.equals(version))
upgradeVersion(version);
// initialize cached preferences (for better performance)
super.setAutoBuilding(preferences.getBoolean(ResourcesPlugin.PREF_AUTO_BUILDING));
super.setSnapshotInterval(preferences.getInt(ResourcesPlugin.PREF_SNAPSHOT_INTERVAL));
super.setMaxBuildIterations(preferences.getInt(ResourcesPlugin.PREF_MAX_BUILD_ITERATIONS));
super.setApplyFileStatePolicy(preferences.getBoolean(ResourcesPlugin.PREF_APPLY_FILE_STATE_POLICY));
super.setMaxFileStates(preferences.getInt(ResourcesPlugin.PREF_MAX_FILE_STATES));
super.setMaxFileStateSize(preferences.getLong(ResourcesPlugin.PREF_MAX_FILE_STATE_SIZE));
super.setFileStateLongevity(preferences.getLong(ResourcesPlugin.PREF_FILE_STATE_LONGEVITY));
super.setOperationsPerSnapshot(preferences.getInt(PreferenceInitializer.PREF_OPERATIONS_PER_SNAPSHOT));
super.setDeltaExpiration(preferences.getLong(PreferenceInitializer.PREF_DELTA_EXPIRATION));
super.setMaxConcurrentBuilds(preferences.getInt(ResourcesPlugin.PREF_MAX_CONCURRENT_BUILDS));
super.setKeepDerivedState(preferences.getBoolean(ResourcesPlugin.PREF_KEEP_DERIVED_STATE));
// This property listener ensures we are being updated properly when changes
// are done directly to the preference store.
preferences.addPropertyChangeListener(event -> synchronizeWithPreferences(event.getProperty()));
}
@Override
public Object clone() {
// should never be called - throws an exception to avoid using a
// WorkspacePreferences when using WorkspaceDescription was the real
// intention (this class offers a different protocol for copying state).
throw new UnsupportedOperationException("clone() is not supported in " + getClass().getName()); //$NON-NLS-1$
}
public void copyFrom(WorkspaceDescription source) {
copyFromTo(source, this);
}
public void copyTo(WorkspaceDescription target) {
copyFromTo(this, target);
}
/**
* @see org.eclipse.core.resources.IWorkspaceDescription#getBuildOrder()
*/
@Override
public String[] getBuildOrder() {
boolean defaultBuildOrder = preferences.getBoolean(ResourcesPlugin.PREF_DEFAULT_BUILD_ORDER);
if (defaultBuildOrder)
return null;
return convertStringToStringArray(preferences.getString(ResourcesPlugin.PREF_BUILD_ORDER), PROJECT_SEPARATOR);
}
/**
* @see org.eclipse.core.internal.resources.WorkspaceDescription#getBuildOrder(boolean)
*/
@Override
public String[] getBuildOrder(boolean makeCopy) {
//note that since this is stored in the preference store, we are creating
//a new copy of the string array on every access anyway
return getBuildOrder();
}
/**
* @see org.eclipse.core.resources.IWorkspaceDescription#setAutoBuilding(boolean)
*/
@Override
public void setAutoBuilding(boolean value) {
preferences.setValue(ResourcesPlugin.PREF_AUTO_BUILDING, value);
}
/**
* @see org.eclipse.core.resources.IWorkspaceDescription#setBuildOrder(String[])
*/
@Override
public void setBuildOrder(String[] value) {
preferences.setValue(ResourcesPlugin.PREF_DEFAULT_BUILD_ORDER, value == null);
preferences.setValue(ResourcesPlugin.PREF_BUILD_ORDER, convertStringArraytoString(value));
}
@Override
public void setDeltaExpiration(long value) {
preferences.setValue(PreferenceInitializer.PREF_DELTA_EXPIRATION, value);
}
/**
* @see org.eclipse.core.resources.IWorkspaceDescription#setApplyFileStatePolicy(boolean)
*/
@Override
public void setApplyFileStatePolicy(boolean apply) {
preferences.setValue(ResourcesPlugin.PREF_APPLY_FILE_STATE_POLICY, apply);
}
/**
* @see org.eclipse.core.resources.IWorkspaceDescription#setFileStateLongevity(long)
*/
@Override
public void setFileStateLongevity(long time) {
preferences.setValue(ResourcesPlugin.PREF_FILE_STATE_LONGEVITY, time);
}
/**
* @see org.eclipse.core.resources.IWorkspaceDescription#setMaxBuildIterations(int)
*/
@Override
public void setMaxBuildIterations(int number) {
preferences.setValue(ResourcesPlugin.PREF_MAX_BUILD_ITERATIONS, number);
}
/**
* @see org.eclipse.core.resources.IWorkspaceDescription#setMaxFileStates(int)
*/
@Override
public void setMaxFileStates(int number) {
preferences.setValue(ResourcesPlugin.PREF_MAX_FILE_STATES, number);
}
/**
* @see org.eclipse.core.resources.IWorkspaceDescription#setMaxFileStateSize(long)
*/
@Override
public void setMaxFileStateSize(long size) {
preferences.setValue(ResourcesPlugin.PREF_MAX_FILE_STATE_SIZE, size);
}
@Override
public void setOperationsPerSnapshot(int value) {
preferences.setValue(PreferenceInitializer.PREF_OPERATIONS_PER_SNAPSHOT, value);
}
@Override
public void setMaxConcurrentBuilds(int n) {
preferences.setValue(ResourcesPlugin.PREF_MAX_CONCURRENT_BUILDS, n);
}
@Override
public void setKeepDerivedState(boolean keepDerivedState) {
preferences.setValue(ResourcesPlugin.PREF_KEEP_DERIVED_STATE, keepDerivedState);
}
/**
* @see org.eclipse.core.resources.IWorkspaceDescription#setSnapshotInterval(long)
*/
@Override
public void setSnapshotInterval(long delay) {
preferences.setValue(ResourcesPlugin.PREF_SNAPSHOT_INTERVAL, delay);
}
protected void synchronizeWithPreferences(String property) {
// do not use the value in the event - may be a string instead
// of the expected type. Retrieve it from the preferences store
// using the type-specific method
if (property.equals(ResourcesPlugin.PREF_AUTO_BUILDING))
super.setAutoBuilding(preferences.getBoolean(ResourcesPlugin.PREF_AUTO_BUILDING));
else if (property.equals(ResourcesPlugin.PREF_SNAPSHOT_INTERVAL))
super.setSnapshotInterval(preferences.getLong(ResourcesPlugin.PREF_SNAPSHOT_INTERVAL));
else if (property.equals(ResourcesPlugin.PREF_MAX_BUILD_ITERATIONS))
super.setMaxBuildIterations(preferences.getInt(ResourcesPlugin.PREF_MAX_BUILD_ITERATIONS));
else if (property.equals(ResourcesPlugin.PREF_APPLY_FILE_STATE_POLICY))
super.setApplyFileStatePolicy(preferences.getBoolean(ResourcesPlugin.PREF_APPLY_FILE_STATE_POLICY));
else if (property.equals(ResourcesPlugin.PREF_MAX_FILE_STATES))
super.setMaxFileStates(preferences.getInt(ResourcesPlugin.PREF_MAX_FILE_STATES));
else if (property.equals(ResourcesPlugin.PREF_MAX_FILE_STATE_SIZE))
super.setMaxFileStateSize(preferences.getLong(ResourcesPlugin.PREF_MAX_FILE_STATE_SIZE));
else if (property.equals(ResourcesPlugin.PREF_FILE_STATE_LONGEVITY))
super.setFileStateLongevity(preferences.getLong(ResourcesPlugin.PREF_FILE_STATE_LONGEVITY));
else if (property.equals(PreferenceInitializer.PREF_OPERATIONS_PER_SNAPSHOT))
super.setOperationsPerSnapshot(preferences.getInt(PreferenceInitializer.PREF_OPERATIONS_PER_SNAPSHOT));
else if (property.equals(PreferenceInitializer.PREF_DELTA_EXPIRATION))
super.setDeltaExpiration(preferences.getLong(PreferenceInitializer.PREF_DELTA_EXPIRATION));
else if (property.equals(ResourcesPlugin.PREF_MAX_CONCURRENT_BUILDS))
super.setMaxConcurrentBuilds(preferences.getInt(ResourcesPlugin.PREF_MAX_CONCURRENT_BUILDS));
else if (property.equals(ResourcesPlugin.PREF_KEEP_DERIVED_STATE)) {
super.setKeepDerivedState(preferences.getBoolean(ResourcesPlugin.PREF_KEEP_DERIVED_STATE));
}
}
private void upgradeVersion(String oldVersion) {
if (oldVersion.length() == 0) {
//only need to convert the build order if we are not using the default order
if (!preferences.getBoolean(ResourcesPlugin.PREF_DEFAULT_BUILD_ORDER)) {
String oldOrder = preferences.getString(ResourcesPlugin.PREF_BUILD_ORDER);
setBuildOrder(convertStringToStringArray(oldOrder, ":")); //$NON-NLS-1$
}
}
preferences.setValue(ICoreConstants.PREF_VERSION_KEY, ICoreConstants.PREF_VERSION);
}
}