org.eclipse.wst.validation.internal.ProjectConfiguration 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.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.StringTokenizer;
import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.wst.validation.internal.delegates.ValidatorDelegateDescriptor;
import org.eclipse.wst.validation.internal.plugin.ValidationPlugin;
import org.osgi.service.prefs.BackingStoreException;
/**
* This class represents the Project Preferences as set on the Project's Validation Properties page.
*/
public class ProjectConfiguration extends ValidationConfiguration {
/** false - If the user has never set a preference before, this is the override default */
static final boolean PRJ_OVERRIDEGLOBAL_DEFAULT = false;
/** default_value - the configuration is using the defaults. */
private static final String DefaultValue = "default_value"; //$NON-NLS-1$
private boolean _doesProjectOverride = getDoesProjectOverrideDefault();
/**
* This constructor should be used in all cases except for the Properties page's values.
*/
protected ProjectConfiguration(IProject project) throws InvocationTargetException {
// The extractProjectValidators method extracts just this project's validators from the
// global list.
super(project, extractProjectValidators(convertToArray(ValidationRegistryReader.getReader().getAllValidators()), project));
// Can't put the call to load() and passivate() in the ValidationConfiguration constructor due
// to the order of initialization.
// 1. First the ValidationConfiguration constructor is called, and that loads the stored values.
// 2. Then this class's method is called, and that initializes the "override" field
// to the default, which may be different than the stored value.
}
/**
* This constructor is provided only for the Properties page, so that the page can store values
* without persisting them (i.e., if the user presses Cancel then nothing needs to be done.)
*
* @deprecated
*/
public ProjectConfiguration(ProjectConfiguration original) throws InvocationTargetException {
super(original.getResource());
original.copyTo(this);
}
/**
* Return the ValidationConfiguration to use, whether global or project.
*/
public boolean useGlobalPreference() {
try {
GlobalConfiguration gp = ConfigurationManager.getManager().getGlobalConfiguration();
if (gp == null) {
return false;
}
if (!gp.canProjectsOverride()) {
// If project's can't override the global, use the global
return true;
}
// If the project overrides, then don't use the global.
// If the project does not override, use the global.
return !_doesProjectOverride;
} catch (InvocationTargetException e) {
ValidationPlugin.getPlugin().handleException(e);
return false;
}
}
public boolean getDoesProjectOverride(){
return _doesProjectOverride;
}
public boolean doesProjectOverride() {
// If the global preference doesn't allow projects to override, it doesn't matter what the
// value of _doesProjectOverride is.
return !useGlobalPreference();
}
public void setDoesProjectOverride(boolean does) {
_doesProjectOverride = does;
}
/**
* If the preferences should be used then the preference settings are returned; otherwise return
* the project settings.
*/
public ValidatorMetaData[] getEnabledValidators() throws InvocationTargetException {
if (useGlobalPreference()) {
return extractProjectValidators(ConfigurationManager.getManager().getGlobalConfiguration().getEnabledValidators(), getResource());
}
return super.getEnabledValidators();
}
public ValidatorMetaData[] getManualEnabledValidators() throws InvocationTargetException {
if (useGlobalPreference()) {
return extractProjectValidators(ConfigurationManager.getManager().getGlobalConfiguration().getManualEnabledValidators(), getResource());
}
return super.getManualEnabledValidators();
}
public ValidatorMetaData[] getBuildEnabledValidators() throws InvocationTargetException {
if (useGlobalPreference()) {
return extractProjectValidators(ConfigurationManager.getManager().getGlobalConfiguration().getBuildEnabledValidators(), getResource());
}
return super.getBuildEnabledValidators();
}
/**
* @see org.eclipse.wst.validation.internal.operations.internal.preference.ValidationConfiguration#getDisabledValidators()
*/
public ValidatorMetaData[] getDisabledValidators() throws InvocationTargetException {
if (useGlobalPreference()) {
return extractProjectValidators(ConfigurationManager.getManager().getGlobalConfiguration().getDisabledValidators(), getResource());
}
return super.getDisabledValidators();
}
/**
* @see org.eclipse.wst.validation.internal.operations.internal.preference.ValidationConfiguration#getValidators()
*/
public ValidatorMetaData[] getValidators() throws InvocationTargetException {
if (useGlobalPreference()) {
return extractProjectValidators(ConfigurationManager.getManager().getGlobalConfiguration().getValidators(), getResource());
}
return super.getValidators();
}
public Map getDelegatingValidators() throws InvocationTargetException {
if (useGlobalPreference()) {
return ConfigurationManager.getManager().getGlobalConfiguration().getDelegatingValidators();
}
return super.getDelegatingValidators();
}
/**
* @see org.eclipse.wst.validation.internal.operations.internal.attribute.ValidationConfiguration#getEnabledIncrementalValidators(boolean)
*/
public ValidatorMetaData[] getEnabledIncrementalValidators(boolean incremental) throws InvocationTargetException {
if (useGlobalPreference()) {
return extractProjectValidators(ConfigurationManager.getManager().getGlobalConfiguration().getEnabledIncrementalValidators(incremental), getResource());
}
return super.getEnabledIncrementalValidators(incremental);
}
/**
* @see org.eclipse.wst.validation.internal.operations.internal.preference.ValidationConfiguration#isEnabled(ValidatorMetaData)
*/
public boolean isEnabled(ValidatorMetaData vmd) throws InvocationTargetException {
if (useGlobalPreference()) {
return ConfigurationManager.getManager().getGlobalConfiguration().isEnabled(vmd);
}
return super.isEnabled(vmd);
}
/**
* @see org.eclipse.wst.validation.internal.operations.internal.preference.ValidationConfiguration#numberOfDisabledValidators()
*/
public int numberOfDisabledValidators() throws InvocationTargetException {
if (useGlobalPreference()) {
return ConfigurationManager.getManager().getGlobalConfiguration().numberOfDisabledValidators();
}
return super.numberOfDisabledValidators();
}
/**
* @see org.eclipse.wst.validation.internal.operations.internal.preference.ValidationConfiguration#numberOfEnabledIncrementalValidators()
*/
public int numberOfEnabledIncrementalValidators() throws InvocationTargetException {
if (useGlobalPreference()) {
return ConfigurationManager.getManager().getGlobalConfiguration().numberOfEnabledIncrementalValidators();
}
return super.numberOfEnabledIncrementalValidators();
}
/**
* @see org.eclipse.wst.validation.internal.operations.internal.preference.ValidationConfiguration#numberOfEnabledValidators()
*/
public int numberOfEnabledValidators() throws InvocationTargetException {
if (useGlobalPreference()) {
return ConfigurationManager.getManager().getGlobalConfiguration().numberOfEnabledValidators();
}
return super.numberOfEnabledValidators();
}
/**
* @see org.eclipse.wst.validation.internal.operations.internal.preference.ValidationConfiguration#numberOfIncrementalValidators()
*/
public int numberOfIncrementalValidators() throws InvocationTargetException {
if (useGlobalPreference()) {
return ConfigurationManager.getManager().getGlobalConfiguration().numberOfIncrementalValidators();
}
return super.numberOfIncrementalValidators();
}
/**
* @see org.eclipse.wst.validation.internal.operations.internal.preference.ValidationConfiguration#numberOfValidators()
*/
public int numberOfValidators() throws InvocationTargetException {
if (useGlobalPreference()) {
return ConfigurationManager.getManager().getGlobalConfiguration().numberOfValidators();
}
return super.numberOfValidators();
}
/**
* This method could be called with the project's values, or with the global preference values.
* Validators that are not configured on this project will be ignored.
*/
public void setEnabledValidators(ValidatorMetaData[] vmds) {
super.setEnabledValidators(extractProjectValidators(vmds, getResource()));
}
/**
* This method could be called with the project's values, or with the global preference values.
* Validators that are not configured on this project will be ignored.
*/
public void setValidators(ValidatorMetaData[] vmds) {
super.setValidators(extractProjectValidators(vmds, getResource()));
}
/**
* Given a set of validators, usually the global preference set, change the set so that it
* contains only the validators configured on this project.
*/
private static ValidatorMetaData[] extractProjectValidators(ValidatorMetaData[] vmds, IResource resource) {
ValidationRegistryReader reader = ValidationRegistryReader.getReader();
int length = (vmds == null) ? 0 : vmds.length;
ValidatorMetaData[] temp = new ValidatorMetaData[length];
if (length == 0) {
return temp;
}
int count = 0;
IProject project = (IProject) resource;
for (int i = 0; i < vmds.length; i++) {
ValidatorMetaData vmd = vmds[i];
if (reader.isConfiguredOnProject(vmd, project)) {
temp[count++] = vmd;
}
}
ValidatorMetaData[] result = new ValidatorMetaData[count];
System.arraycopy(temp, 0, result, 0, count);
temp = null;
return result;
}
public void resetToDefault() throws InvocationTargetException {
// The default values of the project is whatever the preference values are
GlobalConfiguration gp = ConfigurationManager.getManager().getGlobalConfiguration();
setEnabledManualValidators(gp.getManualEnabledValidators());
setEnabledBuildValidators(gp.getBuildEnabledValidators());
setDelegatingValidators(gp.getDelegatingValidators());
// except for this field, which is unique to the project preferences
setDoesProjectOverride(getDoesProjectOverrideDefault());
}
public void resetToDefaultForProjectDescriptionChange() throws InvocationTargetException {
// The default values of the project is whatever the preference values are
GlobalConfiguration gp = ConfigurationManager.getManager().getGlobalConfiguration();
setEnabledManualValidators(gp.getManualEnabledValidators());
setEnabledBuildValidators(gp.getBuildEnabledValidators());
setDelegatingValidators(gp.getDelegatingValidators());
}
/**
* The project's nature has changed, so recalculate the validators that are configured on the
* project, and reset the values of the project to the default.
*
* @deprecated this method doesn't do anything
*/
public void resetProjectNature() {
/*
* We do not want to perform the resetting the of the validators as the nature never gets
* reset due to change in the project references - VKB GlobalConfiguration gp =
* ConfigurationManager.getManager().getGlobalConfiguration();
* setValidators(gp.getValidators()); // Reset the validators that are configured on the
* project (the ProjectConfiguration automatically saves only the validators that are
* configured on the project). resetToDefault(); // Given that the project is "new", reset
* its values to the Preferences.
*/
}
/**
* This method exists only for migration purposes. The project marker must be deleted after
* migration is complete.
*/
protected IMarker[] getMarker() {
try {
// First try to find the 4.03 project marker.
IMarker[] allMarkers = getResource().findMarkers(ConfigurationConstants.PRJ_MARKER_403, false, IResource.DEPTH_ZERO);
// If it doesn't exist, then this might be a 5.0 project marker.
if ((allMarkers == null) || (allMarkers.length == 0)) {
allMarkers = getResource().findMarkers(ConfigurationConstants.PRJ_MARKER, false, IResource.DEPTH_ZERO);
}
// There should be only one projectmarker.
if (allMarkers.length == 1) {
return allMarkers;
}
// Job is done. Nothing to migrate.
return null;
} catch (CoreException e) {
ValidationPlugin.getPlugin().handleException(e);
return null;
}
}
protected void load(IMarker[] marker) {
// 4.03 project preferences are different from the current in the following ways:
// 1. Only preferences that could be set were the enabled validators and the auto-validate
// option.
// 2. The preferences were stored in an IMarker instead of a PersistentProperty.
// The 5.0 project settings were stored in an IMarker, and the current settings are stored
// in a PersistentProperty.
// A 5.0 project could have a null validation marker if the validation page was never
// opened on it, and if validation was never run.
try {
if (marker == null) {
// Assume default values
resetToDefault();
return;
}
IMarker prjMarker = marker[0]; // getProjectMarker() has already checked that there's a
// marker in the array
// GlobalConfiguration gp = ConfigurationManager.getManager().getGlobalConfiguration();
// String enabledValStr = (String) getValue(prjMarker, ConfigurationConstants.ENABLED_VALIDATORS);
// ValidatorMetaData[] enabledVal = null;
// if (enabledValStr == null) {
// enabledVal = gp.getEnabledValidators();
// } else {
// enabledVal = getStringAsEnabledElementsArray(enabledValStr);
// }
// setEnabledValidators(enabledVal);
ValidatorMetaData[] enabledManaualVal = null;
ValidatorMetaData[] enabledBuildVal = null;
String enabledManualValStr = (String) getValue(prjMarker, ConfigurationConstants.ENABLED_MANUAL_VALIDATORS);
String enabledBuildValStr = (String) getValue(prjMarker, ConfigurationConstants.ENABLED_BUILD_VALIDATORS);
// ValidatorMetaData[] enabledVal = null;
// if (enabledManualValStr.equals(null) || enabledBuildValStr.equals(null)) {
// enabledVal = gp.getEnabledValidators();
// } else {
if (!enabledManualValStr.equals(null) && !enabledBuildValStr.equals(null)) {
enabledManaualVal = getStringAsEnabledElementsArray(enabledManualValStr);
setEnabledManualValidators(enabledManaualVal);
enabledBuildVal = getStringAsEnabledElementsArray(enabledManualValStr);
setEnabledBuildValidators(enabledBuildVal);
}
String version = loadVersion(marker); // In 4.03, every project had its own validators &
// auto-validate settings.
Boolean boolVal = (Boolean) getValue(prjMarker, ConfigurationConstants.PRJ_OVERRIDEGLOBAL);
if ((boolVal == null) && (version.equals(ConfigurationConstants.VERSION4_03))) {
// Different default for 4.03. In 4.03, all projects overrode the global, because
// the
// global preferences didn't exist.
setDoesProjectOverride(true);
} else if (boolVal == null) {
setDoesProjectOverride(getDoesProjectOverrideDefault());
} else {
setDoesProjectOverride(boolVal.booleanValue());
}
getResource().getWorkspace().deleteMarkers(marker);
} catch (CoreException e) {
ValidationPlugin.getPlugin().handleException(e);
} catch (InvocationTargetException e) {
ValidationPlugin.getPlugin().handleException(e);
}
}
protected void copyTo(ProjectConfiguration prjp) throws InvocationTargetException {
super.copyTo(prjp);
// Need to have a distinct method for this child class (i.e., the parameter
// is not a ValidationConfiguration) because if this initialization is
// called as part of ValidationConfiguration's constructor, then the value of
// this field is overwritten. Fields of this class are initialized to the
// default after the ValidationConfiguration parent is created.
prjp.setDoesProjectOverride(doesProjectOverride());
}
public static boolean getDoesProjectOverrideDefault() {
return PRJ_OVERRIDEGLOBAL_DEFAULT;
}
/**
* 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.)
*
* The "allow" parameter represents whether or not the global "allow projects to override" has
* been changed: - TRUE means that the preference "allow" parameter has been changed - FALSE
* means that the preference "allow" paramter has not been changed
*/
public boolean hasEnabledValidatorsChanged(ValidatorMetaData[] oldEnabledVmd, boolean allow) 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 (super.hasEnabledValidatorsChanged(oldEnabledVmd)) {
return true;
}
// If the global preference validators have changed, does the task list need to be updated?
// PREF | PROJ | UPDATE
// ALLOW | OVERRIDE | TASK LIST
//------------------------------
// 0 | 0 | 1
// 0 | 1 | 1
// 1 | 0 | 1
// 1 | 1 | 0
//
// If the global "allow" preference changes from "allow" to "don't allow", or vice versa,
// and the project overrides the preferences, and the validators differ between the project
// and the preferences, then the task list must be updated.
if (allow) {
// "allow" has changed, so see if the preference and the project validators match.
ValidatorMetaData[] projEnabledVmd = super.getEnabledValidators(); // bypass the check
// for whether the global preferences are to be used or not
GlobalConfiguration gp = ConfigurationManager.getManager().getGlobalConfiguration();
return gp.hasEnabledValidatorsChanged(projEnabledVmd);
}
return false;
}
public boolean haveDelegatesChanged(Map oldDelegates, boolean allow) throws InvocationTargetException {
if (super.haveDelegatesChanged(oldDelegates)) {
return true;
}
if (allow) {
Map projDelegates = super.getDelegatingValidators();
GlobalConfiguration gp = ConfigurationManager.getManager().getGlobalConfiguration();
return gp.haveDelegatesChanged(projDelegates);
}
return false;
}
public void deserialize(String storedConfiguration) throws InvocationTargetException {
if (storedConfiguration == null || storedConfiguration.length() == 0 || storedConfiguration.equals(DefaultValue)) {
resetToDefault();
} else if (storedConfiguration != null) {
int prjOverrideIndex = storedConfiguration.indexOf(ConfigurationConstants.PRJ_OVERRIDEGLOBAL);
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);
}
// project doesn't override the global
if (disableAllValidationIndex != -1) {
String prjOverride = storedConfiguration.substring(prjOverrideIndex + ConfigurationConstants.PRJ_OVERRIDEGLOBAL.length(), disableAllValidationIndex);
setDoesProjectOverride(Boolean.valueOf(prjOverride).booleanValue());
}
}
}
public String serialize() throws InvocationTargetException {
StringBuffer buffer = new StringBuffer();
buffer.append(ConfigurationConstants.PRJ_OVERRIDEGLOBAL);
buffer.append(String.valueOf(doesProjectOverride()));
if (doesProjectOverride()) {
// Store common values for the Project configuration only if they differ from the global
buffer.append(super.serialize());
}
return buffer.toString();
}
public ValidatorMetaData[] getEnabledFullBuildValidators(boolean fullBuild) throws InvocationTargetException {
if (useGlobalPreference()) {
return extractProjectValidators(ConfigurationManager.getManager().getGlobalConfiguration().getEnabledFullBuildValidators(fullBuild), getResource());
}
return super.getEnabledFullBuildValidators(fullBuild);
}
/**
* Given a set of validators, usually the global preference set, change the set so that it
* contains only the validators configured on this project.
*/
private static ValidatorMetaData[] extractProjectValidators(ValidatorMetaData[] vmds, IResource resource, boolean onlyReferenced) {
ValidationRegistryReader reader = ValidationRegistryReader.getReader();
int length = (vmds == null) ? 0 : vmds.length;
ValidatorMetaData[] temp = new ValidatorMetaData[length];
if (length == 0) {
return temp;
}
int count = 0;
IProject project = (IProject) resource;
for (int i = 0; i < vmds.length; i++) {
ValidatorMetaData vmd = vmds[i];
if (reader.isConfiguredOnProject(vmd, project)) {
if (!onlyReferenced || vmd.isDependentValidator())
temp[count++] = vmd;
}
}
ValidatorMetaData[] result = new ValidatorMetaData[count];
System.arraycopy(temp, 0, result, 0, count);
temp = null;
return result;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.wst.validation.internal.operations.internal.attribute.ValidationConfiguration#getEnabledFullBuildValidators(boolean)
*/
public ValidatorMetaData[] getEnabledFullBuildValidators(boolean fullBuild, boolean onlyReferenced) throws InvocationTargetException {
if (useGlobalPreference()) {
return extractProjectValidators(ConfigurationManager.getManager().getGlobalConfiguration().getEnabledFullBuildValidators(fullBuild), getResource(), onlyReferenced);
}
return super.getEnabledFullBuildValidators(fullBuild, onlyReferenced);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.wst.validation.internal.operations.internal.attribute.ValidationConfiguration#getIncrementalValidators()
*/
public ValidatorMetaData[] getIncrementalValidators() throws InvocationTargetException {
if (useGlobalPreference()) {
return extractProjectValidators(ConfigurationManager.getManager().getGlobalConfiguration().getIncrementalValidators(), getResource());
}
return super.getIncrementalValidators();
}
public int numberOfManualValidators() throws InvocationTargetException {
if (useGlobalPreference()) {
return ConfigurationManager.getManager().getGlobalConfiguration().numberOfManualEnabledValidators();
}
return super.numberOfManualEnabledValidators();
}
public boolean isDisableAllValidation() throws InvocationTargetException{
if (useGlobalPreference()) {
return ConfigurationManager.getManager().getGlobalConfiguration().isDisableAllValidation();
}
return super.isDisableAllValidation();
}
public ValidatorDelegateDescriptor getDelegateDescriptor(ValidatorMetaData vmd) throws InvocationTargetException {
if (useGlobalPreference()) {
return ConfigurationManager.getManager().getGlobalConfiguration().getDelegateDescriptor(vmd);
}
return super.getDelegateDescriptor(vmd);
}
public void store() throws InvocationTargetException {
IProject project = (IProject) getResource();
final PreferencesWrapper pref = PreferencesWrapper.getPreferences(project, null);
if (pref != null) {
try {
pref.put(ValidationConfiguration.UserPreference, serialize());
pref.put(ValidationConfiguration.UserManualPreference, serializeManualSetting());
pref.put(ValidationConfiguration.UserBuildPreference, serializeBuildSetting());
pref.put(ValidationConfiguration.DelegatesPreference, serializeDelegatesSetting());
pref.flush();
} catch (BackingStoreException e) {
// A common error is that the project has been closed, in which case there
// is nothing that we can do.
if (project.isAccessible())ValidationPlugin.getPlugin().handleException(e);
}
}
}
protected void loadPreference() throws InvocationTargetException {
IProject project = (IProject) getResource();
final PreferencesWrapper prefs = PreferencesWrapper.getPreferences(project, null);
if (prefs.nodeExists()) {
String storedConfig = prefs.get(ValidationConfiguration.UserPreference, DefaultValue);
deserialize(storedConfig);
String storedManualConfig = prefs.get(ValidationConfiguration.UserManualPreference, DefaultValue);
deserializeManual(storedManualConfig);
String storedBuildConfig = prefs.get(ValidationConfiguration.UserBuildPreference, DefaultValue);
deserializeBuild(storedBuildConfig);
String storedDelegatesConfiguration = prefs.get(ValidationConfiguration.DelegatesPreference, DefaultValue);
deserializeDelegates(storedDelegatesConfiguration);
}
}
/**
* Answer the validator id's that have been enabled for manual validation.
* @return null if they are all enabled
*/
Set getEnabledManualValidators(){
return getIds(ValidationConfiguration.UserManualPreference, ConfigurationConstants.ENABLED_MANUAL_VALIDATORS);
}
/**
* Answer the validator id's that have been enabled for build validation.
* @return null if they are all enabled
*/
Set getEnabledBuildlValidators(){
return getIds(ValidationConfiguration.UserBuildPreference, ConfigurationConstants.ENABLED_BUILD_VALIDATORS);
}
/**
* A helper method to extract some validator id's from a preference store field.
*
* @return null if all the validators are enabled.
*/
private Set getIds(String prefKey, String enabledPhrase){
IProject project = (IProject) getResource();
final PreferencesWrapper prefs = PreferencesWrapper.getPreferences(project, null);
if (prefs == null)return null;
String storedConfig = prefs.get(prefKey, DefaultValue);
if (storedConfig == null || storedConfig.length() == 0 || storedConfig.equals(DefaultValue))return null;
int validationIndex = storedConfig.indexOf(enabledPhrase);
String ids = storedConfig.substring(validationIndex + enabledPhrase.length(),storedConfig.length());
StringTokenizer tokenizer = new StringTokenizer(ids, ConfigurationConstants.ELEMENT_SEPARATOR);
Set set = new HashSet(20);
while (tokenizer.hasMoreTokens())set.add(tokenizer.nextToken());
if (set.size() == 0)return null;
return set;
}
}