org.eclipse.wst.validation.internal.ValidationConfiguration Maven / Gradle / Ivy
The newest version!
/*******************************************************************************
* Copyright (c) 2001, 2009 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.wst.validation.internal;
import java.lang.reflect.InvocationTargetException;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.StringTokenizer;
import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.Preferences;
import org.eclipse.core.runtime.Preferences.IPropertyChangeListener;
import org.eclipse.core.runtime.Preferences.PropertyChangeEvent;
import org.eclipse.wst.validation.internal.delegates.ValidatorDelegateDescriptor;
import org.eclipse.wst.validation.internal.delegates.ValidatorDelegatesRegistry;
import org.eclipse.wst.validation.internal.plugin.ValidationPlugin;
import org.osgi.service.prefs.BackingStoreException;
/**
* This class represents the user's preference or project settings.
*
* This class is populated from the multiple persistent properties, and is kept as a session
* property while the resource is open.
*/
public abstract class ValidationConfiguration implements IPropertyChangeListener {
private final IResource _resource;
private boolean disableAllValidation = getDisableAllValidation();
private String _version;
/**
* Map of all validators configured on the project or installed globally. The value of true
* means that the VMD is enabled, and a value of false means that the VMD is disabled.
*/
private Map _validators = new HashMap();
protected Map manualValidators;
protected Map buildValidators;
protected static final String UserPreference = "USER_PREFERENCE"; //$NON-NLS-1$
protected static final String UserBuildPreference = "USER_BUILD_PREFERENCE"; //$NON-NLS-1$
protected static final String UserManualPreference = "USER_MANUAL_PREFERENCE"; //$NON-NLS-1$
protected static final String DelegatesPreference = "DELEGATES_PREFERENCE"; //$NON-NLS-1$
// GRK - I am keeping these "constants" in the off chance that they were used somewhere outside the framework
protected String USER_PREFERENCE = UserPreference;
protected String USER_MANUAL_PREFERENCE = UserManualPreference;
protected String USER_BUILD_PREFERENCE = UserBuildPreference;
protected String DELEGATES_PREFERENCE = DelegatesPreference;
/**
* The key is the target id, that is the id of the place holder validator. The value is the id
* of the real validator.
*/
private Map _delegatesByTarget = new HashMap();
private static final String DefaultValue = "default_value"; //$NON-NLS-1$
public static String getEnabledElementsAsString(Set elements) {
if (elements == null)return null;
StringBuffer buffer = new StringBuffer();
for (ValidatorMetaData vmd : elements) {
buffer.append(vmd.getValidatorUniqueName());
buffer.append(ConfigurationConstants.ELEMENT_SEPARATOR);
}
return buffer.toString();
}
private boolean getDisableAllValidation() {
return false;
}
public static String getEnabledElementsAsString(ValidatorMetaData[] elements) {
StringBuffer buffer = new StringBuffer();
for (ValidatorMetaData vmd : elements) {
buffer.append(vmd.getValidatorUniqueName());
buffer.append(ConfigurationConstants.ELEMENT_SEPARATOR);
}
return buffer.toString();
}
public static Set getStringAsEnabledElements(String elements) {
if (elements == null)return null;
Set result = new HashSet();
StringTokenizer tokenizer = new StringTokenizer(elements, ConfigurationConstants.ELEMENT_SEPARATOR);
while (tokenizer.hasMoreTokens()) {
String elem = tokenizer.nextToken();
ValidatorMetaData vmd = ValidationRegistryReader.getReader().getValidatorMetaData(elem);
if (vmd != null)result.add(vmd);
}
return result;
}
public static ValidatorMetaData[] getStringAsEnabledElementsArray(String elements) {
if (elements == null)return null;
StringTokenizer tokenizer = new StringTokenizer(elements, ConfigurationConstants.ELEMENT_SEPARATOR);
ValidatorMetaData[] result = new ValidatorMetaData[tokenizer.countTokens()];
int count = 0;
while (tokenizer.hasMoreTokens()) {
String elem = tokenizer.nextToken();
ValidatorMetaData vmd = ValidationRegistryReader.getReader().getValidatorMetaData(elem);
if (vmd != null)result[count++] = vmd;
}
if (count != result.length) {
ValidatorMetaData[] trimResult = new ValidatorMetaData[count];
System.arraycopy(result, 0, trimResult, 0, count);
return trimResult;
}
return result;
}
/**
* Answer the validators
* @return
*/
public static Set getValidatorIdsManual(){
PreferencesWrapper prefs = PreferencesWrapper.getPreferences(null, null);
String config = prefs.get(UserManualPreference, null);
return getValidatorIds(config);
}
public static Set getValidatorIdsBuild(){
PreferencesWrapper prefs = PreferencesWrapper.getPreferences(null, null);
String config = prefs.get(UserBuildPreference, null);
return getValidatorIds(config);
}
private static Set getValidatorIds(String elements){
Set set = new HashSet(50);
if (elements != null){
StringTokenizer tokenizer = new StringTokenizer(elements, ConfigurationConstants.ELEMENT_SEPARATOR);
while (tokenizer.hasMoreTokens())set.add(tokenizer.nextToken());
}
return set;
}
public static IWorkspaceRoot getRoot() {
return ResourcesPlugin.getWorkspace().getRoot();
}
protected ValidationConfiguration(IResource resource){
_resource = resource;
}
protected ValidationConfiguration(IResource resource, ValidatorMetaData[] validators) throws InvocationTargetException {
if (resource == null) {
throw new InvocationTargetException(null, ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_EXC_NULLCREATE));
}
_resource = resource;
setValidators(validators);
}
public boolean isDisableAllValidation() throws InvocationTargetException {
return disableAllValidation;
}
public void setDisableAllValidation(boolean allValidation) {
disableAllValidation = allValidation;
}
public ValidatorMetaData[] getEnabledValidators() throws InvocationTargetException {
return getValidators(true);
}
/**
* If "incremental" is true, return the enabled incremental validators. If "incremental" is
* false, return the enabled non-incremental validators.
*/
public ValidatorMetaData[] getEnabledIncrementalValidators(boolean incremental) throws InvocationTargetException {
return getEnabledFullBuildValidators(!incremental);
}
/**
* If "fullBuild" is true, return the enabled validators that support full builds. If
* "fullBuild" is false, return the enabled validators that do not support full builds.
*/
public ValidatorMetaData[] getEnabledFullBuildValidators(boolean fullBuild) throws InvocationTargetException {
return getEnabledFullBuildValidators(fullBuild, false);
}
public ValidatorMetaData[] getEnabledFullBuildValidators(boolean fullBuild, boolean onlyReferenced) throws InvocationTargetException {
int count = 0;
ValidatorMetaData[] result = null;
if( !isDisableAllValidation() ){
Set set = getBuildEnabledValidatorsMap().keySet();
ValidatorMetaData[] temp = new ValidatorMetaData[set.size()];
for (ValidatorMetaData vmd : set) {
Boolean bvalue = getBuildEnabledValidatorsMap().get(vmd);
if (bvalue) {
// If the validator is enabled
if (vmd == null)continue;
if ( vmd.isBuildValidation() ) {
if (!onlyReferenced || vmd.isDependentValidator())
temp[count++] = vmd;
}
}
}
result = new ValidatorMetaData[count];
System.arraycopy(temp, 0, result, 0, count);
}
else {
result = new ValidatorMetaData[0];
}
return result;
}
public void setEnabledValidators(ValidatorMetaData[] vmds) {
// First, "disable" all validators
Map all = getValidatorMetaData();
for (ValidatorMetaData vmd : all.keySet()) {
all.put(vmd, Boolean.FALSE);
}
// Then enable only the validators in the array
if ((vmds == null) || (vmds.length == 0))return;
for (ValidatorMetaData vmd : vmds) {
all.put(vmd, Boolean.TRUE);
}
}
public void setEnabledManualValidators(ValidatorMetaData[] vmds) throws InvocationTargetException {
Set manualEnabledVMDs = new HashSet(vmds.length);
for (ValidatorMetaData vmd : vmds)manualEnabledVMDs.add(vmd);
for(ValidatorMetaData data : getValidators()) {
if(manualEnabledVMDs.contains(data))
getManualEnabledValidatorsMap().put(data, Boolean.TRUE);
else
getManualEnabledValidatorsMap().put(data, Boolean.FALSE);
}
}
/**
* Update the list of validators that have been enabled for manual validation.
*
* @param vmds the validators that are enabled for manual validation.
* @throws InvocationTargetException
*/
public void setEnabledManualValidators(Set vmds) throws InvocationTargetException {
for(ValidatorMetaData data : getValidators()) {
if(vmds.contains(data))getManualEnabledValidatorsMap().put(data, Boolean.TRUE);
else getManualEnabledValidatorsMap().put(data, Boolean.FALSE);
}
}
public void setEnabledBuildValidators(ValidatorMetaData[] vmds) throws InvocationTargetException {
Set buildEnabledVMDs = new HashSet(vmds.length);
for (ValidatorMetaData vmd : vmds)buildEnabledVMDs.add(vmd);
for(ValidatorMetaData data : getValidators()) {
if(buildEnabledVMDs.contains(data))
getBuildEnabledValidatorsMap().put(data, Boolean.TRUE);
else
getBuildEnabledValidatorsMap().put(data, Boolean.FALSE);
}
}
/**
* Update the list of validators that have been enabled for build validation.
*
* @param vmds the validators that are enabled for build validation.
* @throws InvocationTargetException
*/
public void setEnabledBuildValidators(Set vmds) throws InvocationTargetException {
for(ValidatorMetaData data : getValidators()) {
if(vmds.contains(data))getBuildEnabledValidatorsMap().put(data, Boolean.TRUE);
else getBuildEnabledValidatorsMap().put(data, Boolean.FALSE);
}
}
private Map getValidatorMetaData() {
return _validators;
}
public ValidatorMetaData[] getDisabledValidators() throws InvocationTargetException {
return getValidators(false);
}
/**
* Return an array of ValidatorMetaData - if value is false, return the disabled validators; if
* value is true, return the enabled validators.
*/
private ValidatorMetaData[] getValidators(boolean value) throws InvocationTargetException {
ValidatorMetaData[] temp = new ValidatorMetaData[numberOfValidators()];
int count = 0;
for (ValidatorMetaData vmd : getValidatorMetaData().keySet()) {
Boolean bvalue = getValidatorMetaData().get(vmd);
if (bvalue.booleanValue() == value) {
temp[count++] = vmd;
}
}
ValidatorMetaData[] result = new ValidatorMetaData[count];
System.arraycopy(temp, 0, result, 0, count);
return result;
}
public ValidatorMetaData[] getManualEnabledValidators() throws InvocationTargetException {
Map map = getManualEnabledValidatorsMap();
if (!map.isEmpty()) {
List list = new LinkedList();
for (Map.Entry me : map.entrySet()) {
Boolean obj = me.getValue();
if (obj != null && obj)list.add(me.getKey());
}
return (ValidatorMetaData[]) list.toArray(new ValidatorMetaData[list.size()]);
}
return getEnabledValidators();
}
public ValidatorMetaData[] getBuildEnabledValidators() throws InvocationTargetException {
Map map = getBuildEnabledValidatorsMap();
List list = new LinkedList();
if (!map.isEmpty()) {
for (Map.Entry me : map.entrySet()) {
Boolean obj = me.getValue();
if (obj != null && obj)list.add(me.getKey());
}
return (ValidatorMetaData[]) list.toArray(new ValidatorMetaData[list.size()]);
}
return getEnabledValidators();
}
/**
* Answer the map of the validators that have been enabled for build validation,
* creating it if necessary.
*/
protected Map getBuildEnabledValidatorsMap() {
if(buildValidators == null)buildValidators = new HashMap();
return buildValidators;
}
/**
* Answer the map of the validators that have been enabled for manual validation,
* creating it if necessary.
*/
protected Map getManualEnabledValidatorsMap() {
if(manualValidators == null)manualValidators = new HashMap();
return manualValidators;
}
/**
* Return all incremental validators for this preference; either every installed validator
* (global) or every validator configured on the project (project).
*/
public ValidatorMetaData[] getIncrementalValidators() throws InvocationTargetException {
ValidatorMetaData[] temp = new ValidatorMetaData[numberOfValidators()];
int count = 0;
for (ValidatorMetaData vmd : getValidatorMetaData().keySet()) {
Boolean bvalue = getValidatorMetaData().get(vmd);
if (bvalue && vmd.isIncremental())temp[count++] = vmd;
}
ValidatorMetaData[] result = new ValidatorMetaData[count];
System.arraycopy(temp, 0, result, 0, count);
return result;
}
/**
* Return all validators for this preference; either every installed validator (global) or every
* validator configured on the project (project).
*/
public ValidatorMetaData[] getValidators() throws InvocationTargetException {
return convertToArray(_validators.keySet());
}
public void setValidators(ValidatorMetaData[] vmds) {
_validators.clear();
for (ValidatorMetaData vmd : vmds) {
if (vmd == null)continue;
_validators.put(vmd, (vmd.isEnabledByDefault() ? Boolean.TRUE : Boolean.FALSE));
}
}
public void setDefaultDelegates(ValidatorMetaData[] vmds) throws InvocationTargetException {
_delegatesByTarget.clear();
for (ValidatorMetaData vmd : vmds) {
if (vmd == null)continue;
String targetID = vmd.getValidatorUniqueName();
String delegateID = ValidatorDelegatesRegistry.getInstance().getDefaultDelegate(targetID);
if (delegateID == null)continue;
_delegatesByTarget.put(targetID, ValidatorDelegatesRegistry.getInstance().getDefaultDelegate(targetID));
}
}
/**
* Returns the number of configured validators on the given project or installed validators in
* the workspace.
*/
public int numberOfValidators() throws InvocationTargetException {
return _validators.size();
}
public int numberOfEnabledIncrementalValidators() throws InvocationTargetException {
return numberOfIncrementalValidators(getEnabledValidators());
}
public int numberOfIncrementalValidators() throws InvocationTargetException {
return numberOfIncrementalValidators(getValidators());
}
private static int numberOfIncrementalValidators(ValidatorMetaData[] vmds) {
int count = 0;
for (ValidatorMetaData vmd : vmds) {
if (vmd.isIncremental())count++;
}
return count;
}
/**
* Returns the number of enabled validators on the project or workspace.
*/
public int numberOfEnabledValidators() throws InvocationTargetException {
return getEnabledValidators().length;
}
/**
* Returns the number of disabled validators on the project or workspace.
*/
public int numberOfDisabledValidators() throws InvocationTargetException {
return getDisabledValidators().length;
}
/**
* The value returned from this method is guaranteed to be non-null.
*/
public final String getVersion() throws InvocationTargetException {
if (_version == null)loadVersion();
return _version;
}
private void setVersion(String version) {
_version = version;
}
/**
* This preference has been migrated; change the version to the current version.
* @deprecated dead code.
*/
public void markVersionCurrent() {
// The version should not be marked current until the migration is complete
// (i.e., ValidationMigrator has been invoked.) Migrating the user's configuration
// is only the first step of the migration.
setVersion(ConfigurationConstants.CURRENT_VERSION);
}
public boolean isVersionCurrent() throws InvocationTargetException {
return getVersion().equals(ConfigurationConstants.CURRENT_VERSION);
}
// IResource could be an IProject or an IWorkspaceRoot
public IResource getResource() {
return _resource;
}
/**
* Return true if the validator is enabled on this preference.
*/
public boolean isEnabled(String validatorClassName) throws InvocationTargetException {
if (validatorClassName == null) {
return false;
}
ValidatorMetaData vmd = ValidationRegistryReader.getReader().getValidatorMetaData(validatorClassName);
return isEnabled(vmd);
}
/**
* Return true if the validator is enabled on this preference.
*/
public boolean isEnabled(ValidatorMetaData vmd) throws InvocationTargetException {
if (vmd == null)return false;
Boolean value = getValidatorMetaData().get(vmd);
if (value == null)return false;
return value.booleanValue();
}
/**
* Once all of the fields have been updated on this ValidationConfiguration instance, this
* preference should be stored back on the IResource for later use. This method must be called
* manually by the validation framework once the fields of this type have been updated.
*/
public final void passivate() throws InvocationTargetException {
try {
if (getResource() == null) {
throw new InvocationTargetException(null, ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_EXC_NULLSAVE));
}
getResource().setSessionProperty(ConfigurationConstants.USER_PREFERENCE, this);
} catch (CoreException exc) {
throw new InvocationTargetException(exc, ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_EXC_SAVE, new String[]{getResource().getName()}));
}
}
/**
* Reset the values to the default values.
*/
public abstract void resetToDefault() throws InvocationTargetException;
protected Boolean convertToBoolean(boolean value) {
return (value == true ? Boolean.TRUE : Boolean.FALSE);
}
protected Integer convertToInteger(int value) {
return new Integer(value);
}
protected boolean convertToBoolean(String value) {
Boolean b = Boolean.valueOf(value);
return b.booleanValue();
}
protected int convertToInt(String value) {
Integer t = Integer.valueOf(value);
return t.intValue();
}
public static ValidatorMetaData[] convertToArray(Collection c) {
int length = (c == null) ? 0 : c.size();
ValidatorMetaData[] result = new ValidatorMetaData[length];
if (length == 0)return result;
int count = 0;
for (ValidatorMetaData vmd : c)result[count++] = vmd;
return result;
}
public static ValidatorMetaData[] convertToArray(Object[] c) {
int length = (c == null) ? 0 : c.length;
ValidatorMetaData[] result = new ValidatorMetaData[length];
if (length == 0)return result;
System.arraycopy(c, 0, result, 0, length);
return result;
}
/**
* Save the values of these fields before the project or workspace is closed.
*/
public void store() throws InvocationTargetException {
store(null);
}
/**
* Save the values of these fields before the project or workspace is closed.
*/
public void store(Boolean persist) throws InvocationTargetException {
PreferencesWrapper pref = PreferencesWrapper.getPreferences(null, persist);
pref.put(ValidationConfiguration.UserPreference, serialize());
pref.put(ValidationConfiguration.UserManualPreference, serializeManualSetting());
pref.put(ValidationConfiguration.UserBuildPreference, serializeBuildSetting());
pref.put(ValidationConfiguration.DelegatesPreference, serializeDelegatesSetting());
try {
pref.flush();
}
catch (BackingStoreException e){
throw new InvocationTargetException(e);
}
}
/**
* Load and store the version number, but nothing else. The version isn't a preference, but it's
* stored and loaded as if it is. Because the load mechanism is different between an IProject
* and the IWorkspaceRoot, keep the load mechanism inside the ValidationConfiguration
* implementation, but initialize only the minimum at first. After the project has been
* migrated, load the other fields (loading the other fields before the migration may overwrite
* the values of those fields).
*/
protected final void loadVersion() throws InvocationTargetException {
if (getResource() == null) {
throw new InvocationTargetException(null, ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_EXC_NULLRETRIEVE));
}
IMarker[] marker = getMarker();
String version = null;
if (marker == null) {
// either a new workspace or already migrated; proceed as normal
version = loadVersion(getResource());
} else {
// migrate
version = loadVersion(marker);
}
setVersion(version);
}
protected final String loadVersion(IMarker[] marker) throws InvocationTargetException {
String version = (String) getValue(marker[0], ConfigurationConstants.VERSION);
if (version == null) return ConfigurationConstants.VERSION4_03;
return version;
}
protected final String loadVersion(IResource resource) throws InvocationTargetException {
try {
// This method will be called in one of two situations:
// 1. This is a new workspace and no preferences exist.
// 2. This is a migrated workspace and the old preferences have already been created as
// persistent properties.
String storedConfiguration = resource.getPersistentProperty(ConfigurationConstants.USER_PREFERENCE);
String version = null;
if (storedConfiguration == null) {
version = getVersionDefault();
} else {
int versionIndex = storedConfiguration.indexOf(ConfigurationConstants.VERSION);
if (versionIndex != -1)
version = storedConfiguration.substring(versionIndex + ConfigurationConstants.VERSION.length());
}
if (version == null) {
return getVersionDefault();
}
return version;
} catch (CoreException exc) {
throw new InvocationTargetException(exc, ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_EXC_RETRIEVE, new String[]{getResource().getName()}));
}
}
/**
* Load the values of these fields when the project or workspace is opened.
*/
protected final void load() throws InvocationTargetException {
try {
if (getResource() == null) {
throw new InvocationTargetException(null, ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_EXC_NULLRETRIEVE));
}
IMarker[] marker = getMarker();
if (marker == null) {
// either a new workspace or already migrated; proceed as normal
loadPreference();
} else {
// migrate
load(marker);
}
} catch (InvocationTargetException exc) {
throw exc;
} catch (Exception exc) {
String resourceName = (getResource() == null) ? "null" : getResource().getName(); //$NON-NLS-1$
throw new InvocationTargetException(exc, ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_EXC_RETRIEVE, new String[]{resourceName}));
}
}
/**
* Return the IMarker that used to store the preference information, if the marker exists. (If
* it doesn't exist, then it's already been migrated.)
*/
protected abstract IMarker[] getMarker();
protected abstract void load(IMarker[] marker) throws InvocationTargetException;
protected Object getValue(IMarker marker, String attribName) {
if (marker == null)return null;
try {
return marker.getAttribute(attribName);
} catch (CoreException e) {
ValidationPlugin.getPlugin().handleException(e);
return null;
}
}
protected boolean getValue(IMarker marker, String attribName, boolean defaultValue) {
Boolean bool = (Boolean) getValue(marker, attribName);
if (bool == null)return defaultValue;
return bool.booleanValue();
}
protected int getValue(IMarker marker, String attribName, int defaultValue) {
Integer integer = (Integer) getValue(marker, attribName);
if (integer == null)return defaultValue;
return integer.intValue();
}
protected String getValue(IMarker marker, String attribName, String defaultValue) {
String string = (String) getValue(marker, attribName);
if (string == null)return defaultValue;
return string;
}
protected void loadPreference() throws InvocationTargetException {
// This method will be called in one of two situations:
// 1. This is a new workspace and no preferences exist.
// 2. This is a migrated workspace and the old preferences have already been created as
// persistent properties.
PreferencesWrapper prefs = PreferencesWrapper.getPreferences(null, null);
deserializeAllPrefs(prefs);
}
/**
* @param prefs
* @throws InvocationTargetException
*/
private void deserializeAllPrefs(PreferencesWrapper prefs) throws InvocationTargetException {
String storedConfig = prefs.get(ValidationConfiguration.UserPreference, null);
deserialize(storedConfig);
String storedManualConfig = prefs.get(ValidationConfiguration.UserManualPreference, null);
deserializeManual(storedManualConfig);
String storedBuildConfig = prefs.get(ValidationConfiguration.UserBuildPreference, null);
deserializeBuild(storedBuildConfig);
String storedDelegatesConfiguration = prefs.get(ValidationConfiguration.DelegatesPreference, null);
deserializeDelegates(storedDelegatesConfiguration);
}
public void propertyChange(PropertyChangeEvent event) {
Preferences prefs = (Preferences) event.getSource();
if (prefs != null && !event.getOldValue().equals(event.getNewValue())) {
try {
deserializeAllPrefs(event);
passivate();
} catch (InvocationTargetException e) {
ValidationPlugin.getPlugin().handleException(e);
}
}
}
private void deserializeAllPrefs(PropertyChangeEvent event) throws InvocationTargetException {
String storedConfig = (String)event.getNewValue();
if( event.getProperty().equals(ValidationConfiguration.UserPreference) ){
deserialize(storedConfig);
}else if(event.getProperty().equals(ValidationConfiguration.UserManualPreference)){
deserializeManual(storedConfig);
}else if(event.getProperty().equals(ValidationConfiguration.UserBuildPreference)){
deserializeBuild(storedConfig);
}else if(event.getProperty().equals(ValidationConfiguration.DelegatesPreference)){
deserializeDelegates(storedConfig);
}
}
protected void deserializeBuild(String storedConfiguration) throws InvocationTargetException {
if (storedConfiguration == null || storedConfiguration.length() == 0 || storedConfiguration.equals(DefaultValue)) {
// Assume that the configuration has never been set (new workspace).
resetToDefault();
return;
}
int buildValidationIndex = storedConfiguration.indexOf(ConfigurationConstants.ENABLED_BUILD_VALIDATORS);
String manualValidation = storedConfiguration.substring(buildValidationIndex + ConfigurationConstants.ENABLED_BUILD_VALIDATORS.length(),storedConfiguration.length());
setEnabledBuildValidators(getStringAsEnabledElementsArray(manualValidation));
}
protected void deserializeManual(String storedConfiguration) throws InvocationTargetException {
if (storedConfiguration == null || storedConfiguration.length() == 0 || storedConfiguration.equals(DefaultValue)) {
// Assume that the configuration has never been set (new workspace).
resetToDefault();
return;
}
int manualValidationIndex = storedConfiguration.indexOf(ConfigurationConstants.ENABLED_MANUAL_VALIDATORS);
String manualValidation = storedConfiguration.substring(manualValidationIndex + ConfigurationConstants.ENABLED_MANUAL_VALIDATORS.length(),storedConfiguration.length());
setEnabledManualValidators(getStringAsEnabledElementsArray(manualValidation));
}
protected void deserializeDelegates(String storedConfiguration) throws InvocationTargetException {
if (storedConfiguration == null || storedConfiguration.length() == 0 || storedConfiguration.equals(DefaultValue)) {
// Assume that the configuration has never been set (new workspace).
resetToDefault();
return;
}
int delegatesIndex = storedConfiguration.indexOf(ConfigurationConstants.DELEGATE_VALIDATORS);
String delegates = storedConfiguration.substring(delegatesIndex + ConfigurationConstants.DELEGATE_VALIDATORS.length(),storedConfiguration.length());
if (delegates == null) {
return;
}
StringTokenizer tokenizer = new StringTokenizer(delegates, ConfigurationConstants.ELEMENT_SEPARATOR);
while (tokenizer.hasMoreTokens()) {
String delegateConfiguration = tokenizer.nextToken();
int separatorIndex = delegateConfiguration.indexOf(ConfigurationConstants.DELEGATES_SEPARATOR);
String targetID = delegateConfiguration.substring(0, separatorIndex);
String delegateID = delegateConfiguration.substring(separatorIndex + 1);
_delegatesByTarget.put(targetID, delegateID);
}
}
protected void copyTo(ValidationConfiguration up) throws InvocationTargetException {
up.setVersion(getVersion());
up.setValidators(getValidators());
up.setDisableAllValidation(isDisableAllValidation());
up.setEnabledValidators(getEnabledValidators());
up.setEnabledManualValidators(getManualEnabledValidators());
up.setEnabledBuildValidators(getBuildEnabledValidators());
up.setDelegatingValidators(getDelegatingValidators());
}
/**
* The key is the id of the place holder validator, and the value is the id of validator
* that will perform the validation.
*/
public Map getDelegatingValidators() throws InvocationTargetException {
return _delegatesByTarget;
}
public void setDelegatingValidators(Map source)
{
// It is safe to copy this map as it contains only immutable strings.
_delegatesByTarget.putAll(source);
}
/**
* Return true if the enabled validators have not changed since this ValidationConfiguration was
* constructed, false otherwise. (This method is needed for the Properties and Preference pages;
* if the list of validators hasn't changed, then there is no need to update the task list;
* updating the task list is a costly operation.)
*/
protected boolean hasEnabledValidatorsChanged(ValidatorMetaData[] oldEnabledVmd) throws InvocationTargetException {
// First check the obvious: is every enabled validator still enabled, and is
// the number of enabled validators the same as it was before? If not, return true.
if (oldEnabledVmd == null) {
// Something's gone wrong...
return true;
}
for (int i = 0; i < oldEnabledVmd.length; i++) {
ValidatorMetaData vmd = oldEnabledVmd[i];
if (!isEnabled(vmd)) {
return true;
}
}
// Everything that was enabled is still enabled; have any additional
// validators been enabled?
if (numberOfEnabledValidators() != oldEnabledVmd.length) {
return true;
}
return false;
}
/**
* Determines if there has been a change in the list of delegate validators.
* @param oldDelegates a Map with the old delegates ID by target ID.
* @return true if there has been a change, false otherwise.
* @throws InvocationTargetException
*/
protected boolean haveDelegatesChanged(Map oldDelegates) throws InvocationTargetException {
if (oldDelegates == null)return true;
for (String targetID : oldDelegates.keySet()) {
String oldDelegateID = oldDelegates.get(targetID);
String newDelegateID = _delegatesByTarget.get(targetID);
if (oldDelegateID == null || newDelegateID == null)return true;
if (!newDelegateID.equals(oldDelegateID))return true;
}
if (oldDelegates.size() != _delegatesByTarget.size())return true;
return false;
}
protected String serialize() throws InvocationTargetException {
StringBuffer buffer = new StringBuffer();
buffer.append(ConfigurationConstants.DISABLE_ALL_VALIDATION_SETTING);
buffer.append(String.valueOf(isDisableAllValidation()));
buffer.append(ConfigurationConstants.VERSION);
buffer.append(getVersion());
return buffer.toString();
}
protected String serializeManualSetting() throws InvocationTargetException {
StringBuffer buffer = new StringBuffer();
buffer.append(ConfigurationConstants.ENABLED_MANUAL_VALIDATORS);
buffer.append(getEnabledElementsAsString(getManualEnabledValidators()));
return buffer.toString();
}
protected String serializeBuildSetting() throws InvocationTargetException {
StringBuffer buffer = new StringBuffer();
buffer.append(ConfigurationConstants.ENABLED_BUILD_VALIDATORS);
buffer.append(getEnabledElementsAsString(getBuildEnabledValidators()));
return buffer.toString();
}
protected String serializeDelegatesSetting() throws InvocationTargetException {
StringBuffer buffer = new StringBuffer();
buffer.append(ConfigurationConstants.DELEGATE_VALIDATORS);
buffer.append(getDelegatesAsString(getValidatorMetaData()));
return buffer.toString();
}
/**
* Provides a String which contains pairs of targetID=delegateID separated by a semicolon.
* @param validatorMetaData a Map with the currently configured validators.
* @return a String.
*/
private String getDelegatesAsString(Map validatorMetaData) {
StringBuffer buffer = new StringBuffer();
for (ValidatorMetaData vmd : validatorMetaData.keySet()) {
String targetID = vmd.getValidatorUniqueName();
String delegateID = getDelegateUniqueName(vmd);
if (delegateID == null)continue;
// Write out pairs targetID=delegateID
buffer.append(targetID);
buffer.append(ConfigurationConstants.DELEGATES_SEPARATOR);
buffer.append(delegateID);
buffer.append(ConfigurationConstants.ELEMENT_SEPARATOR);
}
return buffer.toString();
}
/**
* Provides the delegate's ID of the validator delegate configured in this configuration for
* a given delegating validator. That is answer the id of validator that is going to do the real work.
*
* @param vmd the delegating validator's meta data. Must not be null.
* @return a String with the id of the validator delegate, null if there isn't one.
*/
public String getDelegateUniqueName(ValidatorMetaData vmd) {
String targetID = vmd.getValidatorUniqueName();
return _delegatesByTarget.get(targetID);
}
/**
* Provides the delegate's ID of the validator delegate configured in this configuration for
* a given delegating validator. That is answer the id of validator that is going to do the real work.
*
* @param targetId the id of the target (or place holder) validator. Must not be null.
* @return a String with the id of the validator delegate, null if there isn't one.
*/
public String getDelegateForTarget(String targetId){
return _delegatesByTarget.get(targetId);
}
/**
* Sets the delegate's ID of the validator delegate to be used in this configuration for the
* given delegating validator.
*
* @param vmd the delegating validator's metadata. Must not be null.
* @param delegateID a String with the unique name (ID) of the validator delegate. Must not be null.
*/
public void setDelegateUniqueName(ValidatorMetaData vmd, String delegateID) {
String targetID = vmd.getValidatorUniqueName();
_delegatesByTarget.put(targetID, delegateID);
}
/**
* Deserialize everything except the version number; the version is deserialized first, in the
* loadVersion() method.
*/
protected void deserialize(String storedConfiguration) throws InvocationTargetException {
if (storedConfiguration == null || storedConfiguration.length() == 0 || storedConfiguration.equals(DefaultValue)) {
// Assume that the configuration has never been set (new workspace).
resetToDefault();
return;
}
int disableAllValidationIndex = storedConfiguration.indexOf(ConfigurationConstants.DISABLE_ALL_VALIDATION_SETTING);
int versionIndex = storedConfiguration.indexOf(ConfigurationConstants.VERSION);
if(disableAllValidationIndex != -1) {
String disableAllValidation = storedConfiguration.substring(disableAllValidationIndex + ConfigurationConstants.DISABLE_ALL_VALIDATION_SETTING.length(),versionIndex);
setDisableAllValidation(Boolean.valueOf(disableAllValidation).booleanValue());
} else {
setDisableAllValidation(false);
}
}
public static boolean getDisableValidationDefault() {
return ConfigurationConstants.DEFAULT_DISABLE_VALIDATION_SETTING;
}
public static ValidatorMetaData[] getEnabledValidatorsDefault() {
return ConfigurationConstants.DEFAULT_ENABLED_VALIDATORS;
}
public static int getMaximumNumberOfMessagesDefault() {
return ConfigurationConstants.DEFAULT_MAXNUMMESSAGES;
}
public static String getVersionDefault() {
// If the version can't be retrieved, assume that it's a new workspace. (A null version
// could also mean a 4.03 workspace, but that's taken care of in the load(IMarker[])
// method.)
return ConfigurationConstants.CURRENT_VERSION;
}
public boolean isManualEnabled(ValidatorMetaData vmd) {
if (vmd == null)return false;
Boolean value = getManualEnabledValidatorsMap().get(vmd);
if (value == null)return false;
return value;
}
public boolean isBuildEnabled(ValidatorMetaData vmd) {
if (vmd == null)return false;
Boolean value = getBuildEnabledValidatorsMap().get(vmd);
if (value == null)return false;
return value;
}
public int numberOfManualEnabledValidators() throws InvocationTargetException {
return getManualEnabledValidators().length;
}
public void enableSingleValidator(ValidatorMetaData vmd){
getValidatorMetaData().put(vmd, Boolean.TRUE);
}
public void disableSingleValidator(ValidatorMetaData vmd){
getValidatorMetaData().put(vmd, Boolean.FALSE);
}
public void enableSingleManualValidator(ValidatorMetaData vmd){
getManualEnabledValidatorsMap().put(vmd, Boolean.TRUE);
}
public void disableSingleManualValidator(ValidatorMetaData vmd){
getManualEnabledValidatorsMap().put(vmd, Boolean.FALSE);
}
public void enableSingleBuildValidator(ValidatorMetaData vmd){
getBuildEnabledValidatorsMap().put(vmd, Boolean.TRUE);
}
public void disableSingleBuildValidator(ValidatorMetaData vmd){
getBuildEnabledValidatorsMap().put(vmd, Boolean.FALSE);
}
/**
* Provides the delegate validator descriptor of the validator delegate configured
* for the given delegating validator in the context of this configuration.
* @param vmd the delegating validator's meta data. Must not be null.
* @return a ValidatorDelegateDescriptor for the given delegating validator.
*/
public ValidatorDelegateDescriptor getDelegateDescriptor(ValidatorMetaData vmd) throws InvocationTargetException {
String targetID = vmd.getValidatorUniqueName();
String delegateID = getDelegateUniqueName(vmd);
ValidatorDelegateDescriptor descriptor = ValidatorDelegatesRegistry.getInstance().getDescriptor(targetID, delegateID);
return descriptor;
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy