| /******************************************************************************* |
| * 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.ERROR; |
| 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.WARNING; |
| 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$ |
| } |
