| /******************************************************************************* |
| * Copyright (c) 2006 Oracle Corporation7 |
| * 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.el.diagnostics; |
| |
| import java.text.MessageFormat; |
| |
| import org.eclipse.emf.common.util.BasicDiagnostic; |
| import org.eclipse.emf.common.util.Diagnostic; |
| import org.eclipse.jst.jsf.validation.internal.ELValidationPreferences; |
| import org.eclipse.osgi.util.NLS; |
| |
| /** |
| * Factory for all operator diagnostics. Class should |
| * not be implemented, instantiated or sub-classed. |
| * |
| * @author cbateman |
| * |
| */ |
| public final class DiagnosticFactory |
| { |
| /** |
| * The id used in the source field of all Diagnostic's created by this factory |
| * to uniquely identify EL validation as their source type. |
| */ |
| public final static String SOURCE_ID = "org.eclipse.jst.jsf.validation.el.Diagnostics";//$NON-NLS-1$ |
| |
| /** |
| * Problem id |
| */ |
| public final static int BINARY_OP_BOTH_OPERANDS_NULL_ID = 0; |
| /** |
| * Problem id |
| */ |
| public final static int BINARY_OP_POSSIBLE_DIVISION_BY_ZERO_ID = 1; |
| /** |
| * Problem id |
| */ |
| public final static int BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID = 2; |
| /** |
| * Problem id |
| */ |
| public final static int BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID = 3; |
| /** |
| * Problem id |
| */ |
| public final static int BINARY_OP_EQUALITY_COMP_WITH_NULL_ALWAYS_EVAL_SAME_ID = 4; |
| /** |
| * Problem id |
| */ |
| public final static int BINARY_OP_CANNOT_COERCE_ARGUMENT_TO_BOOLEAN_ID = 5; |
| /** |
| * Problem id |
| */ |
| public final static int BINARY_OP_FIRST_ARGUMENT_SHORT_CIRCUITS_ID = 6; |
| /** |
| * Problem id |
| */ |
| public final static int BINARY_OP_SECOND_ARGUMENT_ALWAYS_EVAL_SAME_ID = 7; |
| /** |
| * Problem id |
| */ |
| public final static int BINARY_OP_NO_AVAILABLE_TYPE_COERCION_ID = 8; |
| /** |
| * Problem id |
| */ |
| public final static int BINARY_OP_COULD_NOT_COERCE_LITERALS_TO_NUMBERS_ID = 9; |
| /** |
| * Problem id |
| */ |
| public final static int UNARY_OP_CONSTANT_EXPRESSION_EVAL_SAME_ID = 10; |
| /** |
| * Problem id |
| */ |
| public final static int UNARY_OP_EMPTY_ALWAYS_FALSE_ON_TYPE_ID = 11; |
| /** |
| * Problem id |
| */ |
| public final static int UNARY_OP_MINUS_ON_NULL_ALWAYS_ZERO_ID = 12; |
| /** |
| * Problem id |
| */ |
| public final static int UNARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID = 13; |
| /** |
| * Problem id |
| */ |
| public final static int UNARY_OP_CANNOT_COERCE_ARGUMENT_TO_BOOLEAN_ID = 14; |
| /** |
| * Problem id |
| */ |
| public final static int TERNARY_OP_CHOICE_IS_ALWAYS_SAME_ID = 15; |
| /** |
| * Problem id |
| */ |
| public final static int TERNARY_OP_CANNOT_COERCE_CHOICE_TO_BOOLEAN_ID = 16; |
| /** |
| * Problem id |
| */ |
| public final static int UNARY_OP_STRING_CONVERSION_NOT_GUARANTEED_ID = 17; |
| /** |
| * Problem id |
| */ |
| public final static int CANNOT_APPLY_OPERATOR_TO_METHOD_BINDING_ID = 18; |
| /** |
| * Problem id |
| */ |
| public final static int MEMBER_NOT_FOUND_ID = 19; |
| /** |
| * Problem id |
| */ |
| public final static int VARIABLE_NOT_FOUND_ID = 20; |
| /** |
| * Problem id |
| */ |
| public final static int MISSING_CLOSING_EXPR_BRACKET_ID = 21; |
| /** |
| * Problem id |
| */ |
| public final static int GENERAL_SYNTAX_ERROR_ID = 22; |
| /** |
| * Problem id |
| */ |
| public final static int EMPTY_EL_EXPRESSION_ID = 23; |
| |
| /** |
| * |
| */ |
| public final static int BINARY_OP_DOT_WITH_VALUEB_NULL_ID = 24; |
| |
| /** |
| * Identifies a problem where we have x.y and x is a map. In this case |
| * the recommend syntax is x['y'] |
| */ |
| public final static int BINARY_OP_DOT_WITH_DOTTED_KEY_SHOULD_USE_ARRAY_ID = 25; |
| |
| /** |
| * Indicates that a numeric array accessor is being used with a value |
| * which is either < 0 or may be greater than the assumed size of the array |
| */ |
| public final static int POSSIBLE_ARRAY_INDEX_OUT_OF_BOUNDS_ID = 26; |
| |
| /** |
| * Identifies the problem where an expr like bean.enumProp == 'blah' |
| * but 'blah' does not match any of the possible enum constants, meaning |
| * that the operation will always resolve to a constant value (in this case false) |
| */ |
| public final static int BINARY_COMPARISON_WITH_ENUM_ALWAYS_SAME_ID = 27; |
| |
| /** |
| * Identifies a problem where two enum variables are compared but the enums are |
| * not compatible. i.e. bean.enum1 < bean.enum2. Enum.compareTo() may throw |
| * an exception in this case (CCE). |
| */ |
| public final static int BINARY_OP_COMPARISON_OF_ENUMS_INCOMPATIBLE_ID = 28; |
| |
| /** |
| * Indicates a situation such as x.y where x is a bundle and |
| * 'x.y.z' exists, but x.y while partially valid, does not have a value |
| * associated. |
| */ |
| public final static int MEMBER_IS_INTERMEDIATE_ID = 29; |
| |
| /** |
| * Count of ids |
| */ |
| public final static int NUM_IDS = 30; |
| |
| /** |
| * @param operatorName |
| * @return a configured diagnostic |
| */ |
| public Diagnostic create_BINARY_OP_BOTH_OPERANDS_NULL(final String operatorName) |
| { |
| final String message = NLS.bind( |
| Messages.BINARY_OP_BOTH_OPERANDS_NULL, operatorName); |
| return create(BINARY_OP_BOTH_OPERANDS_NULL_ID, message); |
| } |
| |
| private static Diagnostic DIAGNOSTIC_POSSIBLE_DIV_BY_ZERO; |
| |
| /** |
| * @return a configured diagnostic |
| */ |
| public Diagnostic create_BINARY_OP_POSSIBLE_DIVISION_BY_ZERO() |
| { |
| if (DIAGNOSTIC_POSSIBLE_DIV_BY_ZERO == null) |
| { |
| final String message = Messages.POSSIBLE_DIV_BY_ZERO; |
| DIAGNOSTIC_POSSIBLE_DIV_BY_ZERO = |
| create(BINARY_OP_POSSIBLE_DIVISION_BY_ZERO_ID, message); |
| } |
| return DIAGNOSTIC_POSSIBLE_DIV_BY_ZERO; |
| } |
| |
| /** |
| * @param operatorName |
| * @return a configured diagnostic |
| */ |
| public Diagnostic create_BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION(final String operatorName) |
| { |
| final String message = |
| NLS.bind(Messages.BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION, operatorName); |
| return create(BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID, message); |
| } |
| |
| /** |
| * @param operatorName |
| * @param value |
| * @return a configured diagnostic |
| */ |
| public Diagnostic create_BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME(final String operatorName, final String value) |
| { |
| final String message = |
| NLS.bind(Messages.BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME,operatorName, value); |
| return create(BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME_ID, message); |
| } |
| |
| /** |
| * @param value |
| * @return a configured diagnostic |
| */ |
| public Diagnostic create_BINARY_OP_EQUALITY_COMP_WITH_NULL_ALWAYS_EVAL_SAME(final String value) |
| { |
| final String message = |
| NLS.bind(Messages.BINARY_OP_EQUALITY_COMP_WITH_NULL_ALWAYS_EVAL_SAME, value); |
| return create(BINARY_OP_EQUALITY_COMP_WITH_NULL_ALWAYS_EVAL_SAME_ID, message); |
| } |
| |
| /** |
| * @param whichArgument |
| * @return a configured diagnostic |
| */ |
| public Diagnostic create_BINARY_OP_CANNOT_COERCE_ARGUMENT_TO_BOOLEAN(final String whichArgument) |
| { |
| final String message = |
| NLS.bind(Messages.BINARY_OP_CANNOT_COERCE_ARGUMENT_TO_BOOLEAN, whichArgument); |
| return create(BINARY_OP_CANNOT_COERCE_ARGUMENT_TO_BOOLEAN_ID, message); |
| } |
| |
| /** |
| * @param shortCircuitValue |
| * @param operatorName |
| * @return a configured diagnostic |
| */ |
| public Diagnostic create_BINARY_OP_FIRST_ARGUMENT_SHORT_CIRCUITS(boolean shortCircuitValue, String operatorName) |
| { |
| final String message = |
| NLS.bind(Messages.BINARY_OP_FIRST_ARGUMENT_SHORT_CIRCUITS, |
| Boolean.valueOf(shortCircuitValue), operatorName); |
| return create(BINARY_OP_FIRST_ARGUMENT_SHORT_CIRCUITS_ID, message); |
| } |
| |
| /** |
| * @param shortCircuitValue |
| * @param operatorName |
| * @return a configured diagnostic |
| */ |
| public Diagnostic create_BINARY_OP_SECOND_ARGUMENT_ALWAYS_EVAL_SAME(final boolean shortCircuitValue, final String operatorName) |
| { |
| final String message = |
| NLS.bind(Messages.BINARY_OP_SECOND_ARGUMENT_ALWAYS_EVAL_SAME, |
| Boolean.valueOf(shortCircuitValue), operatorName); |
| |
| return create(BINARY_OP_SECOND_ARGUMENT_ALWAYS_EVAL_SAME_ID, message); |
| } |
| |
| private static Diagnostic DIAGNOSTIC_NO_AVAILABLE_TYPE_COERCION; |
| |
| /** |
| * @return a configured diagnostic |
| */ |
| public Diagnostic create_BINARY_OP_NO_AVAILABLE_TYPE_COERCION() |
| { |
| if (DIAGNOSTIC_NO_AVAILABLE_TYPE_COERCION == null) |
| { |
| DIAGNOSTIC_NO_AVAILABLE_TYPE_COERCION = |
| create(BINARY_OP_NO_AVAILABLE_TYPE_COERCION_ID, |
| Messages.BINARY_OP_NO_AVAILABLE_TYPE_COERCION); |
| } |
| |
| return DIAGNOSTIC_NO_AVAILABLE_TYPE_COERCION; |
| } |
| |
| private static Diagnostic DIAGNOSTIC_COULD_NOT_COERCE_LITERALS; |
| |
| /** |
| * @return a configured diagnostic |
| */ |
| public Diagnostic create_BINARY_OP_COULD_NOT_COERCE_LITERALS_TO_NUMBERS() |
| { |
| if (DIAGNOSTIC_COULD_NOT_COERCE_LITERALS == null) |
| { |
| DIAGNOSTIC_COULD_NOT_COERCE_LITERALS = |
| create(BINARY_OP_COULD_NOT_COERCE_LITERALS_TO_NUMBERS_ID, |
| Messages.BINARY_OP_COULD_NOT_COERCE_LITERALS_TO_NUMBERS); |
| } |
| |
| return DIAGNOSTIC_COULD_NOT_COERCE_LITERALS; |
| } |
| |
| /** |
| * @param operatorName |
| * @param value |
| * @return a configured diagnostic |
| */ |
| public Diagnostic create_UNARY_OP_CONSTANT_EXPRESSION_EVAL_SAME_ID(final String operatorName, final String value) |
| { |
| final String message = |
| NLS.bind(Messages.UNARY_OP_CONSTANT_EXPRESSION_EVAL_SAME, |
| operatorName, value); |
| return create(UNARY_OP_CONSTANT_EXPRESSION_EVAL_SAME_ID, message); |
| } |
| |
| /** |
| * @return a configured diagnostic |
| */ |
| public Diagnostic create_UNARY_OP_EMPTY_ALWAYS_FALSE_ON_TYPE() |
| { |
| return create(UNARY_OP_EMPTY_ALWAYS_FALSE_ON_TYPE_ID, |
| Messages.UNARY_OP_EMPTY_ALWAYS_FALSE_ON_TYPE); |
| } |
| |
| /** |
| * @return a configured diagnostic |
| */ |
| public Diagnostic create_UNARY_OP_MINUS_ON_NULL_ALWAYS_ZERO() |
| { |
| return create(UNARY_OP_MINUS_ON_NULL_ALWAYS_ZERO_ID, |
| Messages.UNARY_OP_MINUS_ON_NULL_ALWAYS_ZERO); |
| } |
| |
| /** |
| * @param operatorName |
| * @return a configured diagnostic |
| */ |
| public Diagnostic create_UNARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION(final String operatorName) |
| { |
| final String message = |
| NLS.bind(Messages.UNARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION, |
| operatorName); |
| return create(UNARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION_ID, message); |
| } |
| |
| /** |
| * @param operatorName |
| * @return a configured diagnostic |
| */ |
| public Diagnostic create_UNARY_OP_STRING_CONVERSION_NOT_GUARANTEED(final String operatorName) |
| { |
| final String message = |
| NLS.bind(Messages.UNARY_OP_STRING_CONVERSION_NOT_GUARANTEED, |
| operatorName); |
| return create(UNARY_OP_STRING_CONVERSION_NOT_GUARANTEED_ID, message); |
| } |
| |
| /** |
| * @return a configured diagnostic |
| */ |
| public Diagnostic create_UNARY_OP_CANNOT_COERCE_ARGUMENT_TO_BOOLEAN() |
| { |
| return create(UNARY_OP_CANNOT_COERCE_ARGUMENT_TO_BOOLEAN_ID, |
| Messages.UNARY_OP_CANNOT_COERCE_ARGUMENT_TO_BOOLEAN); |
| } |
| |
| /** |
| * @param result |
| * @param whichSelected |
| * @return a configured diagnostic |
| */ |
| public Diagnostic create_TERNARY_OP_CHOICE_IS_ALWAYS_SAME(boolean result, String whichSelected) |
| { |
| final String message = |
| NLS.bind(Messages.TERNARY_OP_CHOICE_IS_ALWAYS_SAME, |
| Boolean.valueOf(result), whichSelected); |
| return create(TERNARY_OP_CHOICE_IS_ALWAYS_SAME_ID, message); |
| } |
| |
| /** |
| * @return a configured diagnostic |
| */ |
| public Diagnostic create_TERNARY_OP_CANNOT_COERCE_CHOICE_TO_BOOLEAN() |
| { |
| return create(TERNARY_OP_CANNOT_COERCE_CHOICE_TO_BOOLEAN_ID, |
| Messages.TERNARY_OP_CANNOT_COERCE_CHOICE_TO_BOOLEAN_ID); |
| } |
| |
| /** |
| * Method bindings cannot participate in expressions involving operators |
| * Per JSP 1.1 spec section 5.2.1 |
| * |
| * @return a configured message |
| */ |
| public Diagnostic create_CANNOT_APPLY_OPERATOR_TO_METHOD_BINDING() |
| { |
| return create(CANNOT_APPLY_OPERATOR_TO_METHOD_BINDING_ID, |
| Messages.CANNOT_APPLY_OPERATORS_TO_MB); |
| } |
| |
| /** |
| * @param curMemberSymbol |
| * @param owningMember |
| * @return a configured message |
| */ |
| public Diagnostic create_MEMBER_NOT_FOUND(String curMemberSymbol, String owningMember) |
| { |
| return create(MEMBER_NOT_FOUND_ID, |
| NLS.bind(Messages.VM_PROP_NAME_NOT_FOUND, curMemberSymbol, owningMember)); |
| } |
| |
| /** |
| * @param variableName |
| * @return a configured message |
| */ |
| public Diagnostic create_VARIABLE_NOT_FOUND(String variableName) |
| { |
| return create(VARIABLE_NOT_FOUND_ID |
| , NLS.bind(Messages.VM_ROOT_NAME_NOT_FOUND, variableName)); |
| } |
| |
| /** |
| * @return a configured message |
| */ |
| public Diagnostic create_MISSING_CLOSING_EXPR_BRACKET() |
| { |
| return create(MISSING_CLOSING_EXPR_BRACKET_ID |
| , Messages.MISSING_CLOSING_EXPR_BRACKET); |
| } |
| |
| /** |
| * @return a configured message |
| */ |
| public Diagnostic create_GENERAL_SYNTAX_ERROR() |
| { |
| return create(GENERAL_SYNTAX_ERROR_ID, Messages.GENERAL_SYNTAX_ERROR); |
| } |
| |
| /** |
| * @return a configured message |
| */ |
| public Diagnostic create_EMPTY_EL_EXPRESSION() |
| { |
| return create(EMPTY_EL_EXPRESSION_ID, Messages.EMPTY_EL_EXPRESSION); |
| } |
| |
| /** |
| * @param operatorName |
| * @return a configured diagnostic |
| */ |
| public Diagnostic create_BINARY_OP_DOT_WITH_VALUEB_NULL(final String operatorName) |
| { |
| return create(BINARY_OP_DOT_WITH_VALUEB_NULL_ID |
| , Messages.bind(Messages.BINARY_OP_DOT_WITH_VALUEB_NULL, operatorName)); |
| } |
| |
| /** |
| * @param valAName |
| * @param valueBName |
| * @return a configured diagnostic |
| */ |
| public Diagnostic create_BINARY_OP_DOT_WITH_VALUEA_MAP_SHOULD_USE_ARRAY(final String valAName, final String valueBName) |
| { |
| final Object[] formatArgs = new Object[] {valAName, valueBName}; |
| return create(BINARY_OP_DOT_WITH_DOTTED_KEY_SHOULD_USE_ARRAY_ID, |
| MessageFormat.format(Messages.BINARY_OP_DOT_WITH_DOTTED_KEY_SHOULD_USE_ARRAY,formatArgs)); |
| } |
| |
| /** |
| * @param value |
| * @return an array index out of bounds diagnostic |
| */ |
| public Diagnostic create_POSSIBLE_ARRAY_INDEX_OUT_OF_BOUNDS(final Integer value) |
| { |
| final Object[] formatArgs = new Object[] {value}; |
| |
| return create(POSSIBLE_ARRAY_INDEX_OUT_OF_BOUNDS_ID |
| , MessageFormat.format(Messages.POSSIBLE_ARRAY_INDEX_OUT_OF_BOUNDS,formatArgs)); |
| } |
| |
| /** |
| * @param operatorName |
| * @param invariantResult |
| * @param enumName |
| * @param fieldName |
| * @return a diagnostic |
| */ |
| public Diagnostic create_BINARY_COMPARISON_WITH_ENUM_AND_CONST_ALWAYS_SAME(final String operatorName, final boolean invariantResult, final String enumName, final String fieldName) |
| { |
| return create(BINARY_COMPARISON_WITH_ENUM_ALWAYS_SAME_ID |
| , MessageFormat.format(Messages.BINARY_COMPARISON_WITH_ENUM_AND_CONST_ALWAYS_SAME |
| , new Object[] {operatorName |
| , Boolean.valueOf(invariantResult), enumName, fieldName})); |
| } |
| |
| /** |
| * @param operatorName |
| * @param invariantResult |
| * @param enumName1 |
| * @param enumName2 |
| * @return a diagnostic |
| */ |
| public Diagnostic create_BINARY_COMPARISON_WITH_TWO_ENUMS_ALWAYS_SAME(final String operatorName, final boolean invariantResult, final String enumName1, final String enumName2) |
| { |
| return create(BINARY_COMPARISON_WITH_ENUM_ALWAYS_SAME_ID |
| , MessageFormat.format(Messages.BINARY_COMPARISON_WITH_TWO_ENUMS_ALWAYS_SAME |
| , new Object[] {operatorName |
| , Boolean.valueOf(invariantResult), enumName1, enumName2})); |
| } |
| |
| /** |
| * @param operatorName |
| * @param invariantResult |
| * @param enumName |
| * @param nonEnum |
| * @return a diagnostic |
| */ |
| public Diagnostic create_BINARY_COMPARISON_WITH_ENUM_AND_UNCOERCABLE_NONCONST_ALWAYS_SAME(final String operatorName, final boolean invariantResult, final String enumName, final String nonEnum) |
| { |
| return create(BINARY_COMPARISON_WITH_ENUM_ALWAYS_SAME_ID |
| , MessageFormat.format(Messages.BINARY_COMPARISON_WITH_ENUM_AND_UNCOERCABLE_NONCONST_ALWAYS_SAME |
| , new Object[] {operatorName |
| , Boolean.valueOf(invariantResult), enumName, nonEnum})); |
| } |
| |
| /** |
| * @return a diagnostic |
| */ |
| public Diagnostic create_BINARY_OP_COMPARISON_OF_ENUMS_INCOMPATIBLE() |
| { |
| return create(BINARY_OP_COMPARISON_OF_ENUMS_INCOMPATIBLE_ID |
| , Messages.BINARY_OP_COMPARISON_OF_ENUMS_INCOMPATIBLE); |
| } |
| |
| /** |
| * @param intermediateMemberName |
| * @return a diagnostic |
| */ |
| public Diagnostic create_MEMBER_IS_INTERMEDIATE(final String intermediateMemberName) |
| { |
| return create(MEMBER_IS_INTERMEDIATE_ID |
| , NLS.bind(Messages.MEMBER_IS_INTERMEDIATE |
| , intermediateMemberName)); |
| } |
| |
| private BasicDiagnostic create(int diagnosticId, String message) |
| { |
| final int severity = ELValidationPreferences.getDefaultSeverity(diagnosticId); |
| return new BasicDiagnostic(severity, SOURCE_ID |
| , diagnosticId |
| , message |
| , null); |
| } |
| } |
