/*******************************************************************************
* Copyright (c) 2006 Oracle Corporation.
* 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:
* Cameron Bateman/Oracle - initial API and implementation
*
********************************************************************************/
package org.eclipse.jst.jsf.validation.internal;
import org.eclipse.core.runtime.preferences.IScopeContext;
import org.eclipse.emf.common.util.Diagnostic;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jst.jsf.core.internal.IJSFPreferenceModel;
import org.eclipse.jst.jsf.core.internal.JSFCorePlugin;
import org.eclipse.jst.jsf.validation.internal.el.diagnostics.DiagnosticFactory;
/**
* Model object for EL validation preferences
*
* @author cbateman
*/
public class ELValidationPreferences implements IJSFPreferenceModel
{
private final static String KEY_ENABLE_BUILD_VALIDATION =
"org.eclipse.jst.jsf.ui.ValidateJSFELBuild"; //$NON-NLS-1$
private final static boolean DEFAULT_ENABLE_BUILD_VALIDATION = true;
private final static String KEY_ENABLE_INCREMENTAL_VALIDATION =
"org.eclipse.jst.jsf.ui.ValidateJSFELIncremental"; //$NON-NLS-1$
private final static boolean DEFAULT_ENABLE_INCREMENTAL_VALIDATION = false;
private boolean _enableBuildValidation;
private boolean _enableIncrementalValidation;
private int[] _severities;
/**
* Loads the object from the preference store provided
*
* @param prefStore
*/
public void load(IPreferenceStore prefStore)
{
if (!prefStore.contains(KEY_ENABLE_BUILD_VALIDATION))
{
prefStore.setDefault(KEY_ENABLE_BUILD_VALIDATION, DEFAULT_ENABLE_BUILD_VALIDATION);
}
_enableBuildValidation =
prefStore.getBoolean(KEY_ENABLE_BUILD_VALIDATION);
if (!prefStore.contains(KEY_ENABLE_INCREMENTAL_VALIDATION))
{
prefStore.setDefault(KEY_ENABLE_INCREMENTAL_VALIDATION, DEFAULT_ENABLE_INCREMENTAL_VALIDATION);
}
_enableIncrementalValidation =
prefStore.getBoolean(KEY_ENABLE_INCREMENTAL_VALIDATION);
loadSeverities(prefStore);
}
private void loadSeverities(final IPreferenceStore prefStore)
{
final int severities[] = getSeverities();
for (int i = 0; i < DiagnosticFactory.NUM_IDS; i++)
{
final String key = getKeyById(i);
if (!prefStore.contains(key))
{
final int diagSeverity = getDefaultSeverity(i);
final Severity severity = mapDiagToSeverity(diagSeverity);
prefStore.setDefault(key, severity.toString());
}
final String storedSeverity = prefStore.getString(key);
severities[i] = mapSeverityToDiag(storedSeverity);
}
}
/**
* Copies the object into the preference store but DOES NOT SAVE IT
*
* @param prefStore
*/
public void commit(IPreferenceStore prefStore)
{
prefStore.setValue(KEY_ENABLE_BUILD_VALIDATION, _enableBuildValidation);
prefStore.setValue(KEY_ENABLE_INCREMENTAL_VALIDATION,
_enableIncrementalValidation);
commitSeverities(prefStore);
}
private void commitSeverities(final IPreferenceStore prefStore)
{
final int severities[] = getSeverities();
for (int i = 0; i < severities.length; i++)
{
final String key = getKeyById(i);
prefStore.setValue(key
, mapDiagToSeverity(severities[i]).toString());
}
}
/**
* Reverts the model to it's defaults. Does not commit to pref store.
*/
public void setDefaults()
{
setEnableBuildValidation(DEFAULT_ENABLE_BUILD_VALIDATION);
setEnableIncrementalValidation(DEFAULT_ENABLE_INCREMENTAL_VALIDATION);
setProblemSeverityDefaults();
}
private void setProblemSeverityDefaults()
{
final int[] severities = getSeverities();
for (int i = 0; i < DiagnosticFactory.NUM_IDS; i++)
{
severities[i] = getDefaultSeverity(i);
}
}
public Object getValueByKey(IScopeContext context, String key) {
// ignore context for now; will be used when we have project overrides
if (KEY_ENABLE_BUILD_VALIDATION.equals(key))
{
return Boolean.valueOf(isEnableBuildValidation());
}
else if (KEY_ENABLE_INCREMENTAL_VALIDATION.equals(key))
{
return Boolean.valueOf(isEnableIncrementalValidation());
}
else
{
try
{
final Severity severity = getSeverity(key);
return severity.toString();
}
catch (IllegalArgumentException e)
{
// getIdByKey will throw this exception if key is not a valid
// severity key. Ignore the exception here and fall-through
}
}
return null; // not found
}
/* (non-Javadoc)
* @see org.eclipse.jst.jsf.core.internal.IJSFPreferenceModel#getStoredValueByKey(org.eclipse.core.runtime.preferences.IScopeContext, java.lang.String)
*/
public Object getStoredValueByKey(IScopeContext context, String key) {
// ignore context for now; will be used when we have project overrides
if (KEY_ENABLE_BUILD_VALIDATION.equals(key))
{
return Boolean.valueOf(context.getNode("org.eclipse.jst.jsf.ui").getBoolean(key, true)); //$NON-NLS-1$
}
else if (KEY_ENABLE_INCREMENTAL_VALIDATION.equals(key))
{
return Boolean.valueOf(context.getNode("org.eclipse.jst.jsf.ui").getBoolean(key, false)); //$NON-NLS-1$
}
else
{
try
{
return context.getNode("org.eclipse.jst.jsf.core").get(key, mapDiagToSeverity(getDefaultSeverity(getIdByKey(key))).toString()); //$NON-NLS-1$
}
catch (IllegalArgumentException e)
{
// getIdByKey will throw this exception if key is not a valid
// severity key. Ignore the exception here and fall-through
}
}
return null; // not found
}
/* (non-Javadoc)
* @see org.eclipse.jst.jsf.core.internal.IJSFPreferenceModel#setValueByKey(org.eclipse.core.runtime.preferences.IScopeContext, java.lang.String, java.lang.Object)
*/
public Object setValueByKey(IScopeContext context, String key, Object value)
{
// ignore context for now; will be used when we have project overrides
if (KEY_ENABLE_BUILD_VALIDATION.equals(key))
{
boolean oldValue = isEnableBuildValidation();
boolean newValue = ((Boolean)value).booleanValue();
setEnableBuildValidation(newValue);
return Boolean.valueOf(oldValue);
}
else if (KEY_ENABLE_INCREMENTAL_VALIDATION.equals(key))
{
boolean oldValue = isEnableIncrementalValidation();
boolean newValue = ((Boolean)value).booleanValue();
setEnableIncrementalValidation(newValue);
return Boolean.valueOf(oldValue);
}
else
{
final Severity oldValue = getSeverity(key);
setSeverity(key, (Severity)value);
return oldValue;
}
}
/**
* @return the build validation enablement
*/
public boolean isEnableBuildValidation()
{
return _enableBuildValidation;
}
/**
* @return the incremental validation enablement
*/
public boolean isEnableIncrementalValidation()
{
return _enableIncrementalValidation;
}
/**
* @param enableBuildValidation
*/
public void setEnableBuildValidation(boolean enableBuildValidation) {
_enableBuildValidation = enableBuildValidation;
}
/**
* @param enableIncrementalValidation
*/
public void setEnableIncrementalValidation(boolean enableIncrementalValidation) {
_enableIncrementalValidation = enableIncrementalValidation;
}
/**
* @param key
* @return the severity
*/
public Severity getSeverity(final String key)
{
final int severityDiag = _severities[getIdByKey(key)];
final Severity severity = mapDiagToSeverity(severityDiag);
return severity;
}
/**
* @param key
* @param severity
*/
public void setSeverity(final String key, final Severity severity)
{
final int newSeverityDiag = mapSeverityToDiag(severity.toString());
final int diagId = getIdByKey(key);
_severities[diagId] = newSeverityDiag;
}
/**
* @param diagnosticId
* @return the severity as configured for diagnosticId. The value
* is relative to the Diagnostic class severity scheme
*/
public final int getDiagnosticSeverity(final int diagnosticId)
{
return getSeverities()[diagnosticId];
}
private int[] getSeverities()
{
if (_severities == null)
{
_severities = new int[DiagnosticFactory.NUM_IDS];
}
return _severities;
}
/**
* @param diagSeverity
* @return a Severity preference value for a diagnostic severity
*/
public static Severity mapDiagToSeverity(int diagSeverity)
{
switch(diagSeverity)
{
case Diagnostic.ERROR:
return Severity.ERROR;
case Diagnostic.WARNING:
return Severity.WARNING;
default:
return Severity.IGNORE;
}
}
/**
* @param severity
* @return a Diagnostic severity level for a severity pref string
*/
public static int mapSeverityToDiag(String severity)
{
if ("error".equals(severity)) //$NON-NLS-1$
{
return Diagnostic.ERROR;
}
else if ("warning".equals(severity)) //$NON-NLS-1$
{
return Diagnostic.WARNING;
}
else if ("ignore".equals(severity)) //$NON-NLS-1$
{
return Diagnostic.OK;
}
else
{
throw new IllegalArgumentException("Invalid enum name: "+severity); //$NON-NLS-1$
}
}
/**
* @param diagnosticId
* @return the default severity of a diagnostic
*/
public static int getDefaultSeverity(final int diagnosticId)
{
switch(diagnosticId)
{
case DiagnosticFactory.BINARY_OP_BOTH_OPERANDS_NULL_ID:
return Diagnostic.WARNING;
case DiagnosticFactory.BINARY_OP_POSSIBLE_DIVISION_BY_ZERO_ID:
return Diagnostic.ERROR;
case DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID:
return Diagnostic.ERROR;
case DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID:
return Diagnostic.WARNING;
case DiagnosticFactory.BINARY_OP_EQUALITY_COMP_WITH_NULL_ALWAYS_EVAL_SAME_ID:
return Diagnostic.WARNING;
case DiagnosticFactory.BINARY_OP_CANNOT_COERCE_ARGUMENT_TO_BOOLEAN_ID:
return Diagnostic.ERROR;
case DiagnosticFactory.BINARY_OP_FIRST_ARGUMENT_SHORT_CIRCUITS_ID:
return Diagnostic.WARNING;
case DiagnosticFactory.BINARY_OP_SECOND_ARGUMENT_ALWAYS_EVAL_SAME_ID:
return Diagnostic.WARNING;
case DiagnosticFactory.BINARY_OP_NO_AVAILABLE_TYPE_COERCION_ID:
return Diagnostic.ERROR;
case DiagnosticFactory.BINARY_OP_COULD_NOT_COERCE_LITERALS_TO_NUMBERS_ID:
return Diagnostic.ERROR;
case DiagnosticFactory.UNARY_OP_CONSTANT_EXPRESSION_EVAL_SAME_ID:
return Diagnostic.WARNING;
case DiagnosticFactory.UNARY_OP_EMPTY_ALWAYS_FALSE_ON_TYPE_ID:
return Diagnostic.WARNING;
case DiagnosticFactory.UNARY_OP_MINUS_ON_NULL_ALWAYS_ZERO_ID:
return Diagnostic.WARNING;
case DiagnosticFactory.UNARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID:
return Diagnostic.ERROR;
case DiagnosticFactory.UNARY_OP_CANNOT_COERCE_ARGUMENT_TO_BOOLEAN_ID:
return Diagnostic.WARNING; /* Bug 243674 */
case DiagnosticFactory.TERNARY_OP_CHOICE_IS_ALWAYS_SAME_ID:
return Diagnostic.WARNING;
case DiagnosticFactory.TERNARY_OP_CANNOT_COERCE_CHOICE_TO_BOOLEAN_ID:
return Diagnostic.ERROR;
case DiagnosticFactory.UNARY_OP_STRING_CONVERSION_NOT_GUARANTEED_ID:
return Diagnostic.WARNING;
case DiagnosticFactory.CANNOT_APPLY_OPERATOR_TO_METHOD_BINDING_ID:
return Diagnostic.ERROR;
case DiagnosticFactory.MEMBER_NOT_FOUND_ID:
return Diagnostic.WARNING;
case DiagnosticFactory.VARIABLE_NOT_FOUND_ID:
return Diagnostic.INFO;
case DiagnosticFactory.MISSING_CLOSING_EXPR_BRACKET_ID:
return Diagnostic.ERROR;
case DiagnosticFactory.GENERAL_SYNTAX_ERROR_ID:
return Diagnostic.WARNING;
case DiagnosticFactory.EMPTY_EL_EXPRESSION_ID:
return Diagnostic.WARNING;
case DiagnosticFactory.BINARY_OP_DOT_WITH_VALUEB_NULL_ID:
return Diagnostic.WARNING;
case DiagnosticFactory.BINARY_OP_DOT_WITH_DOTTED_KEY_SHOULD_USE_ARRAY_ID:
return Diagnostic.WARNING;
case DiagnosticFactory.POSSIBLE_ARRAY_INDEX_OUT_OF_BOUNDS_ID:
return Diagnostic.WARNING;
case DiagnosticFactory.BINARY_COMPARISON_WITH_ENUM_ALWAYS_SAME_ID:
return Diagnostic.WARNING;
case DiagnosticFactory.BINARY_OP_COMPARISON_OF_ENUMS_INCOMPATIBLE_ID:
return Diagnostic.ERROR;
case DiagnosticFactory.MEMBER_IS_INTERMEDIATE_ID:
return Diagnostic.WARNING;
default:
throw new IllegalArgumentException("Diagnostic Id: "+ diagnosticId +" is out of range"); //$NON-NLS-1$ //$NON-NLS-2$
}
}
/**
* @param diagnosticId
* @return the preference key for the corresponding diagnosticId in the el DiagnosticFactory
*/
public static String getKeyById(final int diagnosticId)
{
switch(diagnosticId)
{
case DiagnosticFactory.BINARY_OP_BOTH_OPERANDS_NULL_ID:
return BINARY_OP_BOTH_OPERANDS_NULL;
case DiagnosticFactory.BINARY_OP_POSSIBLE_DIVISION_BY_ZERO_ID:
return BINARY_OP_POSSIBLE_DIVISION_BY_ZERO;
case DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID:
return BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION;
case DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID:
return BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME;
case DiagnosticFactory.BINARY_OP_EQUALITY_COMP_WITH_NULL_ALWAYS_EVAL_SAME_ID:
return BINARY_OP_EQUALITY_COMP_WITH_NULL_ALWAYS_EVAL_SAME;
case DiagnosticFactory.BINARY_OP_CANNOT_COERCE_ARGUMENT_TO_BOOLEAN_ID:
return BINARY_OP_CANNOT_COERCE_ARGUMENT_TO_BOOLEAN;
case DiagnosticFactory.BINARY_OP_FIRST_ARGUMENT_SHORT_CIRCUITS_ID:
return BINARY_OP_FIRST_ARGUMENT_SHORT_CIRCUITS;
case DiagnosticFactory.BINARY_OP_SECOND_ARGUMENT_ALWAYS_EVAL_SAME_ID:
return BINARY_OP_SECOND_ARGUMENT_ALWAYS_EVAL_SAME;
case DiagnosticFactory.BINARY_OP_NO_AVAILABLE_TYPE_COERCION_ID:
return BINARY_OP_NO_AVAILABLE_TYPE_COERCION;
case DiagnosticFactory.BINARY_OP_COULD_NOT_COERCE_LITERALS_TO_NUMBERS_ID:
return BINARY_OP_COULD_NOT_COERCE_LITERALS_TO_NUMBERS;
case DiagnosticFactory.UNARY_OP_CONSTANT_EXPRESSION_EVAL_SAME_ID:
return UNARY_OP_CONSTANT_EXPRESSION_EVAL_SAME;
case DiagnosticFactory.UNARY_OP_EMPTY_ALWAYS_FALSE_ON_TYPE_ID:
return UNARY_OP_EMPTY_ALWAYS_FALSE_ON_TYPE;
case DiagnosticFactory.UNARY_OP_MINUS_ON_NULL_ALWAYS_ZERO_ID:
return UNARY_OP_MINUS_ON_NULL_ALWAYS_ZERO;
case DiagnosticFactory.UNARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID:
return UNARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION;
case DiagnosticFactory.UNARY_OP_CANNOT_COERCE_ARGUMENT_TO_BOOLEAN_ID:
return UNARY_OP_CANNOT_COERCE_ARGUMENT_TO_BOOLEAN;
case DiagnosticFactory.TERNARY_OP_CHOICE_IS_ALWAYS_SAME_ID:
return TERNARY_OP_CHOICE_IS_ALWAYS_SAME;
case DiagnosticFactory.TERNARY_OP_CANNOT_COERCE_CHOICE_TO_BOOLEAN_ID:
return TERNARY_OP_CANNOT_COERCE_CHOICE_TO_BOOLEAN;
case DiagnosticFactory.UNARY_OP_STRING_CONVERSION_NOT_GUARANTEED_ID:
return UNARY_OP_STRING_CONVERSION_NOT_GUARANTEED;
case DiagnosticFactory.CANNOT_APPLY_OPERATOR_TO_METHOD_BINDING_ID:
return CANNOT_APPLY_OPERATOR_TO_METHOD_BINDING;
case DiagnosticFactory.MEMBER_NOT_FOUND_ID:
return MEMBER_NOT_FOUND;
case DiagnosticFactory.VARIABLE_NOT_FOUND_ID:
return VARIABLE_NOT_FOUND;
case DiagnosticFactory.MISSING_CLOSING_EXPR_BRACKET_ID:
return MISSING_CLOSING_EXPR_BRACKET;
case DiagnosticFactory.GENERAL_SYNTAX_ERROR_ID:
return GENERAL_SYNTAX_ERROR;
case DiagnosticFactory.EMPTY_EL_EXPRESSION_ID:
return EMPTY_EL_EXPRESSION;
case DiagnosticFactory.BINARY_OP_DOT_WITH_VALUEB_NULL_ID:
return BINARY_OP_DOT_WITH_VALUEB_NULL;
case DiagnosticFactory.BINARY_OP_DOT_WITH_DOTTED_KEY_SHOULD_USE_ARRAY_ID:
return BINARY_OP_DOT_WITH_DOTTED_KEY_SHOULD_USE_ARRAY;
case DiagnosticFactory.POSSIBLE_ARRAY_INDEX_OUT_OF_BOUNDS_ID:
return POSSIBLE_ARRAY_INDEX_OUT_OF_BOUNDS;
case DiagnosticFactory.BINARY_COMPARISON_WITH_ENUM_ALWAYS_SAME_ID:
return BINARY_COMPARISON_WITH_ENUM_ALWAYS_SAME;
case DiagnosticFactory.BINARY_OP_COMPARISON_OF_ENUMS_INCOMPATIBLE_ID:
return BINARY_OP_COMPARISON_OF_ENUMS_INCOMPATIBLE;
case DiagnosticFactory.MEMBER_IS_INTERMEDIATE_ID:
return MEMBER_IS_INTERMEDIATE;
default:
throw new IllegalArgumentException("Diagnostic Id: "+ diagnosticId +" is out of range"); //$NON-NLS-1$ //$NON-NLS-2$
}
}
/**
* @param key
* @return the preference key for the corresponding diagnosticId in the el DiagnosticFactory
*/
public static int getIdByKey(final String key)
{
if (BINARY_OP_BOTH_OPERANDS_NULL.equals(key))
{
return DiagnosticFactory.BINARY_OP_BOTH_OPERANDS_NULL_ID;
}
else if (BINARY_OP_POSSIBLE_DIVISION_BY_ZERO.equals(key))
{
return DiagnosticFactory.BINARY_OP_POSSIBLE_DIVISION_BY_ZERO_ID;
}
else if (BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION.equals(key))
{
return DiagnosticFactory.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID;
}
else if (BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME.equals(key))
{
return DiagnosticFactory.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID;
}
else if (BINARY_OP_EQUALITY_COMP_WITH_NULL_ALWAYS_EVAL_SAME.equals(key))
{
return DiagnosticFactory.BINARY_OP_EQUALITY_COMP_WITH_NULL_ALWAYS_EVAL_SAME_ID;
}
else if (BINARY_OP_CANNOT_COERCE_ARGUMENT_TO_BOOLEAN.equals(key))
{
return DiagnosticFactory.BINARY_OP_CANNOT_COERCE_ARGUMENT_TO_BOOLEAN_ID;
}
else if (BINARY_OP_FIRST_ARGUMENT_SHORT_CIRCUITS.equals(key))
{
return DiagnosticFactory.BINARY_OP_FIRST_ARGUMENT_SHORT_CIRCUITS_ID;
}
else if (BINARY_OP_SECOND_ARGUMENT_ALWAYS_EVAL_SAME.equals(key))
{
return DiagnosticFactory.BINARY_OP_SECOND_ARGUMENT_ALWAYS_EVAL_SAME_ID;
}
else if (BINARY_OP_NO_AVAILABLE_TYPE_COERCION.equals(key))
{
return DiagnosticFactory.BINARY_OP_NO_AVAILABLE_TYPE_COERCION_ID;
}
else if (BINARY_OP_COULD_NOT_COERCE_LITERALS_TO_NUMBERS.equals(key))
{
return DiagnosticFactory.BINARY_OP_COULD_NOT_COERCE_LITERALS_TO_NUMBERS_ID;
}
else if (UNARY_OP_CONSTANT_EXPRESSION_EVAL_SAME.equals(key))
{
return DiagnosticFactory.UNARY_OP_CONSTANT_EXPRESSION_EVAL_SAME_ID;
}
else if (UNARY_OP_EMPTY_ALWAYS_FALSE_ON_TYPE.equals(key))
{
return DiagnosticFactory.UNARY_OP_EMPTY_ALWAYS_FALSE_ON_TYPE_ID;
}
else if (UNARY_OP_MINUS_ON_NULL_ALWAYS_ZERO.equals(key))
{
return DiagnosticFactory.UNARY_OP_MINUS_ON_NULL_ALWAYS_ZERO_ID;
}
else if (UNARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION.equals(key))
{
return DiagnosticFactory.UNARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID;
}
else if (UNARY_OP_CANNOT_COERCE_ARGUMENT_TO_BOOLEAN.equals(key))
{
return DiagnosticFactory.UNARY_OP_CANNOT_COERCE_ARGUMENT_TO_BOOLEAN_ID;
}
else if (TERNARY_OP_CHOICE_IS_ALWAYS_SAME.equals(key))
{
return DiagnosticFactory.TERNARY_OP_CHOICE_IS_ALWAYS_SAME_ID;
}
else if (TERNARY_OP_CANNOT_COERCE_CHOICE_TO_BOOLEAN.equals(key))
{
return DiagnosticFactory.TERNARY_OP_CANNOT_COERCE_CHOICE_TO_BOOLEAN_ID;
}
else if (UNARY_OP_STRING_CONVERSION_NOT_GUARANTEED.equals(key))
{
return DiagnosticFactory.UNARY_OP_STRING_CONVERSION_NOT_GUARANTEED_ID;
}
else if (CANNOT_APPLY_OPERATOR_TO_METHOD_BINDING.equals(key))
{
return DiagnosticFactory.CANNOT_APPLY_OPERATOR_TO_METHOD_BINDING_ID;
}
else if (MEMBER_NOT_FOUND.equals(key))
{
return DiagnosticFactory.MEMBER_NOT_FOUND_ID;
}
else if (VARIABLE_NOT_FOUND.equals(key))
{
return DiagnosticFactory.VARIABLE_NOT_FOUND_ID;
}
else if (MISSING_CLOSING_EXPR_BRACKET.equals(key))
{
return DiagnosticFactory.MISSING_CLOSING_EXPR_BRACKET_ID;
}
else if (GENERAL_SYNTAX_ERROR.equals(key))
{
return DiagnosticFactory.GENERAL_SYNTAX_ERROR_ID;
}
else if (EMPTY_EL_EXPRESSION.equals(key))
{
return DiagnosticFactory.EMPTY_EL_EXPRESSION_ID;
}
else if (BINARY_OP_DOT_WITH_VALUEB_NULL.equals(key))
{
return DiagnosticFactory.BINARY_OP_DOT_WITH_VALUEB_NULL_ID;
}
else if (BINARY_OP_DOT_WITH_DOTTED_KEY_SHOULD_USE_ARRAY.equals(key))
{
return DiagnosticFactory.BINARY_OP_DOT_WITH_DOTTED_KEY_SHOULD_USE_ARRAY_ID;
}
else if (POSSIBLE_ARRAY_INDEX_OUT_OF_BOUNDS.equals(key))
{
return DiagnosticFactory.POSSIBLE_ARRAY_INDEX_OUT_OF_BOUNDS_ID;
}
else if (BINARY_COMPARISON_WITH_ENUM_ALWAYS_SAME.equals(key))
{
return DiagnosticFactory.BINARY_COMPARISON_WITH_ENUM_ALWAYS_SAME_ID;
}
else if (BINARY_OP_COMPARISON_OF_ENUMS_INCOMPATIBLE.equals(key))
{
return DiagnosticFactory.BINARY_OP_COMPARISON_OF_ENUMS_INCOMPATIBLE_ID;
}
else if (MEMBER_IS_INTERMEDIATE.equals(key))
{
return DiagnosticFactory.MEMBER_IS_INTERMEDIATE_ID;
}
else
{
throw new IllegalArgumentException("Severity Key: "+ key); //$NON-NLS-1$
}
}
/**
* e.g. createQualifiedKeyName("foo") -> org.eclipse.jst.jsf.core.foo
* @param baseName
* @return a plugin qualified key given the baseName
*
*/
private static String createQualifiedKeyName(final String baseName)
{
return JSFCorePlugin.PLUGIN_ID + "." + baseName; //$NON-NLS-1$
}
/**
* preference key. Match to DiagnosticFactory constants
*/
public final static String BINARY_OP_BOTH_OPERANDS_NULL =
createQualifiedKeyName("BINARY_OP_BOTH_OPERANDS_NULL"); //$NON-NLS-1$
/**
* preference key. Match to DiagnosticFactory constants
*/
public final static String BINARY_OP_POSSIBLE_DIVISION_BY_ZERO =
createQualifiedKeyName("BINARY_OP_POSSIBLE_DIVISION_BY_ZERO"); //$NON-NLS-1$
/**
* preference key. Match to DiagnosticFactory constants
*/
public final static String BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION =
createQualifiedKeyName("BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION"); //$NON-NLS-1$
/**
* preference key. Match to DiagnosticFactory constants
*/
public final static String BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME =
createQualifiedKeyName("BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME"); //$NON-NLS-1$
/**
* preference key. Match to DiagnosticFactory constants
*/
public final static String BINARY_OP_EQUALITY_COMP_WITH_NULL_ALWAYS_EVAL_SAME =
createQualifiedKeyName("BINARY_OP_EQUALITY_COMP_WITH_NULL_ALWAYS_EVAL_SAME"); //$NON-NLS-1$
/**
* preference key. Match to DiagnosticFactory constants
*/
public final static String BINARY_OP_CANNOT_COERCE_ARGUMENT_TO_BOOLEAN =
createQualifiedKeyName("BINARY_OP_CANNOT_COERCE_ARGUMENT_TO_BOOLEAN"); //$NON-NLS-1$
/**
* preference key. Match to DiagnosticFactory constants
*/
public final static String BINARY_OP_FIRST_ARGUMENT_SHORT_CIRCUITS =
createQualifiedKeyName("BINARY_OP_FIRST_ARGUMENT_SHORT_CIRCUITS"); //$NON-NLS-1$
/**
* preference key. Match to DiagnosticFactory constants
*/
public final static String BINARY_OP_SECOND_ARGUMENT_ALWAYS_EVAL_SAME =
createQualifiedKeyName("BINARY_OP_SECOND_ARGUMENT_ALWAYS_EVAL_SAME"); //$NON-NLS-1$
/**
* preference key. Match to DiagnosticFactory constants
*/
public final static String BINARY_OP_NO_AVAILABLE_TYPE_COERCION =
createQualifiedKeyName("BINARY_OP_NO_AVAILABLE_TYPE_COERCION"); //$NON-NLS-1$
/**
* preference key. Match to DiagnosticFactory constants
*/
public final static String BINARY_OP_COULD_NOT_COERCE_LITERALS_TO_NUMBERS =
createQualifiedKeyName("BINARY_OP_COULD_NOT_COERCE_LITERALS_TO_NUMBERS"); //$NON-NLS-1$
/**
* preference key. Match to DiagnosticFactory constants
*/
public final static String UNARY_OP_CONSTANT_EXPRESSION_EVAL_SAME =
createQualifiedKeyName("UNARY_OP_CONSTANT_EXPRESSION_EVAL_SAME"); //$NON-NLS-1$
/**
* preference key. Match to DiagnosticFactory constants
*/
public final static String UNARY_OP_EMPTY_ALWAYS_FALSE_ON_TYPE =
createQualifiedKeyName("UNARY_OP_EMPTY_ALWAYS_FALSE_ON_TYPE"); //$NON-NLS-1$
/**
* preference key. Match to DiagnosticFactory constants
*/
public final static String UNARY_OP_MINUS_ON_NULL_ALWAYS_ZERO =
createQualifiedKeyName("UNARY_OP_MINUS_ON_NULL_ALWAYS_ZERO"); //$NON-NLS-1$
/**
* preference key. Match to DiagnosticFactory constants
*/
public final static String UNARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION =
createQualifiedKeyName("UNARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION"); //$NON-NLS-1$
/**
* preference key. Match to DiagnosticFactory constants
*/
public final static String UNARY_OP_CANNOT_COERCE_ARGUMENT_TO_BOOLEAN =
createQualifiedKeyName("UNARY_OP_CANNOT_COERCE_ARGUMENT_TO_BOOLEAN"); //$NON-NLS-1$
/**
* preference key. Match to DiagnosticFactory constants
*/
public final static String TERNARY_OP_CHOICE_IS_ALWAYS_SAME =
createQualifiedKeyName("TERNARY_OP_CHOICE_IS_ALWAYS_SAME"); //$NON-NLS-1$
/**
* preference key. Match to DiagnosticFactory constants
*/
public final static String TERNARY_OP_CANNOT_COERCE_CHOICE_TO_BOOLEAN =
createQualifiedKeyName("TERNARY_OP_CANNOT_COERCE_CHOICE_TO_BOOLEAN"); //$NON-NLS-1$
/**
* preference key. Match to DiagnosticFactory constants
*/
public final static String UNARY_OP_STRING_CONVERSION_NOT_GUARANTEED =
createQualifiedKeyName("UNARY_OP_STRING_CONVERSION_NOT_GUARANTEED"); //$NON-NLS-1$
/**
* preference key. Match to DiagnosticFactory constants
*/
public final static String CANNOT_APPLY_OPERATOR_TO_METHOD_BINDING =
createQualifiedKeyName("CANNOT_APPLY_OPERATOR_TO_METHOD_BINDING"); //$NON-NLS-1$
/**
* preference key. Match to DiagnosticFactory constants
*/
public final static String MEMBER_NOT_FOUND =
createQualifiedKeyName("MEMBER_NOT_FOUND"); //$NON-NLS-1$
/**
* preference key. Match to DiagnosticFactory constants
*/
public final static String VARIABLE_NOT_FOUND =
createQualifiedKeyName("VARIABLE_NOT_FOUND"); //$NON-NLS-1$
/**
* preference key. Match to DiagnosticFactory constants
*/
public final static String MISSING_CLOSING_EXPR_BRACKET =
createQualifiedKeyName("MISSING_CLOSING_EXPR_BRACKET"); //$NON-NLS-1$
/**
* preference key. Match to DiagnosticFactory constants
*/
public final static String GENERAL_SYNTAX_ERROR =
createQualifiedKeyName("GENERAL_SYNTAX_ERROR"); //$NON-NLS-1$
/**
* preference key. Match to DiagnosticFactory constants
*/
public final static String EMPTY_EL_EXPRESSION =
createQualifiedKeyName("EMPTY_EL_EXPRESSION"); //$NON-NLS-1$
/**
* preference key. Match to DiagnosticFactory constants
*/
public final static String BINARY_OP_DOT_WITH_VALUEB_NULL =
createQualifiedKeyName("BINARY_OP_DOT_WITH_VALUEB_NULL"); //$NON-NLS-1$
/**
* preference key. Match to DiagnosticFactory constants
*/
public final static String BINARY_OP_DOT_WITH_DOTTED_KEY_SHOULD_USE_ARRAY =
createQualifiedKeyName("BINARY_OP_DOT_WITH_DOTTED_KEY_SHOULD_USE_ARRAY"); //$NON-NLS-1$
/**
* preference key. Match to DiagnosticFactory constants
*/
public final static String POSSIBLE_ARRAY_INDEX_OUT_OF_BOUNDS =
createQualifiedKeyName("POSSIBLE_ARRAY_INDEX_OUT_OF_BOUNDS"); //$NON-NLS-1$
/**
* preference key. Match to DiagnosticFactory constants
*/
public final static String BINARY_COMPARISON_WITH_ENUM_ALWAYS_SAME =
createQualifiedKeyName("BINARY_COMPARISON_WITH_ENUM_ALWAYS_SAME"); //$NON-NLS-1$
/**
* preference key. Match to DiagnosticFactory constants
*/
public final static String BINARY_OP_COMPARISON_OF_ENUMS_INCOMPATIBLE =
createQualifiedKeyName("BINARY_OP_COMPARISON_OF_ENUMS_INCOMPATIBLE"); //$NON-NLS-1$
/**
* preference key. Match to DiagnosticFactory constants
*/
public final static String MEMBER_IS_INTERMEDIATE =
createQualifiedKeyName("MEMBER_IS_INTERMEDIATE"); //$NON-NLS-1$
}